activemerchant 1.133.0 → 1.138.0

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

@@ -1,7 +1,7 @@
 require 'nokogiri'
 
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class WorldpayGateway < Gateway
       self.test_url = 'https://secure-test.worldpay.com/jsp/merchant/xml/paymentService.jsp'
       self.live_url = 'https://secure.worldpay.com/jsp/merchant/xml/paymentService.jsp'
@@ -16,7 +16,7 @@ module ActiveMerchant #:nodoc:
                                     OM PA PE PF PH PK PL PN PR PT PW PY QA RE RO RS RU RW SA SB SC SE SG SI SK SL SM SN ST SV
                                     SZ TC TD TF TG TH TJ TK TM TO TR TT TV TW TZ UA UG US UY UZ VA VC VE VI VN VU WF WS YE YT
                                     ZA ZM)
-      self.supported_cardtypes = %i[visa master american_express discover jcb maestro elo naranja cabal unionpay]
+      self.supported_cardtypes = %i[visa master american_express discover jcb maestro elo naranja cabal unionpay patagonia_365 tarjeta_sol]
       self.currencies_without_fractions = %w(HUF IDR JPY KRW BEF XOF XAF XPF GRD GNF ITL LUF MGA MGF PYG PTE RWF ESP TRL VND KMF)
       self.currencies_with_three_decimal_places = %w(BHD KWD OMR TND LYD JOD IQD)
       self.homepage_url = 'http://www.worldpay.com/'
@@ -38,14 +38,14 @@ module ActiveMerchant #:nodoc:
         'G' => 'C', # Address does not match, postcode not checked
         'H' => 'I', # Address and postcode not provided
         'I' => 'C', # Address not checked postcode does not match
-        'J' => 'C', # Address and postcode does not match
+        'J' => 'C' # Address and postcode does not match
       }
 
       CVC_CODE_MAP = {
         'A' => 'M', # CVV matches
         'B' => 'P', # Not provided
         'C' => 'P', # Not checked
-        'D' => 'N', # Does not match
+        'D' => 'N' # Does not match
       }
 
       def initialize(options = {})
@@ -62,7 +62,7 @@ module ActiveMerchant #:nodoc:
 
       def authorize(money, payment_method, options = {})
         requires!(options, :order_id)
-        payment_details = payment_details(payment_method)
+        payment_details = payment_details(payment_method, options)
         authorize_request(money, payment_method, payment_details.merge(options))
       end
 
@@ -108,9 +108,11 @@ module ActiveMerchant #:nodoc:
       #   and other transactions should be performed on a normal eCom-flagged
       #   merchant ID.
       def credit(money, payment_method, options = {})
-        payment_details = payment_details(payment_method)
+        payment_details = payment_details(payment_method, options)
         if options[:fast_fund_credit]
           fast_fund_credit_request(money, payment_method, payment_details.merge(credit: true, **options))
+        elsif options[:account_funding_transaction]
+          aft_request(money, payment_method, payment_details.merge(**options))
         else
           credit_request(money, payment_method, payment_details.merge(credit: true, **options))
         end
@@ -131,7 +133,10 @@ module ActiveMerchant #:nodoc:
 
       def inquire(authorization, options = {})
         order_id = order_id_from_authorization(authorization.to_s) || options[:order_id]
-        commit('direct_inquiry', build_order_inquiry_request(order_id, options), :ok, options)
+        failure_criteria = %w(REFUSED CANCELLED)
+        failure_criteria.delete('CANCELLED') if options[:original_request] == 'verification'
+
+        commit('direct_inquiry', build_order_inquiry_request(order_id, options), *failure_criteria, options)
       end
 
       def supports_scrubbing
@@ -148,13 +153,26 @@ module ActiveMerchant #:nodoc:
           gsub(%r((<cardNumber>)\d+(</cardNumber>)), '\1[FILTERED]\2').
           gsub(%r((<cvc>)[^<]+(</cvc>)), '\1[FILTERED]\2').
           gsub(%r((<tokenNumber>)\d+(</tokenNumber>)), '\1[FILTERED]\2').
-          gsub(%r((<cryptogram>)[^<]+(</cryptogram>)), '\1[FILTERED]\2')
+          gsub(%r((<cryptogram>)[^<]+(</cryptogram>)), '\1[FILTERED]\2').
+          gsub(%r((<accountReference accountType="\w+">)\d+(<\/accountReference>)), '\1[FILTERED]\2')
       end
 
       private
 
+      def eci_value(payment_method, options)
+        eci = payment_method.respond_to?(:eci) ? format(payment_method.eci, :two_digits) : ''
+
+        return eci unless eci.empty?
+
+        options[:use_default_eci] ? '07' : eci
+      end
+
       def authorize_request(money, payment_method, options)
-        commit('authorize', build_authorization_request(money, payment_method, options), 'AUTHORISED', 'CAPTURED', options)
+        if options[:account_funding_transaction]
+          aft_request(money, payment_method, options)
+        else
+          commit('authorize', build_authorization_request(money, payment_method, options), 'AUTHORISED', 'CAPTURED', options)
+        end
       end
 
       def capture_request(money, authorization, options)
@@ -181,6 +199,10 @@ module ActiveMerchant #:nodoc:
         commit('fast_credit', build_fast_fund_credit_request(money, payment_method, options), :ok, 'PUSH_APPROVED', options)
       end
 
+      def aft_request(money, payment_method, options)
+        commit('funding_transfer_transaction', build_aft_request(money, payment_method, options), :ok, 'AUTHORISED', options)
+      end
+
       def store_request(credit_card, options)
         commit('store', build_store_request(credit_card, options), options)
       end
@@ -222,6 +244,7 @@ module ActiveMerchant #:nodoc:
               add_order_content(xml, options)
               add_payment_method(xml, money, payment_method, options)
               add_shopper(xml, options)
+              add_fraud_sight_data(xml, options)
               add_statement_narrative(xml, options)
               add_risk_data(xml, options[:risk_data]) if options[:risk_data]
               add_sub_merchant_data(xml, options[:sub_merchant_data]) if options[:sub_merchant_data]
@@ -252,9 +275,8 @@ module ActiveMerchant #:nodoc:
         xml.invoiceReferenceNumber data[:invoice_reference_number] if data.include?(:invoice_reference_number)
         xml.customerReference data[:customer_reference] if data.include?(:customer_reference)
         xml.cardAcceptorTaxId data[:card_acceptor_tax_id] if data.include?(:card_acceptor_tax_id)
-
         {
-          sales_tax: 'salesTax',
+          tax_amount: 'salesTax',
           discount_amount: 'discountAmount',
           shipping_amount: 'shippingAmount',
           duty_amount: 'dutyAmount'
@@ -262,53 +284,37 @@ module ActiveMerchant #:nodoc:
           next unless data.include?(key)
 
           xml.tag! tag do
-            data_amount = data[key].symbolize_keys
-            add_amount(xml, data_amount[:amount].to_i, data_amount)
+            add_amount(xml, data[key].to_i, data)
           end
         end
 
-        xml.discountName data[:discount_name] if data.include?(:discount_name)
-        xml.discountCode data[:discount_code] if data.include?(:discount_code)
-
-        add_date_element(xml, 'shippingDate', data[:shipping_date]) if data.include?(:shipping_date)
-
-        if data.include?(:shipping_courier)
-          xml.shippingCourier(
-            data[:shipping_courier][:priority],
-            data[:shipping_courier][:tracking_number],
-            data[:shipping_courier][:name]
-          )
-        end
-
         add_optional_data_level_two_and_three(xml, data)
 
-        if data.include?(:item) && data[:item].kind_of?(Array)
-          data[:item].each { |item| add_items_into_level_three_data(xml, item.symbolize_keys) }
-        elsif data.include?(:item)
-          add_items_into_level_three_data(xml, data[:item].symbolize_keys)
-        end
+        data[:line_items].each { |item| add_line_items_into_level_three_data(xml, item.symbolize_keys, data) } if data.include?(:line_items)
       end
 
-      def add_items_into_level_three_data(xml, item)
+      def add_line_items_into_level_three_data(xml, item, data)
         xml.item do
           xml.description item[:description] if item[:description]
           xml.productCode item[:product_code] if item[:product_code]
           xml.commodityCode item[:commodity_code] if item[:commodity_code]
           xml.quantity item[:quantity] if item[:quantity]
-
-          {
-            unit_cost: 'unitCost',
-            item_total: 'itemTotal',
-            item_total_with_tax: 'itemTotalWithTax',
-            item_discount_amount: 'itemDiscountAmount',
-            tax_amount: 'taxAmount'
-          }.each do |key, tag|
-            next unless item.include?(key)
-
-            xml.tag! tag do
-              data_amount = item[key].symbolize_keys
-              add_amount(xml, data_amount[:amount].to_i, data_amount)
-            end
+          xml.unitCost do
+            add_amount(xml, item[:unit_cost], data)
+          end
+          xml.unitOfMeasure item[:unit_of_measure] || 'each'
+          xml.itemTotal do
+            sub_total_amount = item[:quantity].to_i * (item[:unit_cost].to_i - item[:discount_amount].to_i)
+            add_amount(xml, sub_total_amount, data)
+          end
+          xml.itemTotalWithTax do
+            add_amount(xml, item[:total_amount], data)
+          end
+          xml.itemDiscountAmount do
+            add_amount(xml, item[:discount_amount], data)
+          end
+          xml.taxAmount do
+            add_amount(xml, item[:tax_amount], data)
           end
         end
       end
@@ -318,7 +324,7 @@ module ActiveMerchant #:nodoc:
         xml.destinationPostalCode data[:destination_postal_code] if data.include?(:destination_postal_code)
         xml.destinationCountryCode data[:destination_country_code] if data.include?(:destination_country_code)
         add_date_element(xml, 'orderDate', data[:order_date].symbolize_keys) if data.include?(:order_date)
-        xml.taxExempt data[:tax_exempt] if data.include?(:tax_exempt)
+        xml.taxExempt data[:tax_amount].to_i > 0 ? 'false' : 'true'
       end
 
       def order_tag_attributes(options)
@@ -360,6 +366,10 @@ module ActiveMerchant #:nodoc:
           if options[:cancel_or_refund]
             # Worldpay docs claim amount must be passed. This causes an error.
             xml.cancelOrRefund # { add_amount(xml, money, options.merge(debit_credit_indicator: 'credit')) }
+          elsif options[:refund_reference]
+            xml.refund 'reference' => options[:refund_reference] do
+              add_amount(xml, money, options.merge(debit_credit_indicator: 'credit'))
+            end
           else
             xml.refund do
               add_amount(xml, money, options.merge(debit_credit_indicator: 'credit'))
@@ -403,7 +413,74 @@ module ActiveMerchant #:nodoc:
               add_amount(xml, money, options)
               add_order_content(xml, options)
               add_payment_details_for_ff_credit(xml, payment_method, options)
-              add_shopper_id(xml, options)
+
+              if options[:email]
+                xml.shopper do
+                  xml.shopperEmailAddress options[:email]
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def build_aft_request(money, payment_method, options)
+        build_request do |xml|
+          xml.submit do
+            xml.order order_tag_attributes(options) do
+              xml.description(options[:description].blank? ? 'Account Funding Transaction' : options[:description])
+              add_amount(xml, money, options)
+              add_order_content(xml, options)
+              add_payment_method(xml, money, payment_method, options)
+              add_shopper(xml, options)
+              add_sub_merchant_data(xml, options[:sub_merchant_data]) if options[:sub_merchant_data]
+              add_additional_3ds_data(xml, options) if options[:execute_threed] && options[:three_ds_version] && options[:three_ds_version] =~ /^2/
+              add_3ds_exemption(xml, options) if options[:exemption_type]
+              add_aft_data(xml, payment_method, options)
+            end
+          end
+        end
+      end
+
+      def add_aft_data(xml, payment_method, options)
+        xml.fundingTransfer 'type' => options[:aft_type], 'category' => 'PULL_FROM_CARD' do
+          xml.paymentPurpose options[:aft_payment_purpose] # Must be included for the recipient for following countries, otherwise optional: Argentina, Bangladesh, Chile, Columbia, Jordan, Mexico, Thailand, UAE, India cross-border
+          xml.fundingParty 'type' => 'sender' do
+            xml.accountReference options[:aft_sender_account_reference], 'accountType' => options[:aft_sender_account_type]
+            xml.fullName do
+              xml.first options.dig(:aft_sender_full_name, :first)
+              xml.middle options.dig(:aft_sender_full_name, :middle) if options.dig(:aft_sender_full_name, :middle)
+              xml.last options.dig(:aft_sender_full_name, :last)
+            end
+            xml.fundingAddress do
+              xml.address1 options.dig(:aft_sender_funding_address, :address1) if options.dig(:aft_sender_funding_address, :address1)
+              xml.address2 options.dig(:aft_sender_funding_address, :address2) if options.dig(:aft_sender_funding_address, :address2)
+              xml.postalCode options.dig(:aft_sender_funding_address, :postal_code) if options.dig(:aft_sender_funding_address, :postal_code)
+              xml.city options.dig(:aft_sender_funding_address, :city) if options.dig(:aft_sender_funding_address, :city)
+              xml.state options.dig(:aft_sender_funding_address, :state) if options.dig(:aft_sender_funding_address, :state)
+              xml.countryCode options.dig(:aft_sender_funding_address, :country_code) if options.dig(:aft_sender_funding_address, :country_code)
+            end
+          end
+          xml.fundingParty 'type' => 'recipient' do
+            xml.accountReference options[:aft_recipient_account_reference], 'accountType' => options[:aft_recipient_account_type]
+            xml.fullName do
+              xml.first options.dig(:aft_recipient_full_name, :first)
+              xml.middle options.dig(:aft_recipient_full_name, :middle) if options.dig(:aft_recipient_full_name, :middle)
+              xml.last options.dig(:aft_recipient_full_name, :last)
+            end
+            xml.fundingAddress do
+              xml.address1 options.dig(:aft_recipient_funding_address, :address1) if options.dig(:aft_recipient_funding_address, :address1)
+              xml.address2 options.dig(:aft_recipient_funding_address, :address2) if options.dig(:aft_recipient_funding_address, :address2)
+              xml.postalCode options.dig(:aft_recipient_funding_address, :postal_code) if options.dig(:aft_recipient_funding_address, :postal_code)
+              xml.city options.dig(:aft_recipient_funding_address, :city) if options.dig(:aft_recipient_funding_address, :city)
+              xml.state options.dig(:aft_recipient_funding_address, :state) if options.dig(:aft_recipient_funding_address, :state)
+              xml.countryCode options.dig(:aft_recipient_funding_address, :country_code) if options.dig(:aft_recipient_funding_address, :country_code)
+            end
+            if options[:aft_recipient_funding_data]
+              xml.fundingData do
+                add_date_element(xml, 'birthDate', options[:aft_recipient_funding_data][:birth_date]) if options[:aft_recipient_funding_data][:birth_date]
+                xml.telephoneNumber options.dig(:aft_recipient_funding_data, :telephone_number) if options.dig(:aft_recipient_funding_data, :telephone_number)
+              end
             end
           end
         end
@@ -418,6 +495,7 @@ module ActiveMerchant #:nodoc:
               add_token_for_ff_credit(xml, payment_method, options)
             end
           end
+          add_shopper_id(xml, options)
         end
       end
 
@@ -443,7 +521,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_additional_3ds_data(xml, options)
-        additional_data = { 'dfReferenceId' => options[:session_id] }
+        additional_data = { 'dfReferenceId' => options[:df_reference_id] }
         additional_data['challengeWindowSize'] = options[:browser_size] if options[:browser_size]
 
         xml.additional3DSData additional_data
@@ -554,10 +632,10 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_amount(xml, money, options)
-        currency = options[:currency] || currency(money)
+        currency = options[:currency] || currency(money.to_i)
 
         amount_hash = {
-          :value => localized_amount(money, currency),
+          :value => localized_amount(money.to_i, currency),
           'currencyCode' => currency,
           'exponent' => currency_exponent(currency)
         }
@@ -571,8 +649,10 @@ module ActiveMerchant #:nodoc:
         case options[:payment_type]
         when :pay_as_order
           add_amount_for_pay_as_order(xml, amount, payment_method, options)
+        when :encrypted_wallet
+          add_encrypted_wallet(xml, payment_method)
         when :network_token
-          add_network_tokenization_card(xml, payment_method)
+          add_network_tokenization_card(xml, payment_method, options)
         else
           add_card_or_token(xml, payment_method, options)
         end
@@ -590,8 +670,9 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def add_network_tokenization_card(xml, payment_method)
-        token_type = NETWORK_TOKEN_TYPE.fetch(payment_method.source, 'NETWORKTOKEN')
+      def add_network_tokenization_card(xml, payment_method, options)
+        source = payment_method.respond_to?(:source) ? payment_method.source : options[:wallet_type]
+        token_type = NETWORK_TOKEN_TYPE.fetch(source, 'NETWORKTOKEN')
 
         xml.paymentDetails do
           xml.tag! 'EMVCO_TOKEN-SSL', 'type' => token_type do
@@ -603,14 +684,58 @@ module ActiveMerchant #:nodoc:
               )
             end
             name = card_holder_name(payment_method, options)
-            eci = format(payment_method.eci, :two_digits)
             xml.cardHolderName name if name.present?
-            xml.cryptogram payment_method.payment_cryptogram
-            xml.eciIndicator eci.empty? ? '07' : eci
+            xml.cryptogram payment_method.payment_cryptogram unless should_send_payment_cryptogram?(options, payment_method)
+            eci = eci_value(payment_method, options)
+            xml.eciIndicator eci if eci.present?
+          end
+          add_stored_credential_options(xml, options)
+          add_shopper_id(xml, options, false)
+          add_three_d_secure(xml, options)
+        end
+      end
+
+      def should_send_payment_cryptogram?(options, payment_method)
+        wallet_type_google_pay?(options) ||
+          (payment_method_apple_pay?(payment_method) &&
+            merchant_initiated?(options))
+      end
+
+      def merchant_initiated?(options)
+        options.dig(:stored_credential, :initiator) == 'merchant'
+      end
+
+      def add_encrypted_wallet(xml, payment_method)
+        source = encrypted_wallet_source(payment_method.source)
+
+        xml.paymentDetails do
+          xml.tag! "#{source}-SSL" do
+            if source == 'APPLEPAY'
+              add_encrypted_apple_pay(xml, payment_method)
+            else
+              add_encrypted_google_pay(xml, payment_method)
+            end
           end
         end
       end
 
+      def add_encrypted_apple_pay(xml, payment_method)
+        xml.header do
+          xml.ephemeralPublicKey payment_method.payment_data.dig(:header, :ephemeralPublicKey)
+          xml.publicKeyHash payment_method.payment_data.dig(:header, :publicKeyHash)
+          xml.transactionId payment_method.payment_data.dig(:header, :transactionId)
+        end
+        xml.signature payment_method.payment_data[:signature]
+        xml.version payment_method.payment_data[:version]
+        xml.data payment_method.payment_data[:data]
+      end
+
+      def add_encrypted_google_pay(xml, payment_method)
+        xml.protocolVersion payment_method.payment_data[:version]
+        xml.signature payment_method.payment_data[:signature]
+        xml.signedMessage payment_method.payment_data[:signed_message]
+      end
+
       def add_card_or_token(xml, payment_method, options)
         xml.paymentDetails credit_fund_transfer_attribute(options) do
           if options[:payment_type] == :token
@@ -636,13 +761,13 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def add_shopper_id(xml, options)
-        if options[:ip] && options[:session_id]
-          xml.session 'shopperIPAddress' => options[:ip], 'id' => options[:session_id]
-        else
-          xml.session 'shopperIPAddress' => options[:ip] if options[:ip]
-          xml.session 'id' => options[:session_id] if options[:session_id]
-        end
+      def add_shopper_id(xml, options, with_session_id = true)
+        session_params = {
+          'shopperIPAddress' => options[:ip],
+          'id' => with_session_id ? options[:session_id] : nil
+        }.compact
+
+        xml.session session_params if session_params.present?
       end
 
       def add_three_d_secure(xml, options)
@@ -678,39 +803,38 @@ module ActiveMerchant #:nodoc:
       def add_stored_credential_options(xml, options = {})
         if options[:stored_credential]
           add_stored_credential_using_normalized_fields(xml, options)
-        else
+        elsif options[:stored_credential_usage]
           add_stored_credential_using_gateway_specific_fields(xml, options)
         end
       end
 
       def add_stored_credential_using_normalized_fields(xml, options)
-        if options[:stored_credential][:initial_transaction]
-          xml.storedCredentials 'usage' => 'FIRST'
-        else
-          reason = case options[:stored_credential][:reason_type]
-                   when 'installment' then 'INSTALMENT'
-                   when 'recurring' then 'RECURRING'
-                   when 'unscheduled' then 'UNSCHEDULED'
-                   end
-
-          xml.storedCredentials 'usage' => 'USED', 'merchantInitiatedReason' => reason do
-            xml.schemeTransactionIdentifier options[:stored_credential][:network_transaction_id] if options[:stored_credential][:network_transaction_id]
-          end
+        reason = case options[:stored_credential][:reason_type]
+                 when 'installment' then 'INSTALMENT'
+                 when 'recurring' then 'RECURRING'
+                 when 'unscheduled' then 'UNSCHEDULED'
+                 end
+        is_initial_transaction = options[:stored_credential][:initial_transaction]
+        stored_credential_params = generate_stored_credential_params(is_initial_transaction, reason, options[:stored_credential][:initiator])
+
+        xml.storedCredentials stored_credential_params do
+          xml.schemeTransactionIdentifier network_transaction_id(options) if send_network_transaction_id?(options)
         end
       end
 
       def add_stored_credential_using_gateway_specific_fields(xml, options)
-        return unless options[:stored_credential_usage]
+        is_initial_transaction = options[:stored_credential_usage] == 'FIRST'
+        stored_credential_params = generate_stored_credential_params(is_initial_transaction, options[:stored_credential_initiated_reason])
 
-        if options[:stored_credential_initiated_reason]
-          xml.storedCredentials 'usage' => options[:stored_credential_usage], 'merchantInitiatedReason' => options[:stored_credential_initiated_reason] do
-            xml.schemeTransactionIdentifier options[:stored_credential_transaction_id] if options[:stored_credential_transaction_id]
-          end
-        else
-          xml.storedCredentials 'usage' => options[:stored_credential_usage]
+        xml.storedCredentials stored_credential_params do
+          xml.schemeTransactionIdentifier options[:stored_credential_transaction_id] if options[:stored_credential_transaction_id] && !is_initial_transaction
         end
       end
 
+      def send_network_transaction_id?(options)
+        network_transaction_id(options) && !options.dig(:stored_credential, :initial_transaction) && options.dig(:stored_credential, :initiator) != 'cardholder'
+      end
+
       def add_shopper(xml, options)
         return unless options[:execute_threed] || options[:email] || options[:customer]
 
@@ -724,6 +848,20 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def add_fraud_sight_data(xml, options)
+        return unless options[:custom_string_fields].is_a?(Hash)
+
+        xml.tag! 'FraudSightData' do
+          xml.tag! 'customStringFields' do
+            options[:custom_string_fields].each do |key, value|
+              # transform custom_string_field_1 into customStringField1, etc.
+              formatted_key = key.to_s.camelize(:lower).to_sym
+              xml.tag! formatted_key, value
+            end
+          end
+        end
+      end
+
       def add_statement_narrative(xml, options)
         xml.statementNarrative truncate(options[:statement_narrative], 50) if options[:statement_narrative]
       end
@@ -792,7 +930,7 @@ module ActiveMerchant #:nodoc:
         xml = xml.strip.gsub(/\&/, '&amp;')
         doc = Nokogiri::XML(xml, &:strict)
         doc.remove_namespaces!
-        resp_params = { action: action }
+        resp_params = { action: }
 
         parse_elements(doc.root, resp_params)
         extract_issuer_response(doc.root, resp_params)
@@ -823,7 +961,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def headers(options)
-        idempotency_key = options[:idempotency_key]
+        @idempotency_key ||= options[:idempotency_key]
 
         headers = {
           'Content-Type' => 'text/xml',
@@ -832,14 +970,20 @@ module ActiveMerchant #:nodoc:
 
         # ensure cookie included on follow-up '3ds' and 'capture_request' calls, using the cookie saved from the preceding response
         # cookie should be present in options on the 3ds and capture calls, but also still saved in the instance var in case
-        cookie = options[:cookie] || @cookie || nil
+        cookie = defined?(@cookie) ? @cookie : nil
+        cookie = options[:cookie] || cookie
         headers['Cookie'] = cookie if cookie
 
-        headers['Idempotency-Key'] = idempotency_key if idempotency_key
+        # Required because Worldpay does not accept duplicate idempotency keys
+        # for different transactions, such as in the case of an authorize => capture flow.
+        if @idempotency_key
+          headers['Idempotency-Key'] = @idempotency_key
+          @idempotency_key = SecureRandom.uuid
+        end
         headers
       end
 
-      def commit(action, request, *success_criteria, options)
+      def commit(action, request, *success_or_failure_criteria, options)
         xml = ssl_post(url, request, headers(options))
         raw = parse(action, xml)
 
@@ -848,8 +992,9 @@ module ActiveMerchant #:nodoc:
           raw[:session_id] = options[:session_id]
           raw[:is3DSOrder] = true
         end
-        success = success_from(action, raw, success_criteria)
-        message = message_from(success, raw, success_criteria, action)
+
+        success = success_from(action, raw, success_or_failure_criteria)
+        message = message_from(success, raw, success_or_failure_criteria, action)
 
         Response.new(
           success,
@@ -894,32 +1039,37 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def success_from(action, raw, success_criteria)
-        success_criteria_success?(raw, success_criteria) || action_success?(action, raw)
+      def success_from(action, raw, success_or_failure_criteria)
+        if action == 'direct_inquiry'
+          return if raw[:error]
+
+          # for direct_inquiry we are looking for failed last_event
+          !success_or_failure_criteria.include?(raw[:last_event])
+        else
+          success_criteria_success?(raw, success_or_failure_criteria) || action_success?(action, raw)
+        end
       end
 
-      def message_from(success, raw, success_criteria, action)
+      def message_from(success, raw, success_or_failure_criteria, action)
         return 'SUCCESS' if success
 
-        raw[:iso8583_return_code_description] || raw[:error] || required_status_message(raw, success_criteria, action) || raw[:issuer_response_description]
+        raw[:iso8583_return_code_description] || raw[:error] || required_status_message(raw, success_or_failure_criteria, action) || raw[:issuer_response_description]
       end
 
-      # success_criteria can be:
+      # success_or_failure_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
       #     success.
-      def success_criteria_success?(raw, success_criteria)
+      def success_criteria_success?(raw, success_or_failure_criteria)
         return if raw[:error]
 
-        raw[:ok].present? || (success_criteria.include?(raw[:last_event]) if raw[:last_event])
+        raw[:ok].present? || (success_or_failure_criteria.include?(raw[:last_event]) if raw[:last_event])
       end
 
       def action_success?(action, raw)
         case action
         when 'store'
           raw[:token].present?
-        when 'direct_inquiry'
-          raw[:last_event].present?
         else
           false
         end
@@ -929,11 +1079,11 @@ module ActiveMerchant #:nodoc:
         raw[:iso8583_return_code_code] || raw[:error_code] || nil unless success == 'SUCCESS'
       end
 
-      def required_status_message(raw, success_criteria, action)
-        return if success_criteria.include?(raw[:last_event])
+      def required_status_message(raw, success_or_failure_criteria, action)
+        return if success_or_failure_criteria.include?(raw[:last_event])
         return unless %w[cancel refund inquiry credit fast_credit].include?(action)
 
-        "A transaction status of #{success_criteria.collect { |c| "'#{c}'" }.join(' or ')} is required."
+        "A transaction status of #{success_or_failure_criteria.collect { |c| "'#{c}'" }.join(' or ')} is required."
       end
 
       def authorization_from(action, raw, options)
@@ -942,7 +1092,7 @@ module ActiveMerchant #:nodoc:
         case action
         when 'store'
           authorization_from_token_details(
-            order_id: order_id,
+            order_id:,
             token_id: raw[:payment_token_id],
             token_scope: 'shopper',
             customer: options[:customer]
@@ -977,21 +1127,32 @@ module ActiveMerchant #:nodoc:
         token_details
       end
 
-      def payment_details(payment_method)
+      def payment_details(payment_method, options = {})
         case payment_method
         when String
           token_type_and_details(payment_method)
         else
-          type = network_token?(payment_method) ? :network_token : :credit
-
-          { payment_type: type }
+          payment_method_type(payment_method, options)
         end
       end
 
-      def network_token?(payment_method)
-        payment_method.respond_to?(:source) &&
-          payment_method.respond_to?(:payment_cryptogram) &&
-          payment_method.respond_to?(:eci)
+      def payment_method_type(payment_method, options)
+        type = if payment_method.is_a?(NetworkTokenizationCreditCard)
+                 payment_method.encrypted_wallet? ? :encrypted_wallet : :network_token
+               else
+                 wallet_type_google_pay?(options) ? :network_token : :credit
+               end
+        { payment_type: type }
+      end
+
+      def payment_method_apple_pay?(payment_method)
+        return false unless payment_method.is_a?(NetworkTokenizationCreditCard)
+
+        payment_method.source == :apple_pay
+      end
+
+      def wallet_type_google_pay?(options)
+        options[:wallet_type] == :google_pay
       end
 
       def token_type_and_details(token)
@@ -1026,6 +1187,29 @@ module ActiveMerchant #:nodoc:
       def card_holder_name(payment_method, options)
         test? && options[:execute_threed] && !options[:three_ds_version]&.start_with?('2') ? '3D' : payment_method.name
       end
+
+      def generate_stored_credential_params(is_initial_transaction, reason = nil, initiator = nil)
+        customer_or_merchant = initiator == 'cardholder' ? 'customerInitiatedReason' : 'merchantInitiatedReason'
+
+        stored_credential_params = {}
+        stored_credential_params['usage'] = is_initial_transaction ? 'FIRST' : 'USED'
+
+        return stored_credential_params if customer_or_merchant == 'customerInitiatedReason' && stored_credential_params['usage'] == 'USED'
+
+        stored_credential_params[customer_or_merchant] = reason if reason
+        stored_credential_params
+      end
+
+      def encrypted_wallet_source(source)
+        case source
+        when :apple_pay
+          'APPLEPAY'
+        when :google_pay
+          'PAYWITHGOOGLE'
+        else
+          raise ArgumentError, 'Invalid encrypted wallet source'
+        end
+      end
     end
   end
 end