braintree 4.41.0 → 4.42.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 874cd322dda721874dc4418b2f6ca24116b9395f7affc02d43fe056f43424b3a
-  data.tar.gz: 8c73ed2ec27ecf6b916474bc12dc14bde985c48107a53bdcea17a65a216cc3d5
+  metadata.gz: 8ec866027a8aca5a627799053012f7e992155e64b4c318e1f8da68bf0a395a84
+  data.tar.gz: d4900837bac1f44acc8f0a9b976d75d6b1a60bde93df1a7cbdabf19bf623de2b
 SHA512:
-  metadata.gz: f8f4fa7af94d5b317dc5efa9aea66d1fbcf84f689e9cb19435f6899b8af8c39fb25063a8d0ff40e4025f42014e4c18555e9d4b2e779132b0fc73afc3f6204baa
-  data.tar.gz: 815d5927abfa22e7acbdf7fa4353d9408b0b0add7f66a5e1cbf43b2b2aaa03a5ac4f925eb25b69bcf1060ff04c01e9cdc9c908e560a4e6e7df9db14339ed886a
+  metadata.gz: e6c03eb513ad06b6fcaabc57167e2398c5a1d36c82f6863f30dcb57e6f1a40a43142f2b8c4591eb594eb36e4fc0d6c4cf2b9a3b756c77450501d5d6c2baa6652
+  data.tar.gz: e4f00316d23efaf9bee33c0af67d05e7a013e7c4a32224f810a4c39a72135e0fd977c57077e816c4fddad6e8e6e95245e6f0eb2888c00f96dec25f8ecbe0e0e1

data/lib/braintree/credit_card_gateway.rb

@@ -120,7 +120,7 @@ module Braintree
         :billing_address_id, :cardholder_name, :cvv, :expiration_date, :expiration_month,
         :expiration_year, :number, :token, :venmo_sdk_payment_method_code, # Deprecated
         :device_data, :payment_method_nonce,
-        {:external_vault => [:network_transaction_id]},
+        {:external_vault => [:network_transaction_id, :mastercard_transaction_link_id]},
         {:options => options},
         {:billing_address => billing_address_params}
       ]

data/lib/braintree/credit_card_verification_gateway.rb

@@ -61,6 +61,7 @@ module Braintree
         ]},
         {:external_vault => [
           :previous_network_transaction_id,
+          :previous_mastercard_transaction_link_id,
           :status,
         ]},
         :intended_transaction_source,

data/lib/braintree/error_codes.rb

@@ -120,6 +120,10 @@ module Braintree
       VerificationAccountTypeNotSupported = "91758"
       VerificationNotSupportedOnThisMerchantAccount = "91730"
 
+      module ExternalVault
+        MastercardTransactionLinkIdIsInvalid = "91767"
+      end
+
       module Options
         UpdateExistingTokenIsInvalid = "91723"
         UpdateExistingTokenNotAllowed = "91729"
@@ -367,6 +371,7 @@ module Braintree
       CannotRefundUnlessSettled = "91506"
       CannotRefundWithPendingMerchantAccount = "91559"
       CannotRefundWithSuspendedMerchantAccount = "91538"
+      CannotReverseAtThisTime = "915282"
       CannotSimulateTransactionSettlement = "91575"
       CannotSubmitForSettlement = "91507"
       CannotUpdateTransactionDetailsNotSubmittedForSettlement = "915129"
@@ -613,8 +618,10 @@ module Braintree
       end
 
       module ExternalVault
+        PreviousMastercardTransactionLinkIdIsInvalid = "915279"
         PreviousNetworkTransactionIdIsInvalid = "915179"
         StatusIsInvalid = "915175"
+        StatusWithPreviousMastercardTransactionLinkIdIsInvalid = "915278"
         StatusWithPreviousNetworkTransactionIdIsInvalid = "915177"
       end
     end
@@ -745,6 +752,11 @@ module Braintree
     end
 
     module Verification
+      module ExternalVault
+        PreviousMastercardTransactionLinkIdIsInvalid = "942206"
+        StatusWithPreviousMastercardTransactionLinkIdIsInvalid = "942205"
+      end
+
       module Options
         AccountTypeIsInvalid = "942184"
         AccountTypeNotSupported = "942185"

data/lib/braintree/transaction.rb

@@ -247,6 +247,14 @@ module Braintree
       Configuration.gateway.transaction.refund!(*args)
     end
 
+    def self.reverse(*args)
+      Configuration.gateway.transaction.reverse(*args)
+    end
+
+    def self.reverse!(*args)
+      Configuration.gateway.transaction.reverse!(*args)
+    end
+
     def self.sale(*args)
       Configuration.gateway.transaction.sale(*args)
     end

data/lib/braintree/transaction_gateway.rb

@@ -100,6 +100,22 @@ module Braintree
       _do_create "/transactions", :transaction => attributes
     end
 
+    def reverse(transaction_id, options = {})
+      raise ArgumentError, "transaction_id contains invalid characters" if Util.invalid_path_segment?(transaction_id)
+
+      Util.verify_keys(TransactionGateway._reverse_signature, options)
+      transaction_params = options.empty? ? nil : options
+      response = @config.http.post(
+        "#{@config.base_merchant_path}/transactions/#{transaction_id}/reverse",
+        transaction_params ? {:transaction => transaction_params} : nil,
+      )
+      _handle_transaction_response(response)
+    end
+
+    def reverse!(*args)
+      return_object_or_raise(:transaction) { reverse(*args) }
+    end
+
     def sale(attributes)
       create(attributes.merge(:type => "sale"))
     end
@@ -226,6 +242,7 @@ module Braintree
         {:external_vault => [
           :status,
           :previous_network_transaction_id,
+          :previous_mastercard_transaction_link_id,
         ]},
         {:google_pay_card => [:number, :cryptogram, :google_transaction_id, :expiration_month, :expiration_year, :source_card_type, :source_card_last_four, :eci_indicator]},
         {:industry => [
@@ -394,6 +411,12 @@ module Braintree
       ]
     end
 
+    def self._reverse_signature
+      [
+        :api_request_key,
+      ]
+    end
+
     def _do_create(path, params=nil)
       if !params.nil?
         params = Util.replace_key(params, :google_pay_card, :android_pay_card)

data/lib/braintree/version.rb

@@ -1,7 +1,7 @@
 module Braintree
   module Version
     Major = 4
-    Minor = 41
+    Minor = 42
     Tiny = 0
 
     String = "#{Major}.#{Minor}.#{Tiny}"

data/spec/integration/braintree/apple_pay_spec.rb

@@ -56,7 +56,9 @@ describe Braintree::ApplePayGateway do
     it "returns stubbed registered domains" do
       result = @gateway.apple_pay.registered_domains
       expect(result).to be_success
-      expect(result.apple_pay_options.domains).to eq(["www.example.com"])
+      domains = result.apple_pay_options.domains
+      expect(domains).not_to be_empty
+      expect(domains).to all(be_a(String).and(satisfy { |domain| !domain.empty? }))
     end
   end
 end

data/spec/integration/braintree/credit_card_spec.rb

@@ -529,6 +529,37 @@ describe Braintree::CreditCard do
       expect(result.success?).to eq(true)
     end
 
+    it "can set the mastercard transaction link identifier when creating a credit card" do
+      customer = Braintree::Customer.create!
+
+      result = Braintree::CreditCard.create(
+        :customer_id => customer.id,
+        :number => Braintree::Test::CreditCardNumbers::MasterCard,
+        :expiration_date => "05/2009",
+        :external_vault => {
+          :mastercard_transaction_link_id => "1234567890123456789012",
+        },
+      )
+
+      expect(result.success?).to eq(true)
+    end
+
+    it "rejects a mastercard transaction link identifier that is not 22 characters" do
+      customer = Braintree::Customer.create!
+
+      result = Braintree::CreditCard.create(
+        :customer_id => customer.id,
+        :number => Braintree::Test::CreditCardNumbers::MasterCard,
+        :expiration_date => "05/2009",
+        :external_vault => {
+          :mastercard_transaction_link_id => "1234567890123456789012123",
+        },
+      )
+
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:credit_card).for(:external_vault).on(:mastercard_transaction_link_id)[0].code).to eq(Braintree::ErrorCodes::CreditCard::ExternalVault::MastercardTransactionLinkIdIsInvalid)
+    end
+
     context "card type indicators" do
       it "sets the prepaid field if the card is prepaid" do
         customer = Braintree::Customer.create!

data/spec/integration/braintree/credit_card_verification_spec.rb

@@ -147,6 +147,60 @@ describe Braintree::CreditCardVerification, "search" do
       expect(result.credit_card_verification.network_transaction_id).not_to be_nil
     end
 
+    it "creates a new verification with previous_mastercard_transaction_link_id" do
+      verification_params = {
+        :credit_card => {
+            :expiration_date => "05/2029",
+            :number => Braintree::Test::CreditCardNumbers::MasterCard,
+        },
+        :external_vault => {
+            :status => "vaulted",
+            :previous_mastercard_transaction_link_id => "1234567890123456789012",
+        }
+      }
+
+      result = Braintree::CreditCardVerification.create(verification_params)
+
+      expect(result).to be_success
+      expect(result.credit_card_verification.id).to match(/^\w{6,}$/)
+    end
+
+    it "rejects non-vaulted status with previous_mastercard_transaction_link_id" do
+      verification_params = {
+        :credit_card => {
+            :expiration_date => "05/2029",
+            :number => Braintree::Test::CreditCardNumbers::MasterCard,
+        },
+        :external_vault => {
+            :status => "will_vault",
+            :previous_mastercard_transaction_link_id => "1234567890123456789012",
+        }
+      }
+
+      result = Braintree::CreditCardVerification.create(verification_params)
+
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:verification).for(:external_vault).on(:status)[0].code).to eq(Braintree::ErrorCodes::Verification::ExternalVault::StatusWithPreviousMastercardTransactionLinkIdIsInvalid)
+    end
+
+    it "rejects previous_mastercard_transaction_link_id that is not 22 characters" do
+      verification_params = {
+        :credit_card => {
+            :expiration_date => "05/2029",
+            :number => Braintree::Test::CreditCardNumbers::MasterCard,
+        },
+        :external_vault => {
+            :status => "vaulted",
+            :previous_mastercard_transaction_link_id => "1234567890123456789012123",
+        }
+      }
+
+      result = Braintree::CreditCardVerification.create(verification_params)
+
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:verification).for(:external_vault).on(:previous_mastercard_transaction_link_id)[0].code).to eq(Braintree::ErrorCodes::Verification::ExternalVault::PreviousMastercardTransactionLinkIdIsInvalid)
+    end
+
     it "creates a new verification from risk data param" do
       verification_params = {
         :credit_card => {

data/spec/integration/braintree/customer_spec.rb

@@ -102,6 +102,21 @@ describe Braintree::Customer do
       expect(result).to be_success
     end
 
+    it "supports creation with a mastercard_transaction_link_id external_vault param" do
+      result = Braintree::Customer.create(
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+          :expiration_date => "05/2010",
+          :cvv => "100",
+          :external_vault => {
+            :mastercard_transaction_link_id => "1234567890123456789012",
+          },
+        },
+      )
+
+      expect(result).to be_success
+    end
+
     it "supports creation including risk data with customer_browser and customer_ip" do
       result = Braintree::Customer.create(
         :credit_card => {

data/spec/integration/braintree/transaction_idempotency_spec.rb

@@ -277,6 +277,36 @@ describe Braintree::Transaction, "idempotency" do
     end
   end
 
+  describe "reverse" do
+    it "returns original reverse on duplicate request with same api_request_key" do
+      api_request_key = "reverse-idempotency-key-#{rand(1000000)}"
+
+      sale_request = {
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "05/2035"
+        }
+      }
+
+      sale_result = Braintree::Transaction.sale(sale_request)
+      expect(sale_result).to be_success
+      transaction_id = sale_result.transaction.id
+
+      reverse_options = {
+        :api_request_key => api_request_key
+      }
+
+      reverse_result1 = Braintree::Transaction.reverse(transaction_id, reverse_options)
+      expect(reverse_result1).to be_success
+
+      reverse_result2 = Braintree::Transaction.reverse(transaction_id, reverse_options)
+      expect(reverse_result2).to be_success
+      expect(reverse_result1.transaction.id).to eq(reverse_result2.transaction.id)
+      expect(reverse_result2.transaction.status).to eq(Braintree::Transaction::Status::Voided)
+    end
+  end
+
   describe "refund" do
     it "returns original refund on duplicate request with same api_request_key" do
       api_request_key = "refund-idempotency-key-#{rand(1000000)}"

data/spec/integration/braintree/transaction_spec.rb

@@ -5013,6 +5013,23 @@ describe Braintree::Transaction do
           expect(result.transaction.network_transaction_id).not_to be_nil
         end
 
+        it "accepts previous_mastercard_transaction_link_id" do
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::MasterCard,
+              :expiration_date => "05/2009"
+            },
+            :external_vault => {
+              :status => Braintree::Transaction::ExternalVault::Status::Vaulted,
+              :previous_mastercard_transaction_link_id => "1234567890123456789012",
+            },
+            :amount => "10.00",
+          )
+          expect(result.success?).to eq(true)
+          expect(result.transaction.network_transaction_id).not_to be_nil
+        end
+
         it "rejects non-vaulted status with previous_network_transaction_id" do
           result = Braintree::Transaction.create(
             :type => "sale",
@@ -5029,6 +5046,40 @@ describe Braintree::Transaction do
           expect(result.success?).to eq(false)
           expect(result.errors.for(:transaction).for(:external_vault).on(:status)[0].code).to eq(Braintree::ErrorCodes::Transaction::ExternalVault::StatusWithPreviousNetworkTransactionIdIsInvalid)
         end
+
+        it "rejects non-vaulted status with previous_mastercard_transaction_link_id" do
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::MasterCard,
+              :expiration_date => "05/2009"
+            },
+            :external_vault => {
+              :status => Braintree::Transaction::ExternalVault::Status::WillVault,
+              :previous_mastercard_transaction_link_id => "1234567890123456789012",
+            },
+            :amount => "10.00",
+          )
+          expect(result.success?).to eq(false)
+          expect(result.errors.for(:transaction).for(:external_vault).on(:status)[0].code).to eq(Braintree::ErrorCodes::Transaction::ExternalVault::StatusWithPreviousMastercardTransactionLinkIdIsInvalid)
+        end
+
+        it "rejects previous_mastercard_transaction_link_id that is not 22 characters" do
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::MasterCard,
+              :expiration_date => "05/2009"
+            },
+            :external_vault => {
+              :status => Braintree::Transaction::ExternalVault::Status::Vaulted,
+              :previous_mastercard_transaction_link_id => "1234567890123456789012123",
+            },
+            :amount => "10.00",
+          )
+          expect(result.success?).to eq(false)
+          expect(result.errors.for(:transaction).for(:external_vault).on(:previous_mastercard_transaction_link_id)[0].code).to eq(Braintree::ErrorCodes::Transaction::ExternalVault::PreviousMastercardTransactionLinkIdIsInvalid)
+        end
       end
 
       context "Non-(Visa/Mastercard/Discover/AmEx) card types" do
@@ -7339,6 +7390,85 @@ describe Braintree::Transaction do
     end
   end
 
+  describe "self.reverse" do
+    it "voids a voidable transaction" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        },
+      )
+
+      result = Braintree::Transaction.reverse(transaction.id)
+
+      expect(result.success?).to eq(true)
+      expect(result.transaction.id).to eq(transaction.id)
+      expect(result.transaction.status).to eq(Braintree::Transaction::Status::Voided)
+      expect(result.transaction.refunded_transaction_id).to be_nil
+    end
+
+    it "returns an error when reversing twice without an api request key" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        },
+      )
+
+      expect(Braintree::Transaction.reverse(transaction.id)).to be_success
+      result = Braintree::Transaction.reverse(transaction.id)
+
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:transaction).on(:base).first.code).to eq(
+        Braintree::ErrorCodes::Transaction::CannotRefundUnlessSettled,
+      )
+    end
+
+    it "voids an explicitly created voidable refund" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        },
+        :options => {
+          :submit_for_settlement => true
+        },
+      )
+      Braintree::TestTransaction.settle(transaction.id)
+      refund = Braintree::Transaction.refund!(transaction.id)
+
+      result = Braintree::Transaction.reverse(refund.id)
+
+      expect(result.success?).to eq(true)
+      expect(result.transaction.id).to eq(refund.id)
+      expect(result.transaction.status).to eq(Braintree::Transaction::Status::Voided)
+      expect(result.transaction.refunded_transaction_id).to eq(transaction.id)
+    end
+
+    it "refunds a settled transaction" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        },
+        :options => {
+          :submit_for_settlement => true
+        },
+      )
+      Braintree::TestTransaction.settle(transaction.id)
+
+      result = Braintree::Transaction.reverse(transaction.id)
+
+      expect(result.success?).to eq(true)
+      expect(result.transaction.type).to eq(Braintree::Transaction::Type::Credit)
+      expect(result.transaction.refunded_transaction_id).to eq(transaction.id)
+    end
+  end
+
   describe "self.void" do
     it "returns a successful result if successful" do
       transaction = Braintree::Transaction.sale!(

data/spec/unit/braintree/credit_card_spec.rb

@@ -23,7 +23,7 @@ describe Braintree::CreditCard do
         :venmo_sdk_payment_method_code, # NEXT_MAJOR_VERSION Remove this attribute
         :device_data,
         :payment_method_nonce,
-        {:external_vault=>[:network_transaction_id]},
+        {:external_vault=>[:network_transaction_id, :mastercard_transaction_link_id]},
         {:options => match_array([:make_default, :skip_advanced_fraud_checking, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, # NEXT_MAJOR_VERSION Remove this attribute
           :account_information_inquiry, :fail_on_duplicate_payment_method, :fail_on_duplicate_payment_method_for_customer, :verification_account_type, :verification_currency_iso_code])},
         {:billing_address => [
@@ -72,7 +72,7 @@ describe Braintree::CreditCard do
         :venmo_sdk_payment_method_code, # NEXT_MAJOR_VERSION Remove this attribute
         :device_data,
         :payment_method_nonce,
-        {:external_vault=>[:network_transaction_id]},
+        {:external_vault=>[:network_transaction_id, :mastercard_transaction_link_id]},
         {:options => match_array([:make_default, :skip_advanced_fraud_checking, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, # NEXT_MAJOR_VERSION Remove this attribute
           :account_information_inquiry, :fail_on_duplicate_payment_method, :fail_on_duplicate_payment_method_for_customer, :verification_account_type, :verification_currency_iso_code])},
         {:billing_address => [

data/spec/unit/braintree/credit_card_verification_gateway_spec.rb

@@ -31,6 +31,7 @@ describe Braintree::CreditCardVerificationGateway do
       expect(result.inspect).to include("number")
       expect(result.inspect).to include("external_vault")
       expect(result.inspect).to include("previous_network_transaction_id")
+      expect(result.inspect).to include("previous_mastercard_transaction_link_id")
       expect(result.inspect).to include("status")
       expect(result.inspect).to include("intended_transaction_source")
       expect(result.inspect).to include("options")

data/spec/unit/braintree/customer_spec.rb

@@ -136,7 +136,7 @@ describe Braintree::Customer do
           :venmo_sdk_payment_method_code, # NEXT_MAJOR_VERSION Remove this attribute
           :device_data,
           :payment_method_nonce,
-          {:external_vault=>[:network_transaction_id]},
+          {:external_vault=>[:network_transaction_id, :mastercard_transaction_link_id]},
           {:options => match_array([:make_default, :skip_advanced_fraud_checking, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, # NEXT_MAJOR_VERSION Remove this attribute
             :account_information_inquiry, :fail_on_duplicate_payment_method, :verification_account_type, :verification_currency_iso_code])},
           {:billing_address => [
@@ -267,7 +267,7 @@ describe Braintree::Customer do
           :venmo_sdk_payment_method_code, # NEXT_MAJOR_VERSION Remove this attribute
           :device_data,
           :payment_method_nonce,
-          {:external_vault=>[:network_transaction_id]},
+          {:external_vault=>[:network_transaction_id, :mastercard_transaction_link_id]},
           {:options => match_array([
             :account_information_inquiry,
             :make_default,

data/spec/unit/braintree/transaction_gateway_spec.rb

@@ -53,6 +53,7 @@ describe Braintree::TransactionGateway do
         {:external_vault => [
           :status,
           :previous_network_transaction_id,
+          :previous_mastercard_transaction_link_id,
         ]},
         {:google_pay_card => [:number, :cryptogram, :google_transaction_id, :expiration_month, :expiration_year, :source_card_type, :source_card_last_four, :eci_indicator]},
         {:industry => [
@@ -210,5 +211,18 @@ describe Braintree::TransactionGateway do
         :surcharge_amount,
       ])
     end
+
+    it "creates a transaction gateway reverse signature" do
+      expect(Braintree::TransactionGateway._reverse_signature).to match([
+        :api_request_key,
+      ])
+    end
+
+    it "rejects invalid transaction IDs when reversing" do
+      transaction = Braintree::TransactionGateway.new(gateway)
+
+      expect { transaction.reverse("../transactions/victim") }
+        .to raise_error(ArgumentError, "transaction_id contains invalid characters")
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: braintree
 version: !ruby/object:Gem::Version
-  version: 4.41.0
+  version: 4.42.0
 platform: ruby
 authors:
 - Braintree
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-16 00:00:00.000000000 Z
+date: 2026-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: builder