activemerchant 1.126.0 → 1.129.0

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

@@ -17,12 +17,16 @@ module ActiveMerchant #:nodoc:
       self.homepage_url = 'https://www.adyen.com/'
       self.display_name = 'Adyen'
 
-      PAYMENT_API_VERSION = 'v64'
-      RECURRING_API_VERSION = 'v49'
+      PAYMENT_API_VERSION = 'v68'
+      RECURRING_API_VERSION = 'v68'
 
       STANDARD_ERROR_CODE_MAPPING = {
+        '0' => STANDARD_ERROR_CODE[:processing_error],
+        '10' => STANDARD_ERROR_CODE[:config_error],
+        '100' => STANDARD_ERROR_CODE[:invalid_amount],
         '101' => STANDARD_ERROR_CODE[:incorrect_number],
         '103' => STANDARD_ERROR_CODE[:invalid_cvc],
+        '104' => STANDARD_ERROR_CODE[:incorrect_address],
         '131' => STANDARD_ERROR_CODE[:incorrect_address],
         '132' => STANDARD_ERROR_CODE[:incorrect_address],
         '133' => STANDARD_ERROR_CODE[:incorrect_address],
@@ -62,6 +66,8 @@ module ActiveMerchant #:nodoc:
         add_recurring_contract(post, options)
         add_network_transaction_reference(post, options)
         add_application_info(post, options)
+        add_level_2_data(post, options)
+        add_level_3_data(post, options)
         commit('authorise', post, options)
       end
 
@@ -71,6 +77,7 @@ module ActiveMerchant #:nodoc:
         add_reference(post, authorization, options)
         add_splits(post, options)
         add_network_transaction_reference(post, options)
+        add_shopper_statement(post, options)
         commit('capture', post, options)
       end
 
@@ -117,7 +124,7 @@ module ActiveMerchant #:nodoc:
         add_extra_data(post, credit_card, options)
         add_stored_credentials(post, credit_card, options)
         add_address(post, options)
-
+        add_network_transaction_reference(post, options)
         options[:recurring_contract_type] ||= 'RECURRING'
         add_recurring_contract(post, options)
 
@@ -216,7 +223,7 @@ module ActiveMerchant #:nodoc:
       NETWORK_TOKENIZATION_CARD_SOURCE = {
         'apple_pay' => 'applepay',
         'android_pay' => 'androidpay',
-        'google_pay' => 'paywithgoogle'
+        'google_pay' => 'googlepay'
       }
 
       def add_extra_data(post, payment, options)
@@ -242,6 +249,48 @@ module ActiveMerchant #:nodoc:
         add_merchant_data(post, options)
       end
 
+      def extract_and_transform(mapper, from)
+        mapper.each_with_object({}) do |key_map, hsh|
+          key, item_key = key_map[0], key_map[1]
+          hsh[key] = from[item_key.to_sym]
+        end
+      end
+
+      def add_level_2_data(post, options)
+        return unless options[:level_2_data].present?
+
+        mapper = {
+          "enhancedSchemeData.totalTaxAmount": 'total_tax_amount',
+          "enhancedSchemeData.customerReference": 'customer_reference'
+        }
+        post[:additionalData].merge!(extract_and_transform(mapper, options[:level_2_data]))
+      end
+
+      def add_level_3_data(post, options)
+        return unless options[:level_3_data].present?
+
+        mapper = { "enhancedSchemeData.freightAmount": 'freight_amount',
+          "enhancedSchemeData.destinationStateProvinceCode": 'destination_state_province_code',
+          "enhancedSchemeData.shipFromPostalCode": 'ship_from_postal_code',
+          "enhancedSchemeData.orderDate": 'order_date',
+          "enhancedSchemeData.destinationPostalCode": 'destination_postal_code',
+          "enhancedSchemeData.destinationCountryCode": 'destination_country_code',
+          "enhancedSchemeData.dutyAmount": 'duty_amount' }
+
+        post[:additionalData].merge!(extract_and_transform(mapper, options[:level_3_data]))
+
+        item_detail_keys = %w[description product_code quantity unit_of_measure unit_price discount_amount total_amount commodity_code]
+        if options[:level_3_data][:items].present?
+          options[:level_3_data][:items].last(9).each.with_index(1) do |item, index|
+            mapper = item_detail_keys.each_with_object({}) do |key, hsh|
+              hsh["enhancedSchemeData.itemDetailLine#{index}.#{key.camelize(:lower)}"] = key
+            end
+            post[:additionalData].merge!(extract_and_transform(mapper, item))
+          end
+        end
+        post[:additionalData].compact!
+      end
+
       def add_shopper_data(post, options)
         post[:shopperEmail] = options[:email] if options[:email]
         post[:shopperEmail] = options[:shopper_email] if options[:shopper_email]
@@ -251,6 +300,14 @@ module ActiveMerchant #:nodoc:
         post[:additionalData][:updateShopperStatement] = options[:update_shopper_statement] if options[:update_shopper_statement]
       end
 
+      def add_shopper_statement(post, options)
+        return unless options[:shopper_statement]
+
+        post[:additionalData] = {
+          shopperStatement: options[:shopper_statement]
+        }
+      end
+
       def add_merchant_data(post, options)
         post[:additionalData][:subMerchantID] = options[:sub_merchant_id] if options[:sub_merchant_id]
         post[:additionalData][:subMerchantName] = options[:sub_merchant_name] if options[:sub_merchant_name]
@@ -387,7 +444,7 @@ module ActiveMerchant #:nodoc:
         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_mpi_data_for_network_tokenization_card(post, payment, options) if payment.is_a?(NetworkTokenizationCreditCard)
           add_card(post, payment)
         end
       end
@@ -396,7 +453,7 @@ module ActiveMerchant #:nodoc:
         bank = {
           bankAccountNumber: bank_account.account_number,
           ownerName: bank_account.name,
-          countryCode: options[:billing_address][:country]
+          countryCode: options[:billing_address].try(:[], :country)
         }
 
         action == 'refundWithData' ? bank[:iban] = bank_account.routing_number : bank[:bankLocationId] = bank_account.routing_number
@@ -438,7 +495,9 @@ module ActiveMerchant #:nodoc:
         post[:originalReference] = original_reference
       end
 
-      def add_mpi_data_for_network_tokenization_card(post, payment)
+      def add_mpi_data_for_network_tokenization_card(post, payment, options)
+        return if options[:skip_mpi_data] == 'Y'
+
         post[:mpiData] = {}
         post[:mpiData][:authenticationResponse] = 'Y'
         post[:mpiData][:cavv] = payment.payment_cryptogram
@@ -616,7 +675,7 @@ module ActiveMerchant #:nodoc:
 
       def success_from(action, response, options)
         if %w[RedirectShopper ChallengeShopper].include?(response.dig('resultCode')) && !options[:execute_threed] && !options[:threed_dynamic]
-          response['refusalReason'] = 'Received unexpected 3DS authentication response. Use the execute_threed and/or threed_dynamic options to initiate a proper 3DS flow.'
+          response['refusalReason'] = 'Received unexpected 3DS authentication response, but a 3DS initiation flag was not included in the request.'
           return false
         end
         case action.to_s

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

@@ -21,6 +21,12 @@ module ActiveMerchant #:nodoc:
         void: '/pa/payment_intents/%{id}/cancel'
       }
 
+      # Provided by Airwallex for testing purposes
+      TEST_NETWORK_TRANSACTION_IDS = {
+        visa: '123456789012345',
+        master: 'MCC123ABC0101'
+      }
+
       def initialize(options = {})
         requires!(options, :client_id, :client_api_key)
         @client_id = options[:client_id]
@@ -30,17 +36,15 @@ module ActiveMerchant #:nodoc:
       end
 
       def purchase(money, card, options = {})
-        requires!(options, :return_url)
-
         payment_intent_id = create_payment_intent(money, options)
         post = {
           'request_id' => request_id(options),
-          'merchant_order_id' => merchant_order_id(options),
-          'return_url' => options[:return_url]
+          'merchant_order_id' => merchant_order_id(options)
         }
         add_card(post, card, options)
         add_descriptor(post, options)
         add_stored_credential(post, options)
+        add_return_url(post, options)
         post['payment_method_options'] = { 'card' => { 'auto_capture' => false } } if authorization_only?(options)
 
         add_three_ds(post, options)
@@ -108,15 +112,19 @@ module ActiveMerchant #:nodoc:
       private
 
       def request_id(options)
-        options[:request_id] || generate_timestamp
+        options[:request_id] || generate_uuid
       end
 
       def merchant_order_id(options)
-        options[:merchant_order_id] || options[:order_id] || generate_timestamp
+        options[:merchant_order_id] || options[:order_id] || generate_uuid
       end
 
-      def generate_timestamp
-        (Time.now.to_f.round(2) * 100).to_i.to_s
+      def add_return_url(post, options)
+        post[:return_url] = options[:return_url] if options[:return_url]
+      end
+
+      def generate_uuid
+        SecureRandom.uuid
       end
 
       def setup_access_token
@@ -134,13 +142,19 @@ module ActiveMerchant #:nodoc:
         base_url + ENDPOINTS[action].to_s % { id: id }
       end
 
+      def add_referrer_data(post)
+        post[:referrer_data] = { type: 'spreedly' }
+      end
+
       def create_payment_intent(money, options = {})
         post = {}
         add_invoice(post, money, options)
         add_order(post, options)
         post[:request_id] = "#{request_id(options)}_setup"
-        post[:merchant_order_id] = "#{merchant_order_id(options)}_setup"
+        post[:merchant_order_id] = merchant_order_id(options)
+        add_referrer_data(post)
         add_descriptor(post, options)
+        post['payment_method_options'] = { 'card' => { 'risk_control' => { 'three_ds_action' => 'SKIP_3DS' } } } if options[:skip_3ds]
 
         response = commit(:setup, post)
         raise ArgumentError.new(response.message) unless response.success?
@@ -199,7 +213,8 @@ module ActiveMerchant #:nodoc:
             'expiry_year' => card.year.to_s,
             'number' => card.number.to_s,
             'name' => card.name,
-            'cvc' => card.verification_value
+            'cvc' => card.verification_value,
+            'brand' => card.brand
           }
         }
         add_billing(post, card, options)
@@ -240,10 +255,23 @@ module ActiveMerchant #:nodoc:
           external_recurring_data[:merchant_trigger_reason] = 'unscheduled'
         end
 
-        external_recurring_data[:original_transaction_id] = stored_credential.dig(:network_transaction_id)
+        external_recurring_data[:original_transaction_id] = test_mit?(options) ? test_network_transaction_id(post) : stored_credential.dig(:network_transaction_id)
         external_recurring_data[:triggered_by] = stored_credential.dig(:initiator) == 'cardholder' ? 'customer' : 'merchant'
       end
 
+      def test_network_transaction_id(post)
+        case post['payment_method']['card']['brand']
+        when 'visa'
+          TEST_NETWORK_TRANSACTION_IDS[:visa]
+        when 'master'
+          TEST_NETWORK_TRANSACTION_IDS[:master]
+        end
+      end
+
+      def test_mit?(options)
+        test? && options.dig(:stored_credential, :initiator) == 'merchant'
+      end
+
       def add_three_ds(post, options)
         return unless three_d_secure = options[:three_d_secure]
 
@@ -293,6 +321,7 @@ module ActiveMerchant #:nodoc:
 
       def commit(action, post, id = nil)
         url = build_request_url(action, id)
+
         post_headers = { 'Authorization' => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
         response = parse(ssl_post(url, post_data(post), post_headers))
 

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

@@ -0,0 +1,256 @@
+require 'jose'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class AleloGateway < Gateway
+      class_attribute :prelive_url
+
+      self.test_url = 'https://sandbox-api.alelo.com.br/alelo/sandbox/'
+      self.live_url = 'https://api.alelo.com.br/alelo/prd/'
+      self.prelive_url = 'https://api.homologacaoalelo.com.br/alelo/uat/'
+
+      self.supported_countries = ['BR']
+      self.default_currency = 'BRL'
+      self.supported_cardtypes = %i[visa master american_express discover]
+
+      self.homepage_url = 'https://www.alelo.com.br'
+      self.display_name = 'Alelo'
+
+      def initialize(options = {})
+        requires!(options, :client_id, :client_secret)
+        super
+      end
+
+      def purchase(money, payment, options = {})
+        post = {}
+        add_order(post, options)
+        add_amount(post, money)
+        add_payment(post, payment)
+        add_geolocation(post, options)
+        add_extra_data(post, options)
+
+        commit('capture/transaction', post, options)
+      end
+
+      def refund(money, authorization, options = {})
+        request_id = authorization.split('#').first
+        options[:http] = { method: :put, prevent_encrypt: true }
+        commit('capture/transaction/refund', { requestId: request_id }, options, :put)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        force_utf8(transcript.encode).
+          gsub(%r((Authorization: Bearer )[\w -]+), '\1[FILTERED]').
+          gsub(%r((client_id=|Client-Id:)[\w -]+), '\1[FILTERED]\2').
+          gsub(%r((client_secret=|Client-Secret:)[\w -]+), '\1[FILTERED]\2').
+          gsub(%r((access_token\":\")[^\"]*), '\1[FILTERED]').
+          gsub(%r((publicKey\":\")[^\"]*), '\1[FILTERED]')
+      end
+
+      private
+
+      def force_utf8(string)
+        return nil unless string
+
+        # binary = string.encode('BINARY', invalid: :replace, undef: :replace, replace: '?')
+        string.encode('UTF-8', invalid: :replace, undef: :replace, replace: '?')
+      end
+
+      def add_amount(post, money)
+        post[:amount] = amount(money).to_f
+      end
+
+      def add_order(post, options)
+        post[:requestId] = options[:order_id]
+      end
+
+      def add_extra_data(post, options)
+        post.merge!({
+          establishmentCode: options[:establishment_code],
+          playerIdentification: options[:player_identification],
+          captureType: '3', # send fixed value 3 to ecommerce
+          subMerchantCode: options[:sub_merchant_mcc],
+          externalTraceNumber: options[:external_trace_number]
+        }.compact)
+      end
+
+      def add_geolocation(post, options)
+        return if options[:geo_latitude].blank? || options[:geo_longitude].blank?
+
+        post.merge!(geolocation: {
+          latitude: options[:geo_latitude],
+          longitude: options[:geo_longitude]
+        })
+      end
+
+      def add_payment(post, payment)
+        post.merge!({
+          cardNumber: payment.number,
+          cardholderName: payment.name,
+          expirationMonth: payment.month,
+          expirationYear: format(payment.year, :two_digits).to_i,
+          securityCode: payment.verification_value
+        })
+      end
+
+      def fetch_access_token
+        params = {
+          grant_type: 'client_credentials',
+          client_id: @options[:client_id],
+          client_secret: @options[:client_secret],
+          scope: '/capture'
+        }
+
+        headers = {
+          'Accept' => 'application/json',
+          'Content-Type' => 'application/x-www-form-urlencoded'
+        }
+
+        parsed = parse(ssl_post(url('captura-oauth-provider/oauth/token'), post_data(params), headers))
+        Response.new(true, parsed[:access_token], parsed)
+      end
+
+      def remote_encryption_key(access_token)
+        response = parse(ssl_get(url('capture/key'), request_headers(access_token)))
+        Response.new(true, response[:publicKey], response)
+      end
+
+      def ensure_credentials(try_again = true)
+        multiresp = MultiResponse.new
+        access_token = @options[:access_token]
+        key = @options[:encryption_key]
+        uuid = @options[:encryption_uuid]
+
+        if access_token.blank?
+          multiresp.process { fetch_access_token }
+          access_token = multiresp.message
+          key = nil
+          uuid = nil
+        end
+
+        if key.blank?
+          multiresp.process { remote_encryption_key(access_token) }
+          key = multiresp.message
+          uuid = multiresp.params['uuid']
+        end
+
+        {
+          key: key,
+          uuid: uuid,
+          access_token: access_token,
+          multiresp: multiresp.responses.present? ? multiresp : nil
+        }
+      rescue ResponseError => error
+        # retry to generate a new access_token when the provided one is expired
+        raise error unless try_again && %w(401 404).include?(error.response.code) && @options[:access_token].present?
+
+        @options.delete(:access_token)
+        @options.delete(:encryption_key)
+        ensure_credentials false
+      end
+
+      def encrypt_payload(body, credentials, options)
+        key = OpenSSL::PKey::RSA.new(Base64.decode64(credentials[:key]))
+        jwk = JOSE::JWK.from_key(key)
+        alg_enc = { 'alg' => 'RSA-OAEP-256', 'enc' => 'A128CBC-HS256' }
+
+        token = JOSE::JWE.block_encrypt(jwk, body.to_json, alg_enc).compact
+
+        encrypted_body = {
+          token: token,
+          uuid: credentials[:uuid]
+        }
+
+        encrypted_body.to_json
+      end
+
+      def parse(body)
+        JSON.parse(body, symbolize_names: true)
+      end
+
+      def post_data(params)
+        params.map { |k, v| "#{k}=#{CGI.escape(v.to_s)}" }.join('&')
+      end
+
+      def commit(action, body, options, try_again = true)
+        credentials = ensure_credentials
+        payload = encrypt_payload(body, credentials, options)
+
+        if options.dig :http, :method
+          payload = body.to_json if options.dig :http, :prevent_encrypt
+          response = parse ssl_request(options[:http][:method], url(action), payload, request_headers(credentials[:access_token]))
+        else
+          response = parse ssl_post(url(action), payload, request_headers(credentials[:access_token]))
+        end
+
+        resp = Response.new(
+          success_from(action, response),
+          message_from(response),
+          response,
+          authorization: authorization_from(response, options),
+          test: test?
+        )
+
+        return resp unless credentials[:multiresp].present?
+
+        multiresp = credentials[:multiresp]
+        resp.params.merge!({
+          'access_token' => credentials[:access_token],
+          'encryption_key' => credentials[:key],
+          'encryption_uuid' => credentials[:uuid]
+        })
+        multiresp.process { resp }
+
+        multiresp
+      rescue ActiveMerchant::ResponseError => e
+        # Retry on a possible expired encryption key
+        if try_again && %w(401 404).include?(e.response.code) && @options[:encryption_key].present?
+          @options.delete(:encryption_key)
+          commit(action, body, options, false)
+        else
+          res = parse(e.response.body)
+          Response.new(false, res[:messageUser] || res[:error], res, test: test?)
+        end
+      end
+
+      def success_from(action, response)
+        case action
+        when 'capture/transaction/refund'
+          response[:status] == 'ESTORNADA'
+        when 'capture/transaction'
+          response[:status] == 'CONFIRMADA'
+        else
+          false
+        end
+      end
+
+      def message_from(response)
+        response[:messages] || response[:messageUser]
+      end
+
+      def authorization_from(response, options)
+        [response[:requestId]].join('#')
+      end
+
+      def url(action)
+        return prelive_url if @options[:url_override] == 'prelive'
+
+        "#{test? ? test_url : live_url}#{action}"
+      end
+
+      def request_headers(access_token)
+        {
+          'Accept' => 'application/json',
+          'X-IBM-Client-Id' => @options[:client_id],
+          'X-IBM-Client-Secret' => @options[:client_secret],
+          'Content-Type' => 'application/json',
+          'Authorization' => "Bearer #{access_token}"
+        }
+      end
+    end
+  end
+end

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

@@ -90,7 +90,6 @@ module ActiveMerchant
       }.freeze
 
       APPLE_PAY_DATA_DESCRIPTOR = 'COMMON.APPLE.INAPP.PAYMENT'
-
       PAYMENT_METHOD_NOT_SUPPORTED_ERROR = '155'
       INELIGIBLE_FOR_ISSUING_CREDIT_ERROR = '54'
 
@@ -176,11 +175,29 @@ module ActiveMerchant
         end
       end
 
-      def verify(credit_card, options = {})
+      def verify(payment_method, options = {})
+        amount = amount_for_verify(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 { authorize(amount, payment_method, options) }
+          r.process(:ignore_result) { void(r.authorization, options) } unless amount == 0
         end
+      rescue ArgumentError => e
+        Response.new(false, e.message)
+      end
+
+      def amount_for_verify(options)
+        return 100 unless options[:verify_amount].present?
+
+        amount = options[:verify_amount]
+        raise ArgumentError.new 'verify_amount value must be an integer' unless amount.is_a?(Integer) && !amount.negative? || amount.is_a?(String) && amount.match?(/^\d+$/) && !amount.to_i.negative?
+        raise ArgumentError.new 'Billing address including zip code is required for a 0 amount verify' if amount.to_i.zero? && !validate_billing_address_values?(options)
+
+        amount.to_i
+      end
+
+      def validate_billing_address_values?(options)
+        options.dig(:billing_address, :zip).present? && options.dig(:billing_address, :address1).present?
       end
 
       def store(credit_card, options = {})

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

@@ -76,6 +76,7 @@ module ActiveMerchant #:nodoc:
         add_transaction_type(post, :authorization)
         add_customer_ip(post, options)
         add_recurring_payment(post, options)
+        add_three_ds(post, options)
         commit(post)
       end
 
@@ -88,6 +89,7 @@ module ActiveMerchant #:nodoc:
         add_transaction_type(post, purchase_action(source))
         add_customer_ip(post, options)
         add_recurring_payment(post, options)
+        add_three_ds(post, options)
         commit(post)
       end
 
@@ -215,6 +217,22 @@ module ActiveMerchant #:nodoc:
       def build_response(*args)
         Response.new(*args)
       end
+
+      def add_three_ds(post, options)
+        return unless three_d_secure = options[:three_d_secure]
+
+        post[:SecureXID] = (three_d_secure[:ds_transaction_id] || three_d_secure[:xid]) if three_d_secure.slice(:ds_transaction_id, :xid).values.any?
+        post[:SecureECI] = formatted_three_ds_eci(three_d_secure[:eci]) if three_d_secure[:eci].present?
+        post[:SecureCAVV] = three_d_secure[:cavv] if three_d_secure[:cavv].present?
+      end
+
+      def formatted_three_ds_eci(val)
+        case val
+        when '05', '02' then 5
+        when '06', '01' then 6
+        else val.to_i
+        end
+      end
     end
   end
 end

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

@@ -68,6 +68,8 @@ module ActiveMerchant
         'business_savings' => 'CORPORATE_SAVINGS'
       }
 
+      SHOPPER_INITIATOR = %w(CUSTOMER CARDHOLDER)
+
       STATE_CODE_COUNTRIES = %w(US CA)
 
       def initialize(options = {})
@@ -179,6 +181,7 @@ module ActiveMerchant
         doc.send('store-card', options[:store_card] || false)
         add_amount(doc, money, options)
         add_fraud_info(doc, payment_method, options)
+        add_stored_credentials(doc, options)
 
         if payment_method.is_a?(String)
           doc.send('vaulted-shopper-id', payment_method)
@@ -190,6 +193,19 @@ module ActiveMerchant
         end
       end
 
+      def add_stored_credentials(doc, options)
+        return unless stored_credential = options[:stored_credential]
+
+        initiator = stored_credential[:initiator]&.upcase
+        initiator = 'SHOPPER' if SHOPPER_INITIATOR.include?(initiator)
+        doc.send('transaction-initiator', initiator) if stored_credential[:initiator]
+        if stored_credential[:network_transaction_id]
+          doc.send('network-transaction-info') do
+            doc.send('original-network-transaction-id', stored_credential[:network_transaction_id])
+          end
+        end
+      end
+
       def add_amount(doc, money, options)
         currency = options[:currency] || currency(money)
         doc.amount(localized_amount(money, currency))
@@ -244,6 +260,7 @@ module ActiveMerchant
       def add_order(doc, options)
         doc.send('merchant-transaction-id', truncate(options[:order_id], 50)) if options[:order_id]
         doc.send('soft-descriptor', options[:soft_descriptor]) if options[:soft_descriptor]
+        doc.send('descriptor-phone-number', options[:descriptor_phone_number]) if options[:descriptor_phone_number]
         add_metadata(doc, options)
         add_3ds(doc, options[:three_d_secure]) if options[:three_d_secure]
         add_level_3_data(doc, options)
@@ -350,6 +367,7 @@ module ActiveMerchant
       def add_alt_transaction_purchase(doc, money, payment_method_details, options)
         doc.send('merchant-transaction-id', truncate(options[:order_id], 50)) if options[:order_id]
         doc.send('soft-descriptor', options[:soft_descriptor]) if options[:soft_descriptor]
+        doc.send('descriptor-phone-number', options[:descriptor_phone_number]) if options[:descriptor_phone_number]
         add_amount(doc, money, options)
 
         vaulted_shopper_id = payment_method_details.vaulted_shopper_id
@@ -358,6 +376,7 @@ module ActiveMerchant
         add_echeck_transaction(doc, payment_method_details.payment_method, options, vaulted_shopper_id.present?) if payment_method_details.check?
 
         add_fraud_info(doc, payment_method_details.payment_method, options)
+        add_stored_credentials(doc, options)
         add_metadata(doc, options)
       end
 
@@ -512,7 +531,9 @@ module ActiveMerchant
       end
 
       def authorization_from(action, parsed_response, payment_method_details)
-        action == :store ? vaulted_shopper_id(parsed_response, payment_method_details) : parsed_response['transaction-id']
+        return vaulted_shopper_id(parsed_response, payment_method_details) if action == :store
+
+        parsed_response['refund-transaction-id'] || parsed_response['transaction-id']
       end
 
       def vaulted_shopper_id(parsed_response, payment_method_details)

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

@@ -90,6 +90,10 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def verify(credit_card, options = {})
+        authorize(0, credit_card, options)
+      end
+
       def store(paysource, options = {})
         case normalize(paysource)
         when /1$/