spree_core 6.0.0.beta4 → 6.0.0.rc2

data/app/models/concerns/spree/acted_by.rb

@@ -158,7 +158,7 @@ module Spree
           next if value.blank? || Spree.actor_classes.include?(value)
 
           errors.add(type_column, :unregistered_actor,
-                     message: Spree.t('errors.messages.unregistered_actor'))
+                     message: I18n.t('spree.errors.messages.unregistered_actor'))
         end
       end
 

data/app/models/concerns/spree/admin_user_methods.rb

@@ -4,12 +4,21 @@ module Spree
 
     include Spree::Actor
     include Spree::PrefixedId
+    include Spree::SignedIdAttachments
     include Spree::UserRoles
     include Spree::RansackableAttributes
 
     included do
       has_prefix_id :adm
 
+      publishes_events 'admin_user.password_reset', 'seller_user.password_reset'
+      # Carry a live reset token and have no external consumer: core sends
+      # these emails itself, so no webhook endpoint ever receives them.
+      publishes_event 'admin_user.password_reset_requested',
+                      serializer: 'Spree::Api::V3::PasswordResetRequestedEventSerializer', webhook: false
+      publishes_event 'seller_user.password_reset_requested',
+                      serializer: 'Spree::Api::V3::PasswordResetRequestedEventSerializer', webhook: false
+
       has_person_name
 
       normalizes :email, :first_name, :last_name, with: ->(value) { value&.to_s&.squish&.presence }
@@ -58,6 +67,7 @@ module Spree
 
       # Attachments
       has_one_attached :avatar, service: Spree.public_storage_service_name
+      signed_id_attachments :avatar
 
       validates :avatar, content_type: Rails.application.config.active_storage.web_image_content_types
 
@@ -128,10 +138,14 @@ module Spree
     # @param model [Class]
     # @param name [Symbol] the acted_by association
     def clear_actor(model, name)
+      columns = Spree::ActedBy.columns_for(name, nil)
+      # Append-only tables (revisions) have no updated_at to stamp.
+      columns = columns.merge(updated_at: Time.current) if model.column_names.include?('updated_at')
+
       model.
         where(:"#{name}_id" => id).
         where(:"#{name}_type" => [self.class.polymorphic_name, nil]).
-        update_all(Spree::ActedBy.columns_for(name, nil).merge(updated_at: Time.current))
+        update_all(columns)
     end
   end
 end

data/app/models/concerns/spree/api_typed.rb

@@ -0,0 +1,91 @@
+module Spree
+  # Wire shorthand for the plain-Ruby strategy classes a merchant picks from a
+  # registry (fulfillment, delivery-rate, pickup-point, payout and digital
+  # asset providers, order routing strategies). Records keep storing the class
+  # name; the API reads and writes this shorthand, so the contract never
+  # carries a Ruby constant.
+  #
+  #   class Spree::FulfillmentProvider::Base
+  #     extend Spree::ApiTyped
+  #   end
+  #
+  #   Spree::FulfillmentProvider::Manual.api_type  # => "manual"
+  #   SpreeEasyPost::FulfillmentProvider.api_type  # => "easy_post"
+  module ApiTyped
+    # The demodulized + underscored leaf. A gem names its class after the
+    # family (`SpreeEasyPost::FulfillmentProvider`, `SpreeAcmeOms::Strategy`),
+    # where the leaf would collapse every gem to one value — those derive it
+    # from the gem's module instead, matching {Spree::Integration.api_type}.
+    # Any other class keeps its leaf, so two providers nested in one module
+    # never share a value. Override to keep the value stable across a rename.
+    #
+    # @return [String]
+    def api_type
+      leaf = name.to_s.demodulize
+      outer = name.to_s.deconstantize.demodulize.delete_prefix('Spree')
+      return leaf.underscore unless leaf == api_typed_family && outer.present?
+
+      outer.underscore
+    end
+
+    # The family's own name — the module its base class sits in
+    # (`FulfillmentProvider` for `Spree::FulfillmentProvider::Base`).
+    #
+    # @return [String, nil]
+    def api_typed_family
+      base = ancestors.reverse.find { |ancestor| ancestor.is_a?(Class) && ancestor.singleton_class.include?(Spree::ApiTyped) }
+      base&.name.to_s.deconstantize.demodulize.presence
+    end
+
+    # The registered class answering to a wire shorthand, or nil.
+    #
+    # @param registry [Array<Class, String>]
+    # @param api_type [String, nil]
+    # @return [Class, nil]
+    def self.find(registry, api_type)
+      return nil if api_type.blank?
+
+      Array(registry).map { |entry| entry.is_a?(Class) ? entry : entry.to_s.safe_constantize }.
+        compact.find { |klass| klass.api_type == api_type.to_s }
+    end
+
+    # The registered class a record's stored class name points at, or nil
+    # when it is no longer registered (a typo, an uninstalled gem) — so a
+    # stored string is never constantized outside the registry.
+    #
+    # @param registry [Array<Class>]
+    # @param class_name [String, nil]
+    # @return [Class, nil]
+    def self.registered_class(registry, class_name)
+      return nil if class_name.blank?
+
+      Array(registry).find { |klass| klass.to_s == class_name.to_s }
+    end
+
+    # The class name a record stores for a value arriving from the API. A
+    # registered shorthand becomes its class name; anything else passes through
+    # unchanged so the record's own inclusion validation rejects it.
+    #
+    # @param registry [Array<Class, String>]
+    # @param value [String, nil]
+    # @return [String, nil]
+    def self.class_name_for(registry, value)
+      return value if value.blank?
+
+      find(registry, value)&.to_s || value
+    end
+
+    # The shorthand for a stored class name. A class that is no longer
+    # registered (an uninstalled gem) is shortened the same way rather than
+    # constantized.
+    #
+    # @param class_name [String, nil]
+    # @return [String, nil]
+    def self.api_type_for(class_name)
+      return nil if class_name.blank?
+
+      klass = class_name.to_s.safe_constantize
+      klass.respond_to?(:api_type) ? klass.api_type : class_name.to_s.demodulize.underscore
+    end
+  end
+end

data/app/models/concerns/spree/calculated_adjustments.rb

@@ -26,32 +26,60 @@ module Spree
       def calculator_type=(calculator_type)
         return if calculator_type.blank?
 
-        registry = self.class.respond_to?(:calculators) ? self.class.calculators : []
-        klass = registry.find { |k| k.api_type == calculator_type.to_s }
+        klass = registered_calculator_class(calculator_type)
         self.calculator = klass.new if klass && !calculator.instance_of?(klass)
       end
 
-      # API v3 writer for the flat `calculator: { type:, preferences: {} }`
-      # payload. Routes preferences through `set_preference` so values are
-      # coerced by the typed `preferred_<name>=` setters — direct
-      # assignment to the serialized hash would skip coercion.
-      def assign_calculator_attributes(attrs)
+      # API v3 writer for the `calculator: { type:, preferences: {} }`
+      # payload. A type the registry does not list is refused like a setting
+      # that does not match (`/calculator/type`); preferences are checked
+      # against the calculator's schema and written through its typed writers.
+      #
+      # @param attrs [Hash, ActionController::Parameters, nil]
+      # @param pointer [String] where the calculator sits in the request
+      # @raise [Spree::Preferences::InvalidPreferences] for a type the registry does not list, or
+      #   preferences that do not match its schema
+      # @return [void]
+      def assign_calculator_attributes(attrs, pointer: '/calculator')
         return if attrs.nil?
 
         attrs = attrs.to_h.with_indifferent_access
-        self.calculator_type = attrs[:type] if attrs[:type].present?
-
-        return if calculator.nil? || attrs[:preferences].blank?
+        type = attrs[:type].to_s
+        target = calculator
+        if type.present? && calculator&.class&.api_type != type
+          klass = registered_calculator_class(type)
+          unless klass
+            raise Spree::Preferences::InvalidPreferences.new(
+              [{ pointer: '/type', message: I18n.t('spree.errors.messages.unknown_calculator_type', type: type) }], prefix: pointer
+            )
+          end
 
-        attrs[:preferences].to_h.each do |key, value|
-          next unless calculator.has_preference?(key.to_sym)
+          target = klass.new
+        end
 
-          calculator.set_preference(key.to_sym, value)
+        if attrs[:preferences].present?
+          # Preferences sent without a type land on the default calculator
+          # rather than on nothing, for a model that has one.
+          target ||= default_calculator if respond_to?(:default_calculator, true)
+          target&.assign_preferences(attrs[:preferences], pointer: "#{pointer}/preferences")
         end
+
+        # Attached only once its settings are accepted: on a saved owner,
+        # assigning a has_one replaces the stored calculator immediately.
+        self.calculator = target unless target.equal?(calculator)
       end
 
       private
 
+      # The registered calculator for an API shorthand, resolved from the
+      # registry entry's own name: nothing user-supplied reaches
+      # `constantize`, and in development the registry can hold a class from
+      # an earlier reload whose instances fail the association's type check.
+      def registered_calculator_class(type)
+        registry = self.class.respond_to?(:calculators) ? self.class.calculators : []
+        registry.find { |klass| klass.api_type == type.to_s }&.to_s&.constantize
+      end
+
       def self.model_name_without_spree_namespace
         to_s.tableize.tr('/', '_').sub('spree_', '')
       end

data/app/models/concerns/spree/calculator/currency_amounts.rb

@@ -13,7 +13,7 @@ module Spree
       extend ActiveSupport::Concern
 
       included do
-        preference :amounts, :hash, default: {}
+        preference :amounts, :hash, keys: :currency, values: :money, default: {}
       end
 
       # The amount this calculator quotes for a currency: the per-currency

data/app/models/concerns/spree/calculator/tiers.rb

@@ -0,0 +1,63 @@
+module Spree
+  class Calculator < Spree.base_class
+    # A tier ladder for the tiered calculators: a list of
+    # `{ "threshold" => "100.0", "value" => "10.0" }` objects, where the value
+    # is a percentage or an amount depending on the calculator. A list rather
+    # than a hash keyed by threshold, because JSON object keys are always
+    # strings and a number key would not survive storage.
+    module Tiers
+      extend ActiveSupport::Concern
+
+      included do
+        preference :tiers, :array, of: :object, properties: { threshold: :money, value: :decimal }, default: []
+
+        validate :preferred_tiers_content
+      end
+
+      # @return [BigDecimal, nil] nil when the value is not a number
+      def self.decimal(value)
+        BigDecimal(value.to_s, exception: false)
+      end
+
+      # The value of the highest tier whose threshold the amount reaches.
+      #
+      # @param amount [Numeric]
+      # @return [BigDecimal, nil] nil when the amount reaches no tier
+      def tier_value_for(amount)
+        tier_pairs.reverse_each.detect { |threshold, _| amount >= threshold }&.last
+      end
+
+      private
+
+      # Tiers that are not numbers are skipped: validation refuses them on
+      # save, but an unsaved calculator can still be asked to compute. Tiers
+      # still in the pre-6.0 hash keyed by threshold, left by an upgrade that
+      # could not convert them, keep discounting until they are converted.
+      #
+      # @return [Array<Array(BigDecimal, BigDecimal)>] threshold and value, lowest threshold first
+      def tier_pairs
+        tiers = preferred_tiers
+        pairs = case tiers
+                when Hash then tiers.to_a
+                when Array then tiers.grep(Hash).map { |tier| tier.values_at('threshold', 'value') }
+                else []
+                end
+        pairs.map { |threshold, value| [Tiers.decimal(threshold), Tiers.decimal(value)] }.select(&:all?).sort_by(&:first)
+      end
+
+      def preferred_tiers_content
+        tiers = preferred_tiers
+        unless tiers.is_a?(Array) && tiers.all? { |tier| tier.is_a?(Hash) }
+          return errors.add(:preferred_tiers, :should_be_list)
+        end
+
+        thresholds = tiers.map { |tier| Tiers.decimal(tier['threshold']) }
+        values = tiers.map { |tier| Tiers.decimal(tier['value']) }
+
+        errors.add(:preferred_tiers, :thresholds_should_be_positive_number) unless thresholds.all? { |threshold| threshold&.positive? }
+        errors.add(:preferred_tiers, :thresholds_should_be_unique) unless thresholds.uniq.size == thresholds.size
+        validate_tier_values(values)
+      end
+    end
+  end
+end

data/app/models/concerns/spree/canonical_decimals.rb

@@ -0,0 +1,61 @@
+module Spree
+  # Decimal attributes written as a number or canonical decimal text
+  # ("1234.56"). Text in any other shape raises Spree::Money::InvalidFormat,
+  # which the API answers as `invalid_money_format`, instead of being read as
+  # a wrong number the way Rails' cast reads "1,599.99" as 1 and "$10" as 0.
+  #
+  # The columns hold four decimals, so a value with more decimals than it may
+  # carry is refused on validation rather than stored and left to drift: an
+  # amount that changes hands keeps its currency's decimals, a unit price four,
+  # a rate its column's scale.
+  module CanonicalDecimals
+    extend ActiveSupport::Concern
+
+    private
+
+    # nil when the record has no currency yet (a payment before its order),
+    # which leaves the check to the record's own presence validations.
+    def canonical_decimals_currency_places
+      currency = try(:currency)
+      Spree::Money::Rounding.precision(currency) if currency.present?
+    rescue ActiveSupport::DelegationError
+      nil
+    end
+
+    class_methods do
+      # @param names [Array<Symbol>]
+      # @param places [:currency, Integer, nil] decimals allowed: the record's
+      #   currency's, a fixed count, or nil for no check
+      # @param ignore_blank [Boolean] leave the attribute as it was when given a blank
+      def canonical_decimals(*names, places: :currency, ignore_blank: false)
+        names.each do |name|
+          define_method("#{name}=") do |value|
+            next if ignore_blank && value.blank?
+
+            super(Spree::Money::Rounding.parse_decimal(value))
+          rescue Spree::Money::InvalidFormat => error
+            raise Spree::Money::InvalidFormat.new(error.message, field: name)
+          end
+        end
+
+        return if places.nil?
+
+        validate do
+          allowed = places == :currency ? canonical_decimals_currency_places : places
+          next if allowed.nil?
+
+          names.each do |name|
+            next unless will_save_change_to_attribute?(name)
+
+            # Read before the column's scale rounds it away.
+            raw = read_attribute_before_type_cast(name)
+            value = raw.is_a?(Numeric) ? BigDecimal(raw.to_s) : self[name]
+            next if value.nil? || value.round(allowed) == value
+
+            errors.add(name, :too_many_decimals, count: allowed)
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/spree/customer_methods.rb

@@ -3,6 +3,7 @@ module Spree
     extend ActiveSupport::Concern
 
     include Spree::PrefixedId
+    include Spree::SignedIdAttachments
     include Spree::HasCustomFields
     include Spree::UserAddress
     include Spree::UserPaymentSource
@@ -20,8 +21,10 @@ module Spree
       # 2026-03-16 "Consolidate metadata") — no public/private split.
       attribute :metadata, default: -> { {} }
 
-      # Enable lifecycle events for user models
       publishes_lifecycle_events
+      publishes_events 'customer.password_reset', 'customer.anonymized'
+      publishes_event 'customer.password_reset_requested',
+                      serializer: 'Spree::Api::V3::PasswordResetRequestedEventSerializer', credential: 'write_customers'
 
       # Password reset token (Rails 7.1+ signed token, no DB column needed)
       # Token auto-invalidates when password changes (salt changes)
@@ -117,6 +120,7 @@ module Spree
       # Attachments
       #
       has_one_attached :avatar, service: Spree.public_storage_service_name
+      signed_id_attachments :avatar
 
       has_spree_rich_text :internal_note
 
@@ -184,14 +188,12 @@ module Spree
         where(conditions.reduce(:or))
       end
 
-      # Backward compatibility alias — remove in Spree 6.0
-      def self.multi_search(query) = search(query)
-
       self.whitelisted_ransackable_associations = %w[bill_address ship_address addresses tags spree_roles orders customer_groups]
       self.whitelisted_ransackable_attributes = %w[id email first_name last_name phone accepts_email_marketing
-                                                    created_at updated_at last_sign_in_at]
-      self.whitelisted_ransackable_scopes = %w[search multi_search with_min_total_spent with_standing_for_company
+                                                    created_at updated_at]
+      self.whitelisted_ransackable_scopes = %w[search with_min_total_spent with_standing_for_company
                                                anonymized]
+      self.ransackable_scope_types = { 'with_min_total_spent' => 'decimal', 'with_standing_for_company' => { list: 'id' }, 'anonymized' => 'boolean' }
 
       # Two-state scope: see Spree::Base.ransack_flag? for why the cast is
       # opted out of here and done inside the scope instead.
@@ -223,10 +225,11 @@ module Spree
       }
 
       # Customers with standing for a company: members of the node or of any
-      # ancestor (see #standing_for?). Accepts a record, an id, or an array.
-      scope :with_standing_for_company, ->(companies) {
+      # ancestor (see #standing_for?). Accepts records, ids, or an array; a
+      # splat because Ransack passes each value of a list as its own argument.
+      scope :with_standing_for_company, ->(*companies) {
         scoped = Spree::Current.store&.companies || Spree::Company.none
-        nodes = Array.wrap(companies).filter_map do |company|
+        nodes = companies.flatten.filter_map do |company|
           company.is_a?(Spree::Company) ? company : scoped.find_by_param(company)
         end
         next none if nodes.empty?
@@ -278,6 +281,16 @@ module Spree
       end
     end
 
+    class_methods do
+      # Customer lifecycle events are `user.*`; an installation whose staff
+      # class shares these methods publishes theirs as `admin.*`.
+      #
+      # @return [String]
+      def event_prefix
+        self == Spree.admin_user_class && Spree.admin_user_class != Spree.customer_class ? 'admin' : 'user'
+      end
+    end
+
     # Returns the last incomplete spree order for the current store
     # @deprecated Carts are {Spree::Cart} since 6.0, so an incomplete order is
     #   a backoffice draft rather than the customer's cart. Use
@@ -337,7 +350,7 @@ module Spree
     # @return [Spree::Wishlist]
     def default_wishlist_for_store(current_store)
       wishlists.find_by(is_default: true, store_id: current_store.id) || ActiveRecord::Base.connected_to(role: :writing) do
-        wishlists.create!(store: current_store, is_default: true, name: Spree.t(:default_wishlist_name))
+        wishlists.create!(store: current_store, is_default: true, name: I18n.t('spree.default_wishlist_name'))
       end
     end
 
@@ -368,14 +381,6 @@ module Spree
       'Spree::Api::V3::CustomerSerializer'.safe_constantize
     end
 
-    def event_prefix
-      if self.class == Spree.admin_user_class && Spree.admin_user_class != Spree.customer_class
-        'admin'
-      else
-        'user'
-      end
-    end
-
     # @param store [Spree::Store] store to scope the lookup to; defaults to the current store
     # @return [Spree::NewsletterSubscriber, nil] this user's newsletter subscriber for the given store
     def newsletter_subscriber(store = Spree::Current.store)

data/app/models/concerns/spree/derived_number.rb

@@ -43,24 +43,22 @@ module Spree
     # unsaved record sorts last, which is what a merchant watching a new row
     # appear expects.
     def position_among_siblings
-      scope = sibling_scope
-      return 1 if scope.nil?
+      parent = owner
+      association = sibling_association_name
+      return 1 if parent.nil? || !parent.respond_to?(association)
 
-      earlier = id.nil? ? scope.count : scope.where(scope.arel_table[:id].lt(id)).count
+      earlier = if id.present? && parent.read_association_in_memory?(association)
+                  parent.public_send(association).to_a.count { |sibling| sibling.id.present? && sibling.id < id }
+                else
+                  scope = parent.public_send(association).unscope(:order)
+                  id.nil? ? scope.count : scope.where(scope.arel_table[:id].lt(id)).count
+                end
 
       earlier + 1
     end
 
-    # The siblings sharing this record's parent. Nil when there is no parent
-    # to group by.
-    def sibling_scope
-      parent = owner
-      return if parent.nil?
-
-      association = self.class.name.demodulize.underscore.pluralize
-      return unless parent.respond_to?(association)
-
-      parent.public_send(association).unscope(:order)
+    def sibling_association_name
+      self.class.name.demodulize.underscore.pluralize
     end
   end
 end

data/app/models/concerns/spree/email_template_identity.rb

@@ -0,0 +1,52 @@
+module Spree
+  # What a store's published email template and its draft share: which
+  # editable template they are, in which language, and the default they
+  # started from.
+  module EmailTemplateIdentity
+    extend ActiveSupport::Concern
+
+    # The version every language uses. Never NULL, so the unique index on
+    # store, key and locale holds for it too.
+    ANY_LOCALE = 'any'.freeze
+    LOCALE_FORMAT = /\A(any|[a-z]{2,3}(-[A-Za-z0-9]{2,8})*)\z/
+
+    included do
+      include Spree::SingleStoreResource
+
+      normalizes :locale, with: ->(locale) { locale.to_s.strip.presence || ANY_LOCALE }, apply_to_nil: true
+
+      validates :key, presence: true, uniqueness: { scope: spree_base_uniqueness_scope + [:store_id, :locale] }
+      validates :locale, format: { with: LOCALE_FORMAT }
+      validates :body, :base_body, presence: true
+      validate :key_editable
+      validate :locale_supported
+
+      scope :for_key, ->(key, locale = ANY_LOCALE) { where(key: key, locale: locale) }
+    end
+
+    # @return [Spree::Emails::EditableTemplates::Definition, nil]
+    def definition
+      Spree.editable_email_templates[key]
+    end
+
+    # @return [Boolean] whether Spree's default changed since this version started from it
+    # @param default [Spree::Emails::Template, nil] the current default
+    def default_changed?(default)
+      return false unless default
+
+      default.body != base_body || default.subject.to_s != base_subject.to_s
+    end
+
+    private
+
+    def key_editable
+      errors.add(:key, :invalid) if key.present? && definition.nil?
+    end
+
+    def locale_supported
+      return if locale == ANY_LOCALE || store.nil?
+
+      errors.add(:locale, :inclusion) unless store.supported_locales_list.include?(locale)
+    end
+  end
+end

data/app/models/concerns/spree/parameterizable_name.rb

@@ -20,6 +20,8 @@ module Spree
         end
       end
 
+      scope :with_name, ->(value) { where(name: value.to_s.parameterize) }
+
       def set_name_from_label
         self.name = label
       end

data/app/models/concerns/spree/payment_session_transitions.rb

@@ -24,10 +24,16 @@ module Spree
       pending?
     end
 
-    %w[complete fail cancel expire].each do |transition|
+    %w[complete fail expire].each do |transition|
       define_method(:"can_#{transition}?") { pending? || processing? }
     end
 
+    # A failed confirm can leave the provider intent payable. Cancel is how
+    # placement retires it; the other transitions stay closed.
+    def can_cancel?
+      pending? || processing? || failed?
+    end
+
     def process
       return false unless transition_to('processing', from: %w[pending])
 
@@ -50,7 +56,7 @@ module Spree
     end
 
     def cancel
-      return false unless transition_to('canceled', from: %w[pending processing])
+      return false unless transition_to('canceled', from: %w[pending processing failed])
 
       publish_canceled_event
       true

data/app/models/concerns/spree/post_sale/taxation.rb

@@ -0,0 +1,54 @@
+module Spree
+  module PostSale
+    # Asks the order's tax provider what tax a return, claim or exchange gives
+    # back. Including models name their lines through +taxed_lines+.
+    #
+    # The provider is asked twice: when the record opens, for what was
+    # announced, and again before money moves, for what actually goes back.
+    # Only the first is copied onto the lines' columns — they keep what was
+    # announced, the way a return line's +pre_tax_amount+ does — while the rows
+    # always say what the customer is, or was, refunded.
+    module Taxation
+      extend ActiveSupport::Concern
+
+      # @return [void]
+      # @raise [Spree::Tax::ProviderError]
+      def calculate_tax!
+        lines = taxed_lines.to_a
+        estimate_tax(lines)
+        lines.each(&:fold_tax_lines!)
+      end
+
+      # @param amounts [Hash{Object => BigDecimal}, nil] the money refunded per
+      #   line when it is less than the line is worth
+      # @return [void]
+      # @raise [Spree::Tax::ProviderError]
+      def settle_tax!(amounts: nil)
+        lines = taxed_lines.select(&:settles_tax?)
+        estimate_tax(lines, amounts: amounts) if lines.any?
+      end
+
+      # Drops every row on the record's lines, for a record withdrawn before
+      # anything went back. Nothing is worked out, so the provider is not asked
+      # — a cancellation must not wait on, or fail with, a tax service.
+      #
+      # @return [void]
+      def clear_tax!
+        Spree::TaxLine.post_sale.where(Spree::TaxLine.adjustable_key_for(taxed_lines.klass) => taxed_lines.select(:id)).delete_all
+      end
+
+      # The tax the record's lines give back, as their credit rows stand.
+      #
+      # @return [BigDecimal]
+      def credited_tax_total
+        taxed_lines.sum(0.to_d, &:credited_tax_total)
+      end
+
+      private
+
+      def estimate_tax(lines, amounts: nil)
+        order.tax_provider.estimate_refund(order, lines, amounts: amounts, tax_date: order.completed_at)
+      end
+    end
+  end
+end