spree_core 5.6.1 → 6.0.0.beta2

data/app/models/spree/order.rb

@@ -1,12 +1,7 @@
-require_dependency 'spree/order/checkout'
-require_dependency 'spree/order/currency_updater'
-require_dependency 'spree/order/digital'
-require_dependency 'spree/order/payments'
-require_dependency 'spree/order/store_credit'
-require_dependency 'spree/order/gift_card'
 
 module Spree
   class Order < Spree.base_class
+    include Spree::CSV::CustomFieldsHelper
     has_prefix_id :or  # Stripe: or_
 
     # Legacy free-text `channel` column was replaced by the `channel_id` FK
@@ -14,64 +9,82 @@ module Spree
     # 5.4-to-5.5 backfill rake can read it; AR ignores it everywhere else.
     self.ignored_columns += ['channel']
 
+    # What Orders::UpdateStatuses derives — the only writer of the column.
+    PAYMENT_STATUSES = %w(none authorized partially_paid paid partially_refunded refunded overcharged voided).freeze
+    # @deprecated legacy machine vocabulary; rows carrying it stay valid until
+    #   the status migration rewrites them. Removed in 6.1.
     PAYMENT_STATES = %w(balance_due credit_owed failed paid void)
-    SHIPMENT_STATES = %w(backorder canceled partial pending ready shipped)
+    FULFILLMENT_STATUSES = %w(backorder canceled partial unfulfilled fulfilled delivered pending ready shipped)
+    # @deprecated legacy name — remove in 6.1 together with the 'shipped' value
+    SHIPMENT_STATES = FULFILLMENT_STATUSES
+    # @deprecated legacy machine vocabulary — line-item removability is
+    #   completion-based since 6.0; removed in 6.1.
     LINE_ITEM_REMOVABLE_STATES = %w(cart address delivery payment confirm resumed)
 
     extend Spree::DisplayMoney
 
-    include Spree::Order::Checkout
-    include Spree::Order::CurrencyUpdater
-    include Spree::Order::Digital
-    include Spree::Order::Payments
-    include Spree::Order::StoreCredit
-    include Spree::Order::AddressBook
-    include Spree::Order::Webhooks
-    include Spree::Core::NumberGenerator.new(prefix: 'R')
-    include Spree::Order::GiftCard
+    include Spree::ActedBy
+    include Spree::SingleStoreResource
+    include Spree::SanitizableRichText
+    include Spree::Purchase::Channel
+    include Spree::Purchase::Company
+    include Spree::Purchase::Freight
+    include Spree::Purchase::QuantityRules
+    include Spree::Purchase::PurchaseOrder
+    include Spree::Purchase::Market
+    include Spree::Purchase::Currency
+    include Spree::Purchase::Locale
+    include Spree::Purchase::DigitalItems
+    include Spree::Purchase::Taxation
+    include Spree::Purchase::StoreCredits
+    include Spree::Purchase::GiftCards
+    include Spree::Purchase::LineItemCurrencies
+    include Spree::Purchase::LineItemLookup
+    include Spree::Purchase::PaymentProcessing
+    include Spree::Purchase::Addresses
+    include Spree::Purchase::Validations
+    include Spree::Purchase::Totals
+    include Spree::Purchase::Lifecycle
+    has_spree_number prefix: 'R'
 
     include Spree::NumberIdentifier
-    include Spree::SingleStoreResource
 
     publishes_lifecycle_events
-    include Spree::MemoizedData
-    include Spree::Metafields
+    include Spree::HasCustomFields
     include Spree::Metadata
+    include Spree::HasExternalReferences
     include Spree::Searchable
     if defined?(Spree::Security::Orders)
       include Spree::Security::Orders
     end
-    if defined?(Spree::VendorConcern)
-      include Spree::VendorConcern
-    end
 
     has_secure_token :token, length: 35
-    has_rich_text :internal_note
 
-    MEMOIZED_METHODS = %w(tax_zone)
+    has_spree_rich_text :internal_note
 
     money_methods :outstanding_balance, :item_total,           :adjustment_total,
                   :included_tax_total,  :additional_tax_total, :tax_total,
-                  :shipment_total,      :promo_total,          :total,
+                  :delivery_total,      :discount_total,       :total,
                   :cart_promo_total,    :pre_tax_item_amount,  :pre_tax_total,
-                  :payment_total,       :amount_due
+                  :payment_total,       :amount_due,           :fee_total,
+                  :commission_amount_total, :commission_tax_total, :commission_total
 
-    alias display_ship_total display_shipment_total
-    alias_attribute :ship_total, :shipment_total
-    def amount_due
-      [outstanding_balance - total_applied_store_credit, 0].max
-    end
+    alias display_ship_total display_delivery_total
+    alias_attribute :ship_total, :delivery_total
 
-    # Transient warnings populated by remove_out_of_stock_items! and ensure_available_shipping_rates
+    # Transient warnings populated by remove_out_of_stock_items! and ensure_available_delivery_rates
     attribute :warnings, default: -> { [] }
 
     # Removes out-of-stock/discontinued items and populates warnings.
     # Returns self (reloaded if items were removed) with warnings set.
     # Captured before the call because removing items reloads the order, which
     # would drop warnings already recorded upstream.
+    # @deprecated Only Carts can auto remove out of stock items
     def remove_out_of_stock_items!
+      Spree::Deprecation.warn('Spree::Order#remove_out_of_stock_items! is deprecated and will be removed in Spree 6.1. This method now works only on Spree::Cart objects')
+
       existing_warnings = warnings
-      result = Spree::Cart::RemoveOutOfStockItems.call(order: self)
+      result = Spree::Carts::RemoveOutOfStockItems.call(cart: self)
       return self unless result.success?
 
       order, _messages, new_warnings = result.value
@@ -79,60 +92,100 @@ module Spree
       order
     end
 
-    # 5.5 API naming bridges (DB columns rename in 6.0)
-    alias_attribute :discount_total, :promo_total
-    alias display_discount_total display_promo_total
-    alias_attribute :customer_note, :special_instructions
-    alias_attribute :total_quantity, :item_count
-
-    MONEY_THRESHOLD  = 100_000_000
-    MONEY_VALIDATION = {
-      presence: true,
-      numericality: {
-        greater_than: -MONEY_THRESHOLD,
-        less_than: MONEY_THRESHOLD,
-        allow_blank: true
-      },
-      format: { with: /\A-?\d+(?:\.\d{1,2})?\z/, allow_blank: true }
-    }.freeze
-
-    POSITIVE_MONEY_VALIDATION = MONEY_VALIDATION.deep_dup.tap do |validation|
-      validation.fetch(:numericality)[:greater_than_or_equal_to] = 0
-    end.freeze
-
-    NEGATIVE_MONEY_VALIDATION = MONEY_VALIDATION.deep_dup.tap do |validation|
-      validation.fetch(:numericality)[:less_than_or_equal_to] = 0
-    end.freeze
-
-    checkout_flow do
-      go_to_state :address
-      go_to_state :delivery, if: ->(order) { order.delivery_required? }
-      go_to_state :payment, if: ->(order) { order.payment? || order.payment_required? }
-      go_to_state :confirm, if: ->(order) { order.confirmation_required? }
-      go_to_state :complete
-    end
-
-    self.whitelisted_ransackable_associations = %w[shipments user created_by approver canceler promotions bill_address ship_address line_items store channel tags]
+    # Checkout-step introspection belongs to Spree::Cart
+    # ({Spree::Purchase::CheckoutSteps}) since 6.0 — an order is past checkout
+    # by definition. These bridges answer for an upgrader reaching for the
+    # Spree 5 API on an order, rather than raising NoMethodError.
+    #
+    # The step list is data-driven, so it stays accurate here: the registry
+    # computes it from the record's own predicates, all of which Order carries.
+    # Where the checkout stands within that list is not, which is why the
+    # readers below report a finished checkout.
+
+    # @deprecated Checkout steps belong to Spree::Cart; removed in 6.1.
+    def checkout_steps
+      Spree::Deprecation.warn('Spree::Order#checkout_steps is deprecated and will be removed in Spree 6.1. Checkout steps belong to Spree::Cart — ask the cart before it is completed.')
+      Spree::Checkout::Registry.step_names_for(self)
+    end
+
+    # @deprecated See {#checkout_steps}; removed in 6.1.
+    def has_checkout_step?(step)
+      Spree::Deprecation.warn('Spree::Order#has_checkout_step? is deprecated and will be removed in Spree 6.1. Checkout steps belong to Spree::Cart — ask the cart before it is completed.')
+      step.present? && Spree::Checkout::Registry.step_names_for(self).include?(step.to_s)
+    end
+
+    # @deprecated See {#checkout_steps}; removed in 6.1.
+    def checkout_step_index(step)
+      Spree::Deprecation.warn('Spree::Order#checkout_step_index is deprecated and will be removed in Spree 6.1. Checkout steps belong to Spree::Cart — ask the cart before it is completed.')
+      Spree::Checkout::Registry.step_names_for(self).index(step).to_i
+    end
+
+    # @deprecated See {#checkout_steps}; removed in 6.1. An order has no
+    #   outstanding step, so this is always 'complete'.
+    def current_checkout_step
+      Spree::Deprecation.warn("Spree::Order#current_checkout_step is deprecated and will be removed in Spree 6.1. An order is past checkout, so this is always 'complete'.")
+      'complete'
+    end
+
+    # @deprecated See {#checkout_steps}; removed in 6.1.
+    def final_checkout_step
+      Spree::Deprecation.warn('Spree::Order#final_checkout_step is deprecated and will be removed in Spree 6.1. Checkout steps belong to Spree::Cart — ask the cart before it is completed.')
+      Spree::Checkout::Registry.step_names_for(self).reject { |step| step == 'complete' }.last || 'address'
+    end
+
+    # @deprecated See {#checkout_steps}; removed in 6.1. Every step is behind
+    #   an order, so this is the whole list bar 'complete'.
+    def completed_checkout_steps
+      Spree::Deprecation.warn("Spree::Order#completed_checkout_steps is deprecated and will be removed in Spree 6.1. An order is past checkout, so every step bar 'complete' is behind it.")
+      Spree::Checkout::Registry.step_names_for(self).reject { |step| step == 'complete' }
+    end
+
+    # Standardized column names (renamed in 6.0); legacy readers stay as
+    # aliases one release.
+    alias_attribute :promo_total, :discount_total
+    alias display_promo_total display_discount_total
+    alias_attribute :item_count, :total_quantity
+
+    # @deprecated The column is +customer_note+ since 6.0; removed in 6.1.
+    def special_instructions
+      Spree::Deprecation.warn('Spree::Order#special_instructions is deprecated and will be removed in Spree 6.1. Use #customer_note instead.')
+      customer_note
+    end
+
+    # @deprecated See {#special_instructions}; removed in 6.1.
+    def special_instructions=(value)
+      Spree::Deprecation.warn('Spree::Order#special_instructions= is deprecated and will be removed in Spree 6.1. Use #customer_note= instead.')
+      self.customer_note = value
+    end
+
+    # lock_version (renamed from state_lock_version) drives the API's manual
+    # optimistic concurrency (compare client-sent version, 409 on mismatch) —
+    # Rails auto-locking must not raise on internal saves.
+    self.lock_optimistically = false
+
+    self.whitelisted_ransackable_associations = %w[fulfillments shipments customer created_by approver canceler promotions bill_address ship_address line_items store channel tags seller order_group]
     self.whitelisted_ransackable_attributes = %w[
-      completed_at email number state status payment_state shipment_state
-      total item_total item_count considered_risky channel_id currency
+      completed_at email number status payment_status payment_state fulfillment_status shipment_state delivery_total
+      total item_total total_quantity considered_risky channel_id currency coupon_code customer_id seller_id
+      order_group_id po_number
     ]
     self.whitelisted_ransackable_scopes = %w[complete incomplete refunded partially_refunded search multi_search]
 
-    attr_reader :coupon_code
-    attr_accessor :temporary_address
-
     # Set to false on admin-initiated flows to suppress customer-facing emails.
     attr_accessor :notify_customer
 
-    attribute :state_machine_resumed, :boolean
 
     STATUSES = %w[draft placed canceled].freeze
 
     attribute :status, :string, default: 'draft'
     validates :status, inclusion: { in: STATUSES }
 
+    # Orders belonging to the given seller. Passing nil selects the
+    # operator's own sales, which on a store with no sellers is every order.
+    scope :for_seller, ->(seller) { where(seller_id: seller.respond_to?(:id) ? seller.id : seller) }
+
     scope :drafts,         -> { where(status: 'draft') }
+    scope :not_drafts,     -> { where.not(status: 'draft') }
     scope :placed_orders,  -> { where(status: 'placed') }
     scope :canceled_orders, -> { where(status: 'canceled') }
 
@@ -143,126 +196,127 @@ module Spree
       self.tag_list = tags
     end
 
-    ASSOCIATED_USER_ATTRIBUTES = [:user_id, :email, :bill_address_id, :ship_address_id]
-
-    # 6.0 forward-compat: User→Customer rename. Column stays user_id in 5.x.
-    alias_attribute :customer_id, :user_id
-
-    belongs_to :user, class_name: "::#{Spree.user_class}", optional: true, autosave: true
-    belongs_to :created_by, class_name: "::#{Spree.admin_user_class}", optional: true
-    belongs_to :approver, class_name: "::#{Spree.admin_user_class}", optional: true
-    belongs_to :canceler, class_name: "::#{Spree.admin_user_class}", optional: true
-
-    belongs_to :bill_address, foreign_key: :bill_address_id, class_name: 'Spree::Address',
-                              optional: true, dependent: :destroy
-    alias_method :billing_address, :bill_address
-    alias_method :billing_address=, :bill_address=
-    alias_attribute :billing_address_id, :bill_address_id
+    ASSOCIATED_CUSTOMER_ATTRIBUTES = [:customer_id, :email, :bill_address_id, :ship_address_id]
 
-    belongs_to :ship_address, foreign_key: :ship_address_id, class_name: 'Spree::Address',
-                              optional: true, dependent: :destroy
-    alias_method :shipping_address, :ship_address
-    alias_method :shipping_address=, :ship_address=
-    alias_attribute :shipping_address_id, :ship_address_id
+    # @deprecated Use {Spree::Purchase::PaymentProcessing#payment_methods};
+    #   removed in 6.1.
+    def collect_frontend_payment_methods
+      Spree::Deprecation.warn('Spree::Order#collect_frontend_payment_methods is deprecated and will be removed in Spree 6.1. Use #payment_methods instead.')
+      payment_methods
+    end
+
+    include Spree::DeprecatedCustomerAlias
+
+    belongs_to :customer, class_name: "::#{Spree.customer_class}", optional: true, autosave: true
+    # The cart this order was completed from (unique — the completion
+    # idempotency key). Backoffice draft orders have no cart.
+    belongs_to :cart, class_name: 'Spree::Cart', optional: true, inverse_of: :order
+    # The checkout this order was placed in, when it was placed alongside
+    # others — one per seller on a marketplace. A single-seller or first-party
+    # only checkout produces a bare order and no group.
+    belongs_to :order_group, class_name: 'Spree::OrderGroup', optional: true, inverse_of: :orders
+    # Whose sale this is. Nil on the operator's own goods, including the
+    # first-party child of a mixed marketplace checkout.
+    belongs_to :seller, class_name: 'Spree::Seller', optional: true
+    acted_by :created_by, :approver, :canceler
+    belongs_to :cancel_reason, class_name: 'Spree::OrderCancellationReason', optional: true, inverse_of: :orders
 
-    belongs_to :store, class_name: 'Spree::Store'
-    belongs_to :market, class_name: 'Spree::Market', optional: true
-    belongs_to :channel, class_name: 'Spree::Channel', optional: true
     belongs_to :preferred_stock_location, class_name: 'Spree::StockLocation', optional: true
 
     with_options dependent: :destroy do
-      has_many :state_changes, as: :stateful, class_name: 'Spree::StateChange'
       has_many :line_items, -> { order(:created_at) }, inverse_of: :order, class_name: 'Spree::LineItem'
       has_many :payments, class_name: 'Spree::Payment'
       has_many :payment_sessions, inverse_of: :order, class_name: 'Spree::PaymentSession'
-      has_many :return_authorizations, inverse_of: :order, class_name: 'Spree::ReturnAuthorization'
-      has_many :adjustments, -> { order(:created_at) }, as: :adjustable, class_name: 'Spree::Adjustment'
-      has_many :cancellations, -> { order(:created_at) }, inverse_of: :order, class_name: 'Spree::OrderCancellation'
-      has_many :approvals, -> { order(:created_at) }, inverse_of: :order, class_name: 'Spree::OrderApproval'
-    end
-    has_many :reimbursements, inverse_of: :order, class_name: 'Spree::Reimbursement'
-    has_many :customer_returns, class_name: 'Spree::CustomerReturn', through: :return_authorizations
-    has_many :line_item_adjustments, through: :line_items, source: :adjustments
-    has_many :inventory_units, inverse_of: :order, class_name: 'Spree::InventoryUnit'
+      has_many :returns, -> { order(:created_at) }, inverse_of: :order, class_name: 'Spree::Return'
+      has_many :exchanges, -> { order(:created_at) }, inverse_of: :order, class_name: 'Spree::Exchange'
+      has_many :claims, -> { order(:created_at) }, inverse_of: :order, class_name: 'Spree::Claim'
+    end
+    has_many :fulfillment_items, inverse_of: :order, class_name: 'Spree::FulfillmentItem'
+    has_many :inventory_units, class_name: 'Spree::FulfillmentItem', inverse_of: :order, deprecated: true
     has_many :stock_reservations, class_name: 'Spree::StockReservation', inverse_of: :order, dependent: :destroy
-    has_many :return_items, through: :inventory_units, class_name: 'Spree::ReturnItem'
+    has_many :return_line_items, through: :returns, class_name: 'Spree::ReturnLineItem', source: :return_line_items
     has_many :variants, through: :line_items
     has_many :products, through: :variants
-    has_many :refunds, through: :payments
-    has_many :all_adjustments,
-             class_name: 'Spree::Adjustment',
-             foreign_key: :order_id,
-             dependent: :destroy,
-             inverse_of: :order
+    # Every refund names the order it puts right — its own payments' refunds
+    # stamp it automatically, and a refund against a payment shared by a split
+    # checkout names the one child being refunded. Keyed on that column rather
+    # than walked through payments, which a grouped order does not own.
+    has_many :refunds, class_name: 'Spree::Refund', inverse_of: :order, dependent: :nullify
+
+    # Typed adjustment rows owned by this order (line-, fulfillment- and
+    # order-level). See docs/plans/6.0-6.1-split-adjustments.md.
+    has_many :tax_lines, class_name: 'Spree::TaxLine', dependent: :destroy, inverse_of: :order
+    # delete, not destroy: the snapshot is readonly once written, and destroy
+    # refuses readonly records. It has no dependents of its own.
+    has_one :tax_identifier, class_name: 'Spree::TaxIdentifier', as: :owner,
+                             dependent: :delete, inverse_of: :owner
+    has_many :discounts, class_name: 'Spree::Discount', dependent: :destroy, inverse_of: :order
+    has_many :fees, class_name: 'Spree::Fee', dependent: :destroy, inverse_of: :order
+
+    # What the marketplace charged its sellers on this order. Off-order by
+    # design: commission never reaches a total the customer pays, so this is a
+    # ledger the order merely hosts. See docs/plans/6.0-multi-vendor-marketplace.md.
+    has_many :commission_lines, class_name: 'Spree::CommissionLine', dependent: :destroy, inverse_of: :order
+
+    # This order's share of the payments made against its group. Empty on an
+    # ungrouped order, whose payments are its own (see #settlement_payments).
+    has_many :payment_splits, class_name: 'Spree::PaymentSplit', dependent: :destroy, inverse_of: :order
+
+    has_many :line_item_tax_lines, through: :line_items, source: :tax_lines
+    has_many :line_item_discounts, through: :line_items, source: :discounts
 
     has_many :order_promotions, class_name: 'Spree::OrderPromotion'
     has_many :promotions, through: :order_promotions, class_name: 'Spree::Promotion'
 
-    has_many :shipments, class_name: 'Spree::Shipment', dependent: :destroy, inverse_of: :order do
+    has_many :fulfillments, -> { order(:created_at, :id) }, class_name: 'Spree::Fulfillment', dependent: :destroy, inverse_of: :order do
       def states
-        pluck(:state).uniq
+        pluck(:status).uniq
       end
     end
-    has_many :shipment_adjustments, through: :shipments, source: :adjustments
+    has_many :fulfillment_tax_lines, through: :fulfillments, source: :tax_lines
+    has_many :fulfillment_discounts, through: :fulfillments, source: :discounts
 
     alias items line_items
-    alias discounts order_promotions
-    alias fulfillments shipments
-    alias_attribute :delivery_total, :shipment_total
-    alias display_delivery_total display_shipment_total
-    alias_attribute :fulfillment_status, :shipment_state
-    alias_attribute :payment_status, :payment_state
+    # Legacy names — removed in 6.1 (real names: fulfillments, delivery_total,
+    # fulfillment_status since 6.0)
+    has_many :shipments, class_name: 'Spree::Fulfillment', inverse_of: :order, deprecated: true
+    alias_attribute :shipment_total, :delivery_total
+    alias display_shipment_total display_delivery_total
+    alias_attribute :shipment_state, :fulfillment_status
+    # Deprecated alias — the column is payment_status since 6.0; remove in 6.1.
+    alias_attribute :payment_state, :payment_status
 
     delegate :has_markets?, to: :store, prefix: true
 
     accepts_nested_attributes_for :line_items
-    accepts_nested_attributes_for :bill_address
-    accepts_nested_attributes_for :ship_address
-    alias shipping_address_attributes= ship_address_attributes=
-    alias billing_address_attributes= bill_address_attributes=
     accepts_nested_attributes_for :payments, reject_if: :credit_card_nil_payment?
-    accepts_nested_attributes_for :shipments
-
-    # Needs to happen before save_permalink is called
-    before_validation :ensure_market_presence
-    before_validation :ensure_channel_presence
-    before_validation :ensure_currency_presence
-    before_validation :ensure_locale_presence
-    before_validation :resolve_market_from_currency, if: -> { persisted? && currency_changed? && !skip_market_resolution }
-
-    before_validation :clone_billing_address, if: :use_billing?
-    before_validation :clone_shipping_address, if: :use_shipping?
-    attr_accessor :use_billing, :use_shipping, :skip_market_resolution
+    accepts_nested_attributes_for :fulfillments
+    # @deprecated legacy writer — removed in 6.1
+    alias shipments_attributes= fulfillments_attributes=
 
     before_create :link_by_email
-    before_update :ensure_updated_shipments, :homogenize_line_item_currencies, if: :currency_changed?
-
-    with_options presence: true do
-      # we want to have this case_sentive: true as changing it to false causes all SQL to use LOWER(slug)
-      # which is very costly and slow on large set of records
-      validates :email, length: { maximum: 254, allow_blank: true }, email: { allow_blank: true }, if: :require_email
-      validates :item_count, numericality: { greater_than_or_equal_to: 0, less_than: 2**31, only_integer: true, allow_blank: true }
-      validates :store
-      validates :currency
-      validates :locale
-    end
-    validates :payment_state,        inclusion:    { in: PAYMENT_STATES, allow_blank: true }
-    validates :shipment_state,       inclusion:    { in: SHIPMENT_STATES, allow_blank: true }
-    validates :item_total,           POSITIVE_MONEY_VALIDATION
-    validates :adjustment_total,     MONEY_VALIDATION
-    validates :included_tax_total,   POSITIVE_MONEY_VALIDATION
-    validates :additional_tax_total, POSITIVE_MONEY_VALIDATION
-    validates :payment_total,        MONEY_VALIDATION
-    validates :shipment_total,       MONEY_VALIDATION
-    validates :promo_total,          NEGATIVE_MONEY_VALIDATION
-    validates :total,                MONEY_VALIDATION
-    validates :market, presence: true, if: :store_has_markets?
-    validate :currency_must_be_supported_by_store
-    validate :locale_must_be_supported_by_store
-
+    before_update :ensure_updated_fulfillments, :homogenize_line_item_currencies, if: :currency_changed?
+    # Record-state deletion eligibility is enforced here, not in ability rules —
+    # secret-key API requests never consult CanCanCan (Axis A/B split,
+    # docs/plans/decisions.md 2026-08-05).
+    before_destroy :ensure_can_be_deleted
+
+    # Shared money/quantity validations live in Spree::Purchase::Validations;
+    # only order-specific rules stay here.
+    validates :email, presence: true, length: { maximum: 254, allow_blank: true }, email: { allow_blank: true }, if: :require_email
+    validates :payment_status,     inclusion: { in: PAYMENT_STATUSES | PAYMENT_STATES, allow_blank: true }
+    validates :fulfillment_status, inclusion: { in: FULFILLMENT_STATUSES, allow_blank: true }
+
+    # @deprecated Both warn and run the full recalculation; use
+    #   {#recalculate_totals!}. Removed in 6.1.
     delegate :update_totals, :persist_totals, to: :updater
     delegate :merge!, to: :merger
-    delegate :firstname, :lastname, to: :bill_address, prefix: true, allow_nil: true
+    delegate :first_name, :last_name, to: :bill_address, prefix: true, allow_nil: true
+
+    # @deprecated The delegated names follow the renamed address columns since
+    #   6.0; removed in 6.1.
+    alias bill_address_firstname bill_address_first_name
+    alias bill_address_lastname bill_address_last_name
 
     class_attribute :update_hooks
     self.update_hooks = Set.new
@@ -271,12 +325,14 @@ module Spree
     scope :completed_between, ->(start_date, end_date) { where(completed_at: start_date..end_date) }
     scope :complete, -> { where.not(completed_at: nil) }
     scope :incomplete, -> { where(completed_at: nil) }
-    scope :canceled, -> { where(state: %w[canceled partially_canceled]) }
-    scope :not_canceled, -> { where.not(state: %w[canceled partially_canceled]) }
-    scope :ready_to_ship, -> { where(shipment_state: %w[ready pending]) }
-    scope :partially_shipped, -> { where(shipment_state: %w[partial]) }
-    scope :not_shipped, -> { where(shipment_state: %w[ready pending partial]) }
-    scope :shipped, -> { where(shipment_state: %w[shipped]) }
+    scope :canceled, -> { where(status: 'canceled') }
+    scope :not_canceled, -> { where.not(status: 'canceled') }
+    # Nil-tolerant channel filter for optional scoping (nil means all channels).
+    scope :for_channel, ->(channel) { channel ? where(channel_id: channel.id) : all }
+    scope :ready_to_ship, -> { where(fulfillment_status: %w[unfulfilled]) }
+    scope :partially_shipped, -> { where(fulfillment_status: %w[partial]) }
+    scope :not_shipped, -> { where(fulfillment_status: %w[unfulfilled partial]) }
+    scope :shipped, -> { where(fulfillment_status: %w[fulfilled delivered shipped]) }
     scope :refunded, lambda {
       joins(:refunds).group(:id).having("sum(#{Spree::Refund.table_name}.amount) = #{Spree::Order.table_name}.total")
     }
@@ -297,15 +353,18 @@ module Spree
 
       conditions = []
       conditions << arel_table[:number].lower.matches(query_pattern)
+      # An accountant holds one reference or the other — ours or their own
+      # purchase order — and both have to find the same transaction.
+      conditions << arel_table[:po_number].lower.matches(query_pattern)
 
-      conditions << search_condition(Spree::Address, :firstname, sanitized_query)
-      conditions << search_condition(Spree::Address, :lastname, sanitized_query)
+      conditions << search_condition(Spree::Address, :first_name, sanitized_query)
+      conditions << search_condition(Spree::Address, :last_name, sanitized_query)
 
       full_name = NameOfPerson::PersonName.full(sanitized_query)
 
       if full_name.first.present? && full_name.last.present?
-        conditions << search_condition(Spree::Address, :firstname, full_name.first)
-        conditions << search_condition(Spree::Address, :lastname, full_name.last)
+        conditions << search_condition(Spree::Address, :first_name, full_name.first)
+        conditions << search_condition(Spree::Address, :last_name, full_name.last)
       end
 
       left_joins(:bill_address).where(arel_table[:email].lower.eq(query.downcase)).or(where(conditions.reduce(:or)))
@@ -347,55 +406,42 @@ module Spree
     # Use this method in other gems that wish to register their own custom logic
     # that should be called after Order#update
     def self.register_update_hook(hook)
+      Spree::Deprecation.warn('Order.register_update_hook is deprecated and will be removed in Spree 6.1')
       update_hooks.add(hook)
     end
 
-    # For compatibility with Calculator::PriceSack
-    def amount
-      line_items.inject(0.0) { |sum, li| sum + li.amount }
-    end
-
-    # Sum of all line item amounts pre-tax
-    def pre_tax_item_amount
-      line_items.sum(:pre_tax_amount)
-    end
-
     # Sum of the eligible promotion adjustments applied to the order itself
-    # (whole-order discounts created by Promotion::Actions::CreateAdjustment),
-    # as opposed to promotions applied to individual line items or shipments.
-    # Zero or negative.
+    # (whole-order discounts created by Promotion::Actions::CreateAdjustment,
+    # distributed proportionally across line items), as opposed to promotions
+    # applied to individual line items or fulfillments. Zero or negative.
     #
     # @return [BigDecimal]
     def order_level_promo_total
-      adjustments.promotion.eligible.sum(:amount)
+      discounts.promotion.where(promotion_action_id: promotion_actions_of_scope(:order)).sum(:amount)
     end
 
-    # Sum of all line item and shipment pre-tax
-    def pre_tax_total
-      pre_tax_item_amount + shipments.sum(:pre_tax_amount)
+    # Promotion actions of the given discount scope, covering both the 6.0
+    # class names and the legacy STI names still present in the type column
+    # until the 6.1 data migration.
+    def promotion_actions_of_scope(scope)
+      Spree::PromotionAction.where(type: Spree::PromotionAction.types_for_discount_scope(scope))
     end
 
     # Returns the subtotal used for analytics integrations
     # It's a sum of the item total and the promo total
     # @return [Float]
     def analytics_subtotal
-      (item_total + line_items.sum(:promo_total)).to_f
+      (item_total + line_items.sum(:discount_total)).to_f
     end
 
+
+    # @deprecated Use {#fulfillment_discount}; removed in 6.1.
     def shipping_discount
-      shipment_adjustments.non_tax.eligible.sum(:amount) * - 1
+      Spree::Deprecation.warn('Spree::Order#shipping_discount is deprecated and will be removed in Spree 6.1. Use #fulfillment_discount instead.')
+      fulfillment_discount
     end
 
-    def completed?
-      completed_at.present?
-    end
 
-    # True when the order is mid-checkout: past the `cart` state but not yet
-    # completed or canceled. Used by stock reservation hooks and any flow
-    # that should only run during the active checkout phase.
-    def in_checkout?
-      !cart? && !complete? && !canceled?
-    end
 
     def draft?
       status == 'draft'
@@ -405,10 +451,26 @@ module Spree
       status == 'placed'
     end
 
+    def canceled?
+      status == 'canceled'
+    end
+
+    # @deprecated machine vocabulary — data-derived bridge for the 6.0
+    #   transition, removed in 6.1. An order is "cart-like" while a draft
+    #   with no checkout data.
+    def cart?
+      draft? && !completed? && email.blank? && ship_address_id.blank?
+    end
+
+    # Derived, not stored (Decision 8): some but not all fulfillments canceled.
+    def partially_canceled?
+      !canceled? && fulfillments.canceled.any? && fulfillments.not_canceled.any?
+    end
+
     # Checks if the order is fully refunded
     # @return [Boolean]
     def order_refunded?
-      return false if item_count.zero?
+      return false if total_quantity.zero?
       return false if refunds_total.zero?
 
       payment_state.in?(%w[void failed]) || refunds_total == total_minus_store_credits - additional_tax_total.abs
@@ -421,12 +483,107 @@ module Spree
     # Checks if the order is partially refunded
     # @return [Boolean]
     def partially_refunded?
-      return false if item_count.zero?
+      return false if total_quantity.zero?
       return false if payment_state.in?(%w[void failed]) || refunds.empty?
 
       refunds_total < total_minus_store_credits - additional_tax_total.abs
     end
 
+    # When the buyer's statutory right of withdrawal expires — the EU
+    # cooling-off period (Consumer Rights Directive 2011/83/EU Art. 9).
+    #
+    # Derived rather than stored, because the clock starts when the buyer takes
+    # physical possession: a value written at placement would be wrong the
+    # moment a parcel arrived.
+    #
+    # Nil until the last live parcel is delivered. Counting from completion
+    # instead would expire the deadline before the statutory period had even
+    # begun — the buyer would be told their right had run out while they were
+    # still waiting for the goods. A right whose start has not happened yet has
+    # no end date to report.
+    #
+    # @return [ActiveSupport::TimeWithZone, nil] nil when the market grants no
+    #   withdrawal right, the order is not complete, or delivery is outstanding
+    def withdrawal_period_ends_at
+      return nil unless withdrawal_right_applies?
+
+      started_at = withdrawal_period_starts_at
+      return nil if started_at.nil?
+
+      started_at + withdrawal_period_days.days
+    end
+
+    # Whether the buyer may still withdraw.
+    #
+    # True while delivery is outstanding: the right cannot have lapsed before
+    # it started, so an order still in transit is always within its period even
+    # though no deadline can be named yet.
+    #
+    # A canceled order is not: withdrawal is how a buyer ends a contract that
+    # is still standing, and cancellation has already ended this one. Without
+    # the guard, cancellation empties the live fulfillments, no start date can
+    # be found, and the open-ended reading above would keep the order reporting
+    # itself as withdrawable forever.
+    #
+    # @return [Boolean]
+    def within_withdrawal_period?
+      return false unless withdrawal_right_applies?
+
+      deadline = withdrawal_period_ends_at
+      # No deadline yet means nothing has been delivered, so the clock that
+      # would end the right has not started.
+      deadline.nil? || deadline.future?
+    end
+
+    # Whether a statutory right to withdraw exists on this order at all. A
+    # cancelled order has already ended the contract the right would end, and
+    # a market that sets no period grants none. Stated once because both
+    # readers above need the same answer.
+    def withdrawal_right_applies?
+      completed? && !canceled? && withdrawal_period_days.present?
+    end
+
+    # The moment the cooling-off period starts: receipt of the goods. The
+    # Consumer Rights Directive treats an order delivered in instalments as
+    # received when the LAST one arrives, so a partly-delivered order has not
+    # started its clock at all — reading the max over the delivered subset
+    # would start it at the first parcel and could expire the right while the
+    # buyer is still waiting for the rest.
+    #
+    # @return [ActiveSupport::TimeWithZone, nil] nil until every parcel that is
+    #   still live has been delivered
+    def withdrawal_period_starts_at
+      live = fulfillments.reject(&:canceled?)
+      return nil if live.empty?
+
+      received = live.map { |fulfillment| withdrawal_receipt_of(fulfillment) }
+      return nil if received.any?(&:blank?)
+
+      received.max
+    end
+
+    # When one fulfillment counts as received.
+    #
+    # Digital content has no delivery event and no carrier to report one, so
+    # waiting for `delivered_at` would leave a mixed order's clock stopped
+    # forever — the physical parcel arrives and the deadline never appears.
+    # The Directive treats digital content differently from goods anyway
+    # (Art. 16(m)); handing it over is the moment it reaches the buyer.
+    #
+    # @param fulfillment [Spree::Fulfillment]
+    # @return [ActiveSupport::TimeWithZone, nil]
+    def withdrawal_receipt_of(fulfillment)
+      return fulfillment.delivered_at || fulfillment.fulfilled_at if fulfillment.digital?
+
+      fulfillment.delivered_at
+    end
+
+    # @return [Integer, nil] nil where no market says otherwise — a statutory
+    #   notice is not something to assume on an order with no region attached
+    def withdrawal_period_days
+      market&.preferred_withdrawal_period_days
+    end
+
     # Indicates whether or not the user is allowed to proceed to checkout.
     # Currently this is implemented as a check for whether or not there is at
     # least one LineItem in the Order.  Feel free to override this logic in your
@@ -435,33 +592,11 @@ module Spree
       line_items.exists?
     end
 
-    # Does this order require a delivery (physical or digital).
-    def delivery_required?
-      true # true for Spree, can be decorated
-    end
-
-    # Is this a free order in which case the payment step should be skipped
-    def payment_required?
-      total.to_f > 0.0
-    end
-
-    # If true, causes the confirmation step to happen during the checkout process
-    def confirmation_required?
-      Spree::Config[:always_include_confirm_step] ||
-        payments.valid.map(&:payment_method).compact.any?(&:confirmation_required?) ||
-        # Little hacky fix for #4117
-        # If this wasn't here, order would transition to address state on confirm failure
-        # because there would be no valid payments any more.
-        confirm?
-    end
 
     def email_required?
       require_email
     end
 
-    def backordered?
-      shipments.any?(&:backordered?)
-    end
 
     # Check if the shipping address is a quick checkout address
     # quick checkout addresses are incomplete as wallet providers like Apple Pay and Google Pay
@@ -475,141 +610,188 @@ module Spree
     # Either fully digital or not digital at all
     # @return [Boolean]
     def quick_checkout_available?
-      payment_required? && shipments.count <= 1 && (digital? || !some_digital? || !delivery_required?)
+      payment_required? && fulfillments.count <= 1 && (digital? || !some_digital? || !delivery_step_required?)
     end
 
     # Check if quick checkout requires an address collection
-    # If the order is digital or not delivery required, then we don't need to collect an address
     # @return [Boolean]
     def quick_checkout_require_address?
-      !digital? && delivery_required?
+      shipping_address_required?
     end
 
-    # Returns the relevant zone (if any) to be used for taxation purposes.
-    # Uses default tax zone unless there is a specific match
-    def tax_zone
-      @tax_zone ||= Zone.match(tax_address) || Zone.default_tax
+    # @deprecated Use {#recalculate_totals!} for money and {#update_statuses!}
+    #   for payment/fulfillment statuses; removed in 6.1.
+    def updater
+      @updater ||= Spree.order_updater.new(self)
     end
 
-    # Returns the address for taxation based on configuration
-    def tax_address
-      Spree::Config[:tax_using_ship_address] ? ship_address : bill_address
+    # Recomputes and persists money totals (item, tax, promotion, delivery)
+    # and derived item counts. Convenience for
+    # {Spree::Orders::RecalculateTotals}.
+    def recalculate_totals!
+      Spree.order_recalculate_totals_workflow.call(order: self)
     end
 
-    def updater
-      @updater ||= Spree.order_updater.new(self)
+    # Derives and persists payment_status / fulfillment_status from the
+    # order's payment, refund and fulfillment records. Convenience for
+    # {Spree::Orders::UpdateStatuses}, the sole status writer.
+    def update_statuses!
+      Spree.order_update_statuses_service.call(order: self)
     end
 
+    # @deprecated Use {#recalculate_totals!}; removed in 6.1.
     def update_with_updater!
-      updater.update
+      Spree::Deprecation.warn('Spree::Order#update_with_updater! is deprecated and will be removed in Spree 6.1. Use #recalculate_totals! instead.')
+      recalculate_totals!
     end
 
+    # @deprecated Use {Spree::Carts::Merge}; removed in 6.1.
     def merger
       @merger ||= Spree::OrderMerger.new(self)
     end
 
-    def ensure_store_presence
-      Spree::Deprecation.warn('Spree::Order#ensure_store_presence is deprecated and will be removed in Spree 6.0. ensure_store instead.')
-      ensure_store
-    end
-
-    def ensure_market_presence
-      self.market ||= Spree::Current.market || store&.default_market
-    end
-
-    def ensure_channel_presence
-      return if channel_id.present?
-
-      self.channel = store&.default_channel
-    end
-
-    # @return [Boolean] true when this order has no registered user and its
-    #   channel forbids guest checkout (see Spree::Channel::Gating). Enforced by
-    #   the checkout completion service and the v3 Store API so every completion
-    #   path (controller, payment webhook) is covered.
-    #
-    #   A +prices_hidden+ channel also disallows guest completion regardless of
-    #   the +guest_checkout+ flag — prices are withheld from guests, and a buyer
-    #   who cannot see prices cannot meaningfully place an order. This dissolves
-    #   the otherwise contradictory "prices hidden but guests may buy" config.
-    def guest_checkout_disallowed?
-      return false if user_id.present?
-      return false if channel.blank?
-      return true if channel.storefront_prices_hidden?
-
-      !channel.resolved_guest_checkout
-    end
 
     def allow_cancel?
       return false if !completed? || canceled?
 
-      shipment_state.nil? || %w{ready backorder pending canceled}.include?(shipment_state)
+      fulfillment_status.nil? || %w{unfulfilled backorder canceled}.include?(fulfillment_status)
     end
+    alias can_cancel? allow_cancel?
 
     def all_inventory_units_returned?
       inventory_units.all?(&:returned?)
     end
 
     # Associates the specified user with the order.
-    # Delegates to {Spree::Cart::Associate} service.
+    # Delegates to {Spree::Carts::Associate} service.
     #
-    # @param user [Spree.user_class] the user to associate with the order
-    # @param override_email [Boolean] whether to override the order email with the user's email
+    # @param customer [Spree.customer_class] the customer to associate with the order
+    # @param override_email [Boolean] whether to override the order email with the customer's email
     # @return [Spree::ServiceModule::Result]
+    def associate_customer!(customer, override_email = true)
+      Spree.cart_associate_service.call(guest_cart: self, customer: customer, override_email: override_email)
+    end
+
+    # @deprecated Use {#associate_customer!}; removed in 6.1.
     def associate_user!(user, override_email = true)
-      Spree.cart_associate_service.call(guest_order: self, user: user, override_email: override_email)
+      Spree::Deprecation.warn('Spree::Order#associate_user! is deprecated and will be removed in Spree 6.1. Use #associate_customer! instead.')
+      associate_customer!(user, override_email)
     end
 
-    def disassociate_user!
-      nullified_attributes = ASSOCIATED_USER_ATTRIBUTES.index_with(nil)
+    def disassociate_customer!
+      nullified_attributes = ASSOCIATED_CUSTOMER_ATTRIBUTES.index_with(nil)
 
       update!(nullified_attributes)
     end
 
-    def quantity_of(variant, options = {})
-      line_item = find_line_item_by_variant(variant, options)
-      line_item ? line_item.quantity : 0
-    end
-
-    def find_line_item_by_variant(variant, options = {})
-      line_items.detect do |line_item|
-        line_item.variant_id == variant.id &&
-          Spree.cart_compare_line_items_service.new.call(order: self, line_item: line_item, options: options).value
-      end
+    # @deprecated Use {#disassociate_customer!}; removed in 6.1.
+    def disassociate_user!
+      Spree::Deprecation.warn('Spree::Order#disassociate_user! is deprecated and will be removed in Spree 6.1. Use #disassociate_customer! instead.')
+      disassociate_customer!
     end
 
-    # Creates new tax charges if there are any applicable rates. If prices already
-    # include taxes then price adjustments are created instead.
+    # Re-estimates tax through the configured provider (writes TaxLine rows
+    # with replace-all semantics).
     def create_tax_charge!
-      Spree::TaxRate.adjust(self, line_items)
-      Spree::TaxRate.adjust(self, shipments) if shipments.any?
+      tax_provider.estimate(self, **tax_estimate_inputs)
     end
 
     def create_shipment_tax_charge!
-      Spree::TaxRate.adjust(self, shipments) if shipments.any?
+      tax_provider.estimate(self, fulfillments.to_a, **tax_estimate_inputs) if fulfillments.any?
     end
 
+    # Re-prices every line from the catalog.
+    #
+    # A completed order's money is frozen — re-pricing would rewrite what the
+    # customer was actually charged — so this refuses rather than reporting a
+    # success it did not deliver. Post-placement price changes belong to the
+    # order-change substrate (docs/plans/6.1-order-change-substrate.md).
+    #
+    # @raise [RuntimeError] when the order is already completed
+    # @return [void]
     def update_line_item_prices!
+      raise 'cannot re-price a completed order' if completed?
+
       transaction do
         line_items.reload.each(&:update_price)
         save!
       end
     end
 
+    # Refunds are already netted out of payment_total by
+    # Spree::Carts::RecalculateTotals, so returns and claims need no separate
+    # term here — the legacy reimbursement payout was the only one that sat
+    # outside that sum.
     def outstanding_balance
       if canceled?
         -1 * payment_total
       else
-        total - (payment_total + reimbursement_paid_total)
+        total - payment_total
       end
     end
 
-    def reimbursement_paid_total
-      reimbursements.sum(&:paid_amount)
+
+    # The payments that settle this order.
+    #
+    # An order placed in a split checkout has none of its own: the customer
+    # made one payment for the whole basket, against the group. Anything asking
+    # what money exists for this order — capture on dispatch, refunds, the
+    # admin payments panel — reads it here, and reads its own share of it from
+    # {#payment_splits}.
+    #
+    # @return [ActiveRecord::Relation<Spree::Payment>]
+    def settlement_payments
+      order_group_id.present? ? order_group.payments : payments
+    end
+
+    # What has been captured against this order, net of refunds.
+    #
+    # An order placed in a split checkout owns no payments, so its own
+    # +payment_total+ stays at zero however much the customer paid — the
+    # figure comes from its share of the group's payments instead, the same
+    # way {Spree::Orders::UpdateStatuses} derives +payment_status+. The
+    # group's own total will not do: once one seller has been captured and
+    # another has not, no proportion of it describes either.
+    #
+    # @return [BigDecimal]
+    def net_captured_total
+      return payment_total unless grouped?
+
+      payment_splits.sum(&:net_captured_amount)
     end
 
-    def outstanding_balance?
-      outstanding_balance != 0
+    # Payments still to be collected for this order, wherever they live.
+    #
+    # @return [ActiveRecord::Relation<Spree::Payment>, Array<Spree::Payment>]
+    def settlement_pending_payments
+      grouped? ? settlement_payments.pending : pending_payments
+    end
+
+    # @return [Boolean] whether this order was placed alongside others in one
+    #   checkout, and therefore shares their payment
+    def grouped?
+      order_group_id.present?
+    end
+
+    # This order and any placed alongside it in the same checkout.
+    #
+    # The set anything counting *checkouts* rather than orders works from — a
+    # promotion's usage limit, for one, which must not be spent several times
+    # over because a basket happened to span several sellers.
+    #
+    # @return [Array<Integer>]
+    def sibling_order_ids
+      return [id] unless grouped?
+
+      order_group.orders.ids
+    end
+
+    # This order's share of one payment made against its group.
+    #
+    # @param payment [Spree::Payment]
+    # @return [Spree::PaymentSplit, nil]
+    def payment_split_for(payment)
+      payment_splits.find_by(payment_id: payment.id)
     end
 
     def name
@@ -619,8 +801,8 @@ module Spree
     end
 
     def full_name
-      @full_name ||= if user.present? && user.name.present?
-                       user.full_name
+      @full_name ||= if customer.present? && customer.name.present?
+                       customer.full_name
                      else
                        billing_address&.full_name || email
                      end
@@ -646,62 +828,38 @@ module Spree
     def backordered_variants
       variants.
         where(track_inventory: true).
-        joins(:stock_items, :product).
-        where(Spree::StockItem.table_name => { count_on_hand: ..0, backorderable: true })
+        joins(:stock_levels, :product).
+        where(Spree::StockLevel.table_name => { backorderable: true }).
+        where("#{Spree::StockLevel.table_name}.count_on_hand - #{Spree::StockLevel.table_name}.allocated_count <= ?", 0)
     end
 
     def can_ship?
-      complete? || resumed? || awaiting_return? || returned?
+      placed?
     end
 
     def uneditable?
-      complete? || canceled? || returned?
+      completed? || canceled?
     end
 
     # Finalizes an in progress order after checkout is complete.
     # Called after transition to complete state when payments will have been processed
+    # @deprecated Completion lives in {Spree::Orders::Complete} (checkout
+    #   reaches it through +Spree.carts_complete_workflow+). Removed in 6.1.
     def finalize!
-      # lock all adjustments (coupon promotions, etc.)
-      all_adjustments.each(&:close)
-
-      # update payment and shipment(s) states, and save
-      updater.update_payment_state
-      shipments.each do |shipment|
-        shipment.update!(self)
-        shipment.finalize!
-      end
-
-      updater.update_shipment_state
-      self.status = 'placed'
-      save!
-      updater.run_hooks
-
-      touch :completed_at
-
-      send_order_placed_webhook
-
-      consider_risk
-
-      publish_order_completed_event
+      Spree::Deprecation.warn('Spree::Order#finalize! is deprecated and will be removed in Spree 6.1. Completion runs through Spree.order_complete_workflow (Spree::Orders::Complete).')
+      Spree.order_complete_workflow.call(order: self, payment_pending: true)
     end
 
     def fulfill!
-      shipments.each { |shipment| shipment.update!(self) if shipment.persisted? }
-      updater.update_shipment_state
+      fulfillments.each { |shipment| shipment.update!(self) if shipment.persisted? }
       save!
+      update_statuses!
     end
 
-    # Helper methods for checkout steps
-    def paid?
-      payments.valid.completed.size == payments.valid.size && payments.valid.sum(:amount) >= total
-    end
 
-    def payment_methods
-      @payment_methods ||= store.payment_methods.active.available_on_front_end.select { |pm| pm.available_for_order?(self) }
-    end
 
     def available_payment_methods(store = nil)
-      Spree::Deprecation.warn('`Order#available_payment_methods` is deprecated and will be removed in Spree 5.5. Use `collect_frontend_payment_methods` instead.')
+      Spree::Deprecation.warn('`Order#available_payment_methods` is deprecated and will be removed in Spree 6.1. Use `payment_methods` instead.')
 
       @available_payment_methods ||= collect_payment_methods(store)
     end
@@ -713,99 +871,111 @@ module Spree
     ##
     # Check to see if any line item variants are discontinued.
     # If so add error and restart checkout.
+    # @deprecated Completion validation lives in
+    #   {Spree::Checkout::DefaultRequirements} (the +discontinued+ stock
+    #   error). Removed in 6.1.
     def ensure_line_item_variants_are_not_discontinued
+      Spree::Deprecation.warn('Spree::Order#ensure_line_item_variants_are_not_discontinued is deprecated and will be removed in Spree 6.1. Completion validation lives in Spree::Checkout::Requirements.')
       if line_items.any? { |li| !li.variant || li.variant.discontinued? }
-        restart_checkout_flow
-        errors.add(:base, Spree.t(:discontinued_variants_present))
+        errors.add(:base, :discontinued_variants_present, message: Spree.t(:discontinued_variants_present))
         false
       else
         true
       end
     end
 
+    # @deprecated Completion validation lives in
+    #   {Spree::Checkout::DefaultRequirements} (the +out_of_stock+ stock
+    #   error). Removed in 6.1.
     def ensure_line_items_are_in_stock
+      Spree::Deprecation.warn('Spree::Order#ensure_line_items_are_in_stock is deprecated and will be removed in Spree 6.1. Completion validation lives in Spree::Checkout::Requirements.')
       if insufficient_stock_lines.present?
-        restart_checkout_flow
-        errors.add(:base, Spree.t(:insufficient_stock_lines_present))
+        errors.add(:base, :insufficient_stock_lines_present, message: Spree.t(:insufficient_stock_lines_present))
         false
       else
         true
       end
     end
 
-    def empty!
-      raise Spree.t(:cannot_empty_completed_order) if completed?
-
-      result = Spree.cart_empty_service.call(order: self)
-      result.value
-    end
-
     def use_all_coupon_codes
+      Spree::Deprecation.warn('Spree::Order#use_all_coupon_codes is deprecated and will be removed in Spree 6.1. Use Spree::CouponCodes::CouponCodesHandler instead.')
       Spree::CouponCodes::CouponCodesHandler.new(order: self).use_all_codes
     end
 
-    def has_step?(step)
-      checkout_steps.include?(step)
-    end
+    normalizes :coupon_code, with: ->(code) { code.to_s.strip.downcase.presence }
 
-    def state_changed(name)
-      state = "#{name}_state"
-      if persisted?
-        old_state = send("#{state}_was")
-        new_state = send(state)
-        unless old_state == new_state
-          log_state_changes(state_name: name, old_state: old_state, new_state: new_state)
-        end
-      end
-    end
-
-    def log_state_changes(state_name:, old_state:, new_state:)
-      state_changes.create(
-        previous_state: old_state,
-        next_state: new_state,
-        name: state_name,
-        user_id: user_id
-      )
+    def can_add_coupon?
+      Spree::Deprecation.warn('Spree::Order#can_add_coupon? is deprecated and will be removed in Spree 6.1. Use Spree::Promotion.order_activatable? instead.')
+      Spree::Promotion.order_activatable?(self)
     end
 
-    def coupon_code=(code)
-      @coupon_code = begin
-        code.strip.downcase
-      rescue StandardError
-        nil
-      end
+    def shipped?
+      %w(partial shipped fulfilled delivered).include?(fulfillment_status)
     end
 
-    def can_add_coupon?
-      Spree::Promotion.order_activatable?(self)
+    # True when every fulfillment has left the merchant's hands — the signal
+    # order.fulfilled publishes on. `delivered` counts: it is downstream of
+    # fulfilled, so a delivered order must not read as un-fulfilled.
+    def fully_fulfilled?
+      fulfillments.fulfilled_or_delivered.size == fulfillments.size
     end
 
-    def shipped?
-      %w(partial shipped).include?(shipment_state)
+    # True when every fulfillment reached confirmed receipt — the signal
+    # order.delivered publishes on.
+    def fully_delivered?
+      total = fulfillments.size
+      total.positive? && fulfillments.delivered.size == total
     end
 
+    # @deprecated Use {#fully_fulfilled?}; removed in 6.1.
     def fully_shipped?
-      shipments.shipped.size == shipments.size
+      Spree::Deprecation.warn('Spree::Order#fully_shipped? is deprecated and will be removed in Spree 6.1. Use #fully_fulfilled? instead.')
+      fully_fulfilled?
     end
 
-    def create_proposed_shipments
-      all_adjustments.shipping.delete_all
+    def rebuild_fulfillments!
+      discounts.for_fulfillments.delete_all
+      tax_lines.for_fulfillments.delete_all
+      fees.for_fulfillments.delete_all
 
-      shipment_ids = shipments.map(&:id)
-      StateChange.where(stateful_type: 'Spree::Shipment', stateful_id: shipment_ids).delete_all
-      ShippingRate.where(shipment_id: shipment_ids).delete_all
+      shipment_ids = fulfillments.map(&:id)
+      DeliveryRate.where(fulfillment_id: shipment_ids).delete_all
 
-      shipments.delete_all
+      fulfillments.delete_all
 
       # Inventory Units which are not associated to any shipment (unshippable)
       # and are not returned or shipped should be deleted
-      inventory_units.on_hand_or_backordered.delete_all
+      fulfillment_items.on_hand_or_backordered.delete_all
 
-      self.shipments = order_routing_strategy.for_allocation.map do |package|
-        package.to_shipment.tap { |s| s.address_id = ship_address_id }
+      self.fulfillments = order_routing_strategy.for_allocation.map do |package|
+        package.to_fulfillment.tap { |fulfillment| fulfillment.address_id = ship_address_id }
       end
     end
 
+    # @deprecated Use {#rebuild_fulfillments!}; removed in 6.1.
+    def create_proposed_fulfillments
+      Spree::Deprecation.warn('Spree::Order#create_proposed_fulfillments is deprecated and will be removed in Spree 6.1. Use #rebuild_fulfillments! instead.')
+      rebuild_fulfillments!
+    end
+
+    # @deprecated Use {#rebuild_fulfillments!}; removed in 6.1.
+    def create_proposed_shipments
+      Spree::Deprecation.warn('Spree::Order#create_proposed_shipments is deprecated and will be removed in Spree 6.1. Use #rebuild_fulfillments! instead.')
+      rebuild_fulfillments!
+    end
+
+    # @deprecated Use {#delivery_step_required?}; removed in 6.1.
+    def delivery_required?
+      Spree::Deprecation.warn('Spree::Order#delivery_required? is deprecated and will be removed in Spree 6.1. Use #delivery_step_required? (delivery-step applicability) or #shipping_address_required? (address collection) instead.')
+      delivery_step_required?
+    end
+
+    # @deprecated Use {#shipping_address_required?}; removed in 6.1.
+    def requires_ship_address?
+      Spree::Deprecation.warn('Spree::Order#requires_ship_address? is deprecated and will be removed in Spree 6.1. Use #shipping_address_required? instead.')
+      shipping_address_required?
+    end
+
     # Resolves the routing strategy from the channel override first, then the
     # store default. Only a registered Spree::OrderRouting::Strategy::Base
     # subclass is used; any other value (an unregistered/typo'd class, or a
@@ -839,27 +1009,35 @@ module Spree
       @total_weight ||= line_items.joins(:variant).includes(:variant).map(&:item_weight).sum
     end
 
-    # Returns line items that have no shipping rates
+    # Returns line items that have no delivery rates
+    #
+    # Deliberately not memoized: callers destroy fulfillments between reads
+    # (see {#ensure_available_delivery_rates}), so a cached value would
+    # describe fulfillments that no longer exist.
     #
     # @return [Array<Spree::LineItem>]
-    def line_items_without_shipping_rates
-      @line_items_without_shipping_rates ||= shipments.map do |shipment|
-        shipment.manifest.map(&:line_item) if shipment.shipping_rates.blank?
+    def line_items_without_delivery_rates
+      fulfillments.map do |fulfillment|
+        fulfillment.manifest.map(&:line_item) if fulfillment.delivery_rates.blank?
       end.flatten.compact
     end
 
+    # @deprecated Use {#line_items_without_delivery_rates}; removed in 6.1.
+    def line_items_without_shipping_rates
+      Spree::Deprecation.warn('Spree::Order#line_items_without_shipping_rates is deprecated and will be removed in Spree 6.1. Use #line_items_without_delivery_rates instead.')
+      line_items_without_delivery_rates
+    end
+
     # Checks if all line items cannot be shipped
     #
     # @returns Boolean
     def all_line_items_invalid?
-      line_items_without_shipping_rates.size == line_items.count
+      line_items_without_delivery_rates.size == line_items.count
     end
 
     def apply_free_shipping_promotions
       Spree::PromotionHandler::FreeShipping.new(self).activate
-      shipments.each { |shipment| Spree::Adjustable::AdjustmentsUpdater.update(shipment) }
-      create_shipment_tax_charge!
-      update_with_updater!
+      recalculate_totals!
     end
 
     # Applies user promotions when login after filling the cart
@@ -867,55 +1045,61 @@ module Spree
       ::Spree::PromotionHandler::Cart.new(self).activate
     end
 
-    # Clean shipments and make order back to address state
-    #
-    # At some point the might need to force the order to transition from address
-    # to delivery again so that proper updated shipments are created.
-    # e.g. customer goes back from payment step and changes order items
-    def ensure_updated_shipments
-      if shipments.any? && !completed?
-        shipments.destroy_all
-        update_column(:shipment_total, 0)
+    # Drops stale fulfillments so they are rebuilt from current items.
+    def ensure_updated_fulfillments
+      if fulfillments.any? && !completed?
+        fulfillments.destroy_all
+        update_column(:delivery_total, 0)
 
         # Manually publish update event since update_column bypasses callbacks
         publish_event('order.updated')
-
-        restart_checkout_flow
       end
     end
 
-    def restart_checkout_flow
-      update_columns(
-        state: 'cart',
-        updated_at: Time.current
-      )
-
-      # Manually publish update event since update_columns bypasses callbacks
-      publish_event('order.updated')
-
-      next! unless line_items.empty?
+    # @deprecated Use {#ensure_updated_fulfillments}; removed in 6.1.
+    def ensure_updated_shipments
+      Spree::Deprecation.warn('Spree::Order#ensure_updated_fulfillments is deprecated and will be removed in Spree 6.1. Use #ensure_updated_fulfillments instead.')
+      ensure_updated_fulfillments
     end
 
-    def refresh_shipment_rates(shipping_method_filter = ShippingMethod::DISPLAY_ON_FRONT_END)
-      shipments.map { |s| s.refresh_rates(shipping_method_filter) }
+    # Re-quotes every fulfillment for the given audience.
+    #
+    # @param audience [Symbol] {Spree::DeliveryMethod::STOREFRONT} (default)
+    #   or {Spree::DeliveryMethod::BACKOFFICE}
+    # @return [Array<Array<Spree::DeliveryRate>>]
+    def refresh_delivery_rates(audience = DeliveryMethod::STOREFRONT)
+      fulfillments.map { |fulfillment| fulfillment.refresh_rates(audience) }
     end
 
-    def shipping_eq_billing_address?
-      bill_address == ship_address
+    # @deprecated Use {#refresh_delivery_rates}; removed in 6.1.
+    def refresh_shipment_rates(audience = DeliveryMethod::STOREFRONT)
+      Spree::Deprecation.warn('Spree::Order#refresh_shipment_rates is deprecated and will be removed in Spree 6.1. Use #refresh_delivery_rates instead.')
+      refresh_delivery_rates(audience)
     end
 
     def set_shipments_cost
-      shipments.each(&:update_amounts)
-      updater.update_shipment_total
-      updater.update_adjustment_total
-      persist_totals
+      Spree::Deprecation.warn('Spree::Order#set_shipments_cost is deprecated and will be removed in Spree 6.1l. Please use set_fulfillments_cost instead')
+      set_fulfillments_cost
+    end
+
+    def set_fulfillments_cost
+      fulfillments.each(&:update_amounts)
+      recalculate_totals!
     end
 
     def shipping_method
-      # This query will select the first available shipping method from the shipments.
-      # It will use subquery to first select the shipping method id from the shipments' selected_shipping_rate.
-      Spree::ShippingMethod.
-        where(id: shipments.with_selected_shipping_method.limit(1).pluck(:shipping_method_id)).
+      Spree::Deprecation.warn('Spree::Order#shipping_method is deprecated and will be removed in Spree 6.1. Please use Spree::Order#delivery_method')
+      delivery_method
+    end
+
+    # Returns first available delivery method from the fulfillments
+    # Useful for analytics and CSV exports
+    # @return [Spree::DeliveryMethod]
+    def delivery_method
+      # This query will select the first available delivery method from the fulfillments.
+      # It will use subquery to first select the delivery method id from the fulfillments' selected_delivery_rate.
+      Spree::DeliveryMethod.
+        where(id: fulfillments.with_selected_delivery_method.limit(1).pluck(:delivery_method_id)).
         limit(1).
         first
     end
@@ -925,22 +1109,38 @@ module Spree
     end
 
     # Cancels the order and records the canceler.
-    # Delegates to {Spree::Orders::Cancel} service.
+    # Delegates to {Spree::Orders::Cancel} workflow.
     #
-    # @param user [Spree.user_class, nil] the user who canceled the order
+    # @deprecated Call {Spree.order_cancel_workflow} directly — it exposes the
+    #   full cancellation vocabulary (reason, note, refund_payments,
+    #   notify_customer) this wrapper cannot pass through.
+    # @param user [Spree.customer_class, nil] the user who canceled the order
     # @param canceled_at [Time, nil] the time of cancellation (defaults to current time)
     # @return [Spree::ServiceModule::Result]
     def canceled_by(user, canceled_at = nil)
-      Spree.order_cancel_service.call(order: self, canceler: user, canceled_at: canceled_at)
+      Spree::Deprecation.warn('Spree::Order#canceled_by is deprecated and will be removed in Spree 6.1. Use Spree.order_cancel_workflow (Spree::Orders::Cancel) instead.')
+      Spree.order_cancel_workflow.call(order: self, canceler: user, canceled_at: canceled_at)
+    end
+
+    # Machine-free lifecycle: cancellation runs through the
+    # {Spree::Orders::Cancel} workflow. There is no way back — a canceled
+    # order stays canceled, as it does on every comparable platform.
+    def cancel
+      Spree.order_cancel_workflow.call(order: self).success?
+    end
+
+    def cancel!
+      cancel || raise(ActiveRecord::RecordInvalid.new(self))
     end
 
     # Approves the order and records the approver.
     # Delegates to {Spree::Orders::Approve} service.
     #
-    # @param user [Spree.user_class, nil] the user who approved the order
+    # @param actor [Object, nil] who approved it — an admin user or an API
+    #   key (see Spree.actor_classes)
     # @return [Spree::ServiceModule::Result]
-    def approved_by(user = nil)
-      Spree.order_approve_service.call(order: self, approver: user)
+    def approved_by(actor = nil)
+      Spree.order_approve_service.call(order: self, approver: actor)
     end
 
     def approved?
@@ -951,14 +1151,6 @@ module Spree
       !approved?
     end
 
-    def can_be_destroyed?
-      Spree::Deprecation.warn('Spree::Order#can_be_destroyed? is deprecated and will be removed in the next major version. Use Spree::Order#can_be_deleted? instead.')
-      can_be_deleted?
-    end
-
-    def can_be_deleted?
-      !completed? && payments.completed.empty?
-    end
 
     def consider_risk
       considered_risky! if is_risky? && !approved?
@@ -979,26 +1171,10 @@ module Spree
       Spree.order_approve_service.call(order: self)
     end
 
-    def tax_total
-      included_tax_total + additional_tax_total
-    end
-
-    def quantity
-      line_items.sum(:quantity)
-    end
-
-    def has_non_reimbursement_related_refunds?
-      refunds.non_reimbursement.exists? ||
-        payments.offset_payment.exists? # how old versions of spree stored refunds
-    end
-
     def collect_backend_payment_methods
-      store.payment_methods.active.available_on_back_end.select { |pm| pm.available_for_order?(self) }
+      store.payment_methods.active.select { |pm| pm.available_for_order?(self) }
     end
 
-    def collect_frontend_payment_methods
-      store.payment_methods.active.available_on_front_end.select { |pm| pm.available_for_order?(self) }
-    end
 
     # determines whether the inventory is fully discounted
     #
@@ -1023,9 +1199,7 @@ module Spree
     # Returns the IDs of the valid promotions for the order
     # @return [Array<Integer>]
     def valid_promotion_ids
-      all_adjustments.eligible.nonzero.promotion.promotion.eligible.nonzero.promotion.
-        joins("INNER JOIN #{Spree::PromotionAction.table_name} ON #{Spree::PromotionAction.table_name}.id = #{Spree::Adjustment.table_name}.source_id").
-        pluck("#{Spree::PromotionAction.table_name}.promotion_id").compact.uniq
+      discounts.promotion.nonzero.where.not(promotion_id: nil).distinct.pluck(:promotion_id)
     end
 
     # Returns the valid coupon promotions for the order
@@ -1037,43 +1211,50 @@ module Spree
     end
 
     # Returns item and whole order discount amount for Order
-    # without Shipment discounts (eg. Free Shipping)
+    # without fulfillment discounts (eg. Free Shipping)
     # @return [BigDecimal]
     def cart_promo_total
-      all_adjustments.eligible.nonzero.promotion.
-        where.not(adjustable_type: 'Spree::Shipment').
-        sum(:amount)
+      Spree::Deprecation.warn('Spree::Order#cart_promo_total is deprecated and will be removed in Spree 6.1. Please use order.cart.discount_total instead')
+      discounts.promotion.nonzero.for_line_items.sum(:amount)
     end
 
     def has_free_shipping?
-      shipment_adjustments.
-        joins(:promotion_action).
-        where(spree_adjustments: { eligible: true, source_type: 'Spree::PromotionAction' },
-              spree_promotion_actions: { type: 'Spree::Promotion::Actions::FreeShipping' }).exists?
+      discounts.promotion.for_fulfillments.exists?
     end
 
-    def to_csv(_store = nil)
-      metafields_for_csv ||= Spree::MetafieldDefinition.for_resource_type('Spree::Order').order(:namespace, :key).map do |mf_def|
-        metafields.find { |mf| mf.metafield_definition_id == mf_def.id }&.csv_value
-      end
+    # @param omit_headers [Array<String>] columns to leave out, named by their
+    #   header. A seller's export drops the buyer's email this way — see
+    #   Spree::Exports::Orders.
+    def to_csv(store = nil, omit_headers: [])
+      store ||= self.store
+      # Through the shared helper so the value row is built from exactly the
+      # definitions, in exactly the order, that Export#custom_fields_headers
+      # used for the header row — a mismatch shifts every value column.
+      custom_field_values = custom_fields_for_csv(self, store)
 
       csv_lines = []
-      all_line_items.each_with_index do |line_item, index|
-        csv_lines << Spree::CSV::OrderLineItemPresenter.new(self, line_item, index, metafields_for_csv).call
+      line_items.each_with_index do |line_item, index|
+        csv_lines << Spree::CSV::OrderLineItemPresenter.new(
+          self, line_item, index, custom_field_values, omit_headers: omit_headers
+        ).call
       end
       csv_lines
     end
 
     def all_line_items
+      Spree::Deprecation.warn('Spree::Order#all_line_items is deprecated and will be removed in Spree 6.1. Please use Spree::Order#line_items instead')
       line_items
     end
 
-    def requires_ship_address?
-      !digital?
-    end
-
     private
 
+    def ensure_can_be_deleted
+      return true if can_be_deleted?
+
+      errors.add(:base, :order_cannot_be_deleted, message: Spree.t(:order_cannot_be_deleted))
+      throw :abort
+    end
+
     def valid_order_routing_strategy_class(klass_name)
       return if klass_name.blank?
 
@@ -1088,30 +1269,36 @@ module Spree
     end
 
     def link_by_email
-      self.email = user.email if user
+      self.email = customer.email if customer
     end
 
     # Determine if email is required (we don't want validation errors before we hit the checkout)
     # we need to add delivery to the list for quick checkouts
     def require_email
-      true unless new_record? || ['cart', 'address', 'delivery'].include?(state)
+      !new_record? && (completed? || placed?)
     end
 
     def ensure_line_items_present
       unless line_items.present?
-        errors.add(:base, Spree.t(:there_are_no_items_for_this_order)) && (return false)
+        errors.add(:base, :there_are_no_items_for_this_order, message: Spree.t(:there_are_no_items_for_this_order)) && (return false)
       end
     end
 
-    def ensure_available_shipping_rates
-      if shipments.empty? || line_items_without_shipping_rates.present?
+    def ensure_available_delivery_rates
+      # Captured before destroy_all — afterwards there are no fulfillments
+      # left to derive the undeliverable items from.
+      undeliverable_line_items = line_items_without_delivery_rates
+
+      if fulfillments.empty? || undeliverable_line_items.present?
         # After this point, order redirects back to 'address' state and asks user to pick a proper address
         # Therefore, shipments are not necessary at this point.
-        shipments.destroy_all
+        fulfillments.destroy_all
 
-        if line_items_without_shipping_rates.present?
-          errors.add(:base, Spree.t(:products_cannot_be_shipped, product_names: line_items_without_shipping_rates.map(&:name).to_sentence))
-          self.warnings |= line_items_without_shipping_rates.map do |line_item|
+        if undeliverable_line_items.present?
+          product_names = undeliverable_line_items.map(&:name).to_sentence
+          errors.add(:base, :products_cannot_be_shipped, product_names: product_names,
+                     message: Spree.t(:products_cannot_be_shipped, product_names: product_names))
+          self.warnings |= undeliverable_line_items.map do |line_item|
             {
               code: 'delivery_unavailable',
               message: Spree.t('cart_line_item.delivery_unavailable', li_name: line_item.name),
@@ -1120,7 +1307,7 @@ module Spree
             }
           end
         else
-          errors.add(:base, Spree.t(:items_cannot_be_shipped))
+          errors.add(:base, :items_cannot_be_shipped, message: Spree.t(:items_cannot_be_shipped))
           self.warnings |= [{ code: 'delivery_unavailable', message: Spree.t(:items_cannot_be_shipped) }]
         end
 
@@ -1128,85 +1315,10 @@ module Spree
       end
     end
 
-    def after_cancel
-      update_column(:status, 'canceled')
-
-      shipments.each(&:cancel!)
-
-      # payments fully covered by gift card won't be refunded
-      # we want to only void the payment
-      if gift_card.present? && covered_by_store_credit?
-        payments.completed.store_credits.each(&:void!)
-      else
-        payments.completed.each(&:cancel!)
-        payments.incomplete.not_store_credits.each(&:void_transaction!)
-        payments.store_credits.pending.each(&:void!)
-      end
-
-      update_with_updater!
-      send_order_canceled_webhook
-    end
-
-    def after_resume
-      update_column(:status, 'placed')
-
-      shipments.each(&:resume!)
-      consider_risk
-      send_order_resumed_webhook
-      publish_order_resumed_event
-    end
-
-    def use_billing?
-      use_billing.in?([true, 'true', '1'])
-    end
-
-    def use_shipping?
-      use_shipping.in?([true, 'true', '1'])
-    end
-
-    def ensure_currency_presence
-      self.currency ||= store&.default_currency
-    end
-
-    # Sets the locale from Spree::Current.locale when not already set.
-    # Called as a before_validation callback, mirroring ensure_currency_presence.
-    def ensure_locale_presence
-      self.locale ||= Spree::Current.locale
-    end
-
-    def currency_must_be_supported_by_store
-      return if currency.blank? || store.blank?
-
-      supported_codes = store.supported_currencies_list.map(&:iso_code)
-      unless supported_codes.include?(currency)
-        errors.add(:currency, Spree.t(:currency_not_supported_by_store))
-      end
-    end
-
-    # Validates that the order's locale is within the store's supported locales.
-    # Mirrors currency_must_be_supported_by_store.
-    def locale_must_be_supported_by_store
-      return if locale.blank? || store.blank?
-
-      unless store.supported_locales_list.include?(locale)
-        errors.add(:locale, Spree.t(:locale_not_supported_by_store))
-      end
-    end
-
-    # When currency changes, auto-resolve the matching market.
-    # Only applies when the store has markets configured.
-    def resolve_market_from_currency
-      return unless store_has_markets?
-      return if market&.currency == currency
-
-      resolved = store.markets.find_by(currency: currency)
-      self.market = resolved if resolved
-    end
-
     def collect_payment_methods
-      Spree::Deprecation.warn('`Order#collect_payment_methods` is deprecated and will be removed in Spree 5.5. Use `collect_frontend_payment_methods` instead.')
+      Spree::Deprecation.warn('`Order#collect_payment_methods` is deprecated and will be removed in Spree 6.1. Use `payment_methods` instead.')
 
-      store.payment_methods.available_on_front_end.select { |pm| pm.available_for_order?(self) }
+      store.payment_methods.active.storefront_visible.select { |pm| pm.available_for_order?(self) }
     end
 
     def credit_card_nil_payment?(attributes)
@@ -1214,21 +1326,14 @@ module Spree
     end
 
     def recalculate_store_credit_payment
-      updater.update_adjustment_total if using_store_credit?
+      recalculate_totals! if using_store_credit?
 
       if gift_card.present?
         recalculate_gift_card
       elsif using_store_credit?
-        Spree.checkout_add_store_credit_service.call(order: self)
+        Spree.store_credit_apply_service.call(order: self)
       end
     end
 
-    def publish_order_completed_event
-      publish_event('order.completed', event_payload.merge(notify_customer: notify_customer))
-    end
-
-    def publish_order_resumed_event
-      publish_event('order.resumed')
-    end
   end
 end