spree_api 6.0.0.rc1 → 6.0.0.rc2

data/app/serializers/spree/api/v3/order_group_serializer.rb

@@ -8,9 +8,7 @@ module Spree
       # their order history shows them — with the per-seller orders nested
       # inside it, each carrying its own items, delivery and tracking.
       class OrderGroupSerializer < BaseSerializer
-        typelize number: :string, email: [:string, nullable: true], currency: :string,
-                 total: [:string, nullable: true], display_total: [:string, nullable: true],
-                 item_total: [:string, nullable: true], display_item_total: [:string, nullable: true],
+        typelize number: :string, email: [:string, nullable: true], currency: [:string, enum: Spree::Money::Rounding::CURRENCY_CODES, enum_type_name: 'CurrencyCode'],
                  fulfillment_status: [:string, nullable: true, enum: Spree::Order::FULFILLMENT_STATUSES],
                  payment_status: [:string, nullable: true, enum: Spree::Order::PAYMENT_STATUSES],
                  completed_at: [:string, nullable: true],
@@ -18,7 +16,11 @@ module Spree
 
         attributes :number, :email, :currency
 
-        attributes total: :string, display_total: :string, item_total: :string, display_item_total: :string
+        # Every figure is rolled up from the children, never prorated back
+        # down. The payments are the group's own: a split checkout pays once,
+        # against the group, so a child holds none.
+        include Spree::Api::V3::PurchaseSummary
+
         # Rolled up across the children rather than stored, so it can never
         # disagree with the orders it describes.
         attributes :fulfillment_status, :payment_status
@@ -30,6 +32,12 @@ module Spree
         one :billing_address, resource: proc { Spree.api.address_serializer }
         one :shipping_address, resource: proc { Spree.api.address_serializer }
 
+        # The card itself is deliberately not nested here — the split copies it
+        # onto every child, so it is already in the payload, and a group this
+        # deep pushes the generated Zod schema past what TypeScript will
+        # serialize into a declaration file. `gift_card_total` is the figure a
+        # summary needs, and only the group can answer it.
+
         # The whole point of the group: the customer sees one purchase, and the
         # seller orders inside it are how it will arrive.
         many :orders, resource: proc { Spree.api.order_serializer }

data/app/serializers/spree/api/v3/order_serializer.rb

@@ -9,12 +9,11 @@ module Spree
                  channel_id: [:string, nullable: true], company_id: [:string, nullable: true],
                  company_name: [:string, nullable: true], po_number: [:string, nullable: true],
                  po_document_filename: [:string, nullable: true], po_document_byte_size: ['number | null'],
-                 currency: :string, locale: [:string, nullable: true], total_quantity: :number,
+                 currency: [:string, enum: Spree::Money::Rounding::CURRENCY_CODES, enum_type_name: 'CurrencyCode'], locale: [:string, nullable: true, enum: Spree::Locales::ALL, enum_type_name: 'LocaleCode'], total_quantity: :number,
                  coupon_code: [:string, nullable: true],
                  fulfillment_status: [:string, nullable: true, enum: Spree::Order::FULFILLMENT_STATUSES],
                  payment_status: [:string, nullable: true, enum: Spree::Order::PAYMENT_STATUSES],
-                 store_credit_total: [:string, nullable: true], display_store_credit_total: [:string, nullable: true],
-                 covered_by_store_credit: :boolean, completed_at: [:string, nullable: true],
+                 completed_at: [:string, nullable: true],
                  withdrawal_period_ends_at: [:string, nullable: true], within_withdrawal_period: :boolean,
                  billing_address: { nullable: true }, shipping_address: { nullable: true },
                  gift_card: { nullable: true }, market: { nullable: true }
@@ -64,25 +63,9 @@ module Spree
 
         # Nulled for gated (prices_hidden) guests, consistent with cart and
         # catalog price hiding.
-        money_attributes :item_total, :display_item_total,
-                         :adjustment_total, :display_adjustment_total,
-                         :discount_total, :display_discount_total,
-                         :tax_total, :display_tax_total, :included_tax_total, :display_included_tax_total,
-                         :additional_tax_total, :display_additional_tax_total, :total, :display_total,
-                         :gift_card_total, :display_gift_card_total,
-                         :amount_due, :display_amount_due,
-                         :delivery_total, :display_delivery_total,
-                         :fee_total, :display_fee_total
-
-        attribute :store_credit_total do |order|
-          order.total_applied_store_credit.to_s unless params[:hide_prices]
-        end
-
-        attribute :display_store_credit_total do |order|
-          order.display_total_applied_store_credit.to_s unless params[:hide_prices]
-        end
-
-        attribute :covered_by_store_credit, &:covered_by_store_credit?
+        include Spree::Api::V3::PurchaseSummary
+        money_attributes :adjustment_total, :display_adjustment_total,
+                         descriptions: { adjustment_total: 'Every discount, fee and added tax together, as one amount.' }
 
         many :order_promotions, key: :discounts, resource: proc { Spree.api.applied_promotion_serializer }
         # Itemized charges (duties, surcharges, COD, handling) — see the cart
@@ -90,7 +73,6 @@ module Spree
         many :fees, resource: proc { Spree.api.fee_serializer }
         many :line_items, key: :items, resource: proc { Spree.api.line_item_serializer }
         many :fulfillments, resource: proc { Spree.api.fulfillment_serializer }
-        many :payments, resource: proc { Spree.api.payment_serializer }
         one :billing_address, resource: proc { Spree.api.address_serializer }
         one :shipping_address, resource: proc { Spree.api.address_serializer }
         one :gift_card, resource: proc { Spree.api.gift_card_serializer }

data/app/serializers/spree/api/v3/payment_session_serializer.rb

@@ -2,7 +2,7 @@ module Spree
   module Api
     module V3
       class PaymentSessionSerializer < BaseSerializer
-        typelize status: [:string, enum: Spree::PaymentSession.statuses, enum_type_name: 'PaymentSessionStatus'], amount: :string, currency: :string,
+        typelize status: [:string, enum: Spree::PaymentSession.statuses, enum_type_name: 'PaymentSessionStatus'], currency: [:string, enum: Spree::Money::Rounding::CURRENCY_CODES, enum_type_name: 'CurrencyCode'],
                  external_id: :string, external_data: 'Record<string, unknown>',
                  expires_at: [:string, nullable: true], customer_external_id: [:string, nullable: true],
                  payment_method_id: :string, order_id: [:string, nullable: true],
@@ -12,9 +12,7 @@ module Spree
                    :customer_external_id,
                    expires_at: :iso8601
 
-        attribute :amount do |session|
-          session.amount&.to_s
-        end
+        money_attributes :amount
 
         prefixed_id_attributes :payment_method
 

data/app/serializers/spree/api/v3/price_history_serializer.rb

@@ -4,13 +4,13 @@ module Spree
   module Api
     module V3
       class PriceHistorySerializer < BaseSerializer
-        typelize amount: :string,
-                 amount_in_cents: :number,
-                 display_amount: :string,
-                 currency: :string,
+        typelize display_amount: display_money_type(:display_amount, nullable: false),
+                 currency: [:string, enum: Spree::Money::Rounding::CURRENCY_CODES, enum_type_name: 'CurrencyCode'],
                  recorded_at: :string
 
-        attributes :amount, :amount_in_cents, :currency
+        attributes :currency
+
+        money_attributes :amount, unit_price: true
 
         attributes :display_amount
 

data/app/serializers/spree/api/v3/price_serializer.rb

@@ -5,17 +5,14 @@ module Spree
       # Represents a resolved/calculated price for storefront display
       # Can represent either a calculated price (with price list resolution) or a base price
       class PriceSerializer < BaseSerializer
-        typelize amount: [:string, nullable: true],
-                 amount_in_cents: [:number, nullable: true],
-                 display_amount: [:string, nullable: true],
-                 compare_at_amount: [:string, nullable: true],
-                 compare_at_amount_in_cents: [:number, nullable: true],
-                 display_compare_at_amount: [:string, nullable: true],
-                 currency: [:string, nullable: true],
+        typelize display_amount: display_money_type(:display_amount),
+                 display_compare_at_amount: display_money_type(:display_compare_at_amount),
+                 currency: [:string, nullable: true, enum: Spree::Money::Rounding::CURRENCY_CODES, enum_type_name: 'CurrencyCode'],
                  price_list_id: [:string, nullable: true]
 
-        attributes :amount, :amount_in_cents, :compare_at_amount,
-                   :compare_at_amount_in_cents, :currency
+        attributes :currency
+
+        money_attributes :amount, :compare_at_amount, unit_price: true
 
         attribute :display_amount do |price|
           price.display_amount&.to_s

data/app/serializers/spree/api/v3/product_filter_price_range_serializer.rb

@@ -4,11 +4,17 @@ module Spree
       class ProductFilterPriceRangeSerializer < BaseSerializer
         typelize id: :string,
                  type: "'price_range'",
-                 min: :number,
-                 max: :number,
-                 currency: :string
+                 min: :string,
+                 max: :string,
+                 currency: [:string, enum: Spree::Money::Rounding::CURRENCY_CODES, enum_type_name: 'CurrencyCode']
 
-        attributes :id, :type, :min, :max, :currency
+        attributes :id, :type
+
+        # Search providers hand the bounds over as numbers.
+        attribute(:min) { |range| Spree::Money::Rounding.format(range[:min], range[:currency], unit_price: true) }
+        attribute(:max) { |range| Spree::Money::Rounding.format(range[:max], range[:currency], unit_price: true) }
+
+        attributes :currency
       end
     end
   end

data/app/serializers/spree/api/v3/product_serializer.rb

@@ -79,7 +79,7 @@ module Spree
         # single-seller catalog winner and default variant are the same row.
         attribute :price do |product|
           price = price_for(featured_variant(product))
-          Spree.api.price_serializer.new(price, params: params).to_h if price.present?
+          price_serializer.new(price, params: params).to_h if price.present?
         end
 
         # Original price - base price without price list resolution (for showing strikethrough)
@@ -90,7 +90,7 @@ module Spree
           base = price_in(variant)
 
           if calculated.present? && base.present? && calculated.id != base.id
-            Spree.api.price_serializer.new(base, params: params).to_h
+            price_serializer.new(base, params: params).to_h
           end
         end
 
@@ -148,7 +148,7 @@ module Spree
         attribute :prior_price,
                   if: proc { expand?('prior_price') } do |product|
           record = price_in(featured_variant(product))&.prior_price
-          Spree.api.price_history_serializer.new(record, params: params).to_h if record
+          price_history_serializer.new(record, params: params).to_h if record
         end
       end
     end

data/app/serializers/spree/api/v3/refund_serializer.rb

@@ -4,15 +4,14 @@ module Spree
   module Api
     module V3
       class RefundSerializer < BaseSerializer
-        typelize amount: [:string, nullable: true], transaction_id: [:string, nullable: true],
+        typelize transaction_id: [:string, nullable: true],
                  payment_id: [:string, nullable: true], refund_reason_id: [:string, nullable: true],
-                 originator_id: [:string, nullable: true], originator_type: [:string, nullable: true]
+                 originator_id: [:string, nullable: true], originator_type: [:string, nullable: true],
+                 reimbursement_id: [:string, nullable: true, deprecated: 'Always null: reimbursements are gone. Use `originator_id`. Removed in 6.1.']
 
         attributes :transaction_id
 
-        attribute :amount do |refund|
-          refund.amount&.to_s
-        end
+        money_attributes :amount
 
         prefixed_id_attributes :payment, refund_reason_id: :reason
 
@@ -23,6 +22,10 @@ module Spree
         attribute :originator_type do |refund|
           Spree::Base.polymorphic_api_type(refund.originator_type)
         end
+
+        # @deprecated Reimbursements were folded into returns, which a refund
+        #   names as its +originator+. Removed in 6.1.
+        attribute(:reimbursement_id) { nil }
       end
     end
   end

data/app/serializers/spree/api/v3/return_line_item_serializer.rb

@@ -7,25 +7,17 @@ module Spree
         typelize quantity: :number,
                  received_quantity: :number,
                  resellable: :boolean,
-                 pre_tax_amount: :string,
-                 display_pre_tax_amount: :string,
-                 included_tax_total: :string,
-                 additional_tax_total: :string,
-                 tax_total: :string,
-                 display_tax_total: :string,
-                 refund_amount: :string,
-                 display_refund_amount: :string,
                  variant_id: [:string, nullable: true],
                  line_item_id: [:string, nullable: true],
                  fulfillment_item_id: [:string, nullable: true]
 
         attributes :quantity, :received_quantity, :resellable
 
-        attributes pre_tax_amount: :string, display_pre_tax_amount: :string, included_tax_total: :string,
-                   additional_tax_total: :string, tax_total: :string, display_tax_total: :string
+        money_attributes :pre_tax_amount, :display_pre_tax_amount, :included_tax_total,
+                         :additional_tax_total, :tax_total, :display_tax_total
         # What the line refunds, tax included — for the units that arrived
         # once the warehouse has counted.
-        attributes refund_amount: :string, display_refund_amount: :string
+        money_attributes :refund_amount, :display_refund_amount
         prefixed_id_attributes :variant, :line_item, :fulfillment_item
 
         one :variant, resource: proc { Spree.api.variant_serializer }, if: proc { expand?('variant') }

data/app/serializers/spree/api/v3/return_serializer.rb

@@ -10,10 +10,6 @@ module Spree
                  status: [:string, enum: Spree::Return.statuses, enum_type_name: 'ReturnStatus'],
                  order_id: [:string, nullable: true],
                  reason_id: [:string, nullable: true],
-                 refund_total: :string,
-                 display_refund_total: :string,
-                 refund_tax_total: :string,
-                 display_refund_tax_total: :string,
                  approved_at: [:string, nullable: true],
                  received_at: [:string, nullable: true],
                  refunded_at: [:string, nullable: true],
@@ -23,9 +19,10 @@ module Spree
 
         prefixed_id_attributes :order, :reason
 
-        attributes refund_total: :string, display_refund_total: :string
+        money_attributes :refund_total, :display_refund_total
         # The tax inside refund_total.
-        attributes refund_tax_total: :string, display_refund_tax_total: :string
+        money_attributes :refund_tax_total, :display_refund_tax_total
+
         attribute :approved_at do |return_record|
           return_record.approved_at&.iso8601
         end

data/app/serializers/spree/api/v3/seller/address_serializer.rb

@@ -0,0 +1,12 @@
+module Spree
+  module Api
+    module V3
+      module Seller
+        class AddressSerializer < V3::AddressSerializer
+          # The Store API keeps these deprecated names until 6.1.
+          %i[state_abbr country_iso].each { |key| _attributes.delete(key) }
+        end
+      end
+    end
+  end
+end

data/app/serializers/spree/api/v3/seller/balance_serializer.rb

@@ -6,14 +6,14 @@ module Spree
         #
         # A computed value rather than a record, so it carries no id.
         class BalanceSerializer < V3::BaseSerializer
-          typelize currency: :string,
-                   settlement_currency: :string,
+          typelize currency: [:string, enum: Spree::Money::Rounding::CURRENCY_CODES, enum_type_name: 'CurrencyCode'],
+                   settlement_currency: [:string, enum: Spree::Money::Rounding::CURRENCY_CODES, enum_type_name: 'CurrencyCode'],
                    converted: :boolean,
-                   earned: :string, display_earned: :string,
-                   payable: :string, display_payable: :string,
-                   paid: :string, display_paid: :string,
-                   balance: :string, display_balance: :string,
-                   pending: :string, display_pending: :string
+                   earned: :string,
+                   payable: :string,
+                   paid: :string,
+                   balance: :string,
+                   pending: :string
 
           _attributes.delete(:id)
 
@@ -24,9 +24,14 @@ module Spree
 
           attribute(:converted) { |balance| balance.converted? }
 
-          %i[earned payable paid balance pending].each do |figure|
-            attribute(figure) { |balance| balance.public_send(figure).to_s }
-            attribute(:"display_#{figure}") { |balance| balance.public_send(:"display_#{figure}").to_s }
+          # Earnings are in the currency the sales were priced in; what the
+          # account holds is in the one it settles in.
+          %i[earned pending].each do |figure|
+            attribute(figure) { |balance| Spree::Money::Rounding.format(balance.public_send(figure), balance.currency) }
+          end
+
+          %i[payable paid balance].each do |figure|
+            attribute(figure) { |balance| Spree::Money::Rounding.format(balance.public_send(figure), balance.settlement_currency) }
           end
         end
       end

data/app/serializers/spree/api/v3/seller/claim_line_item_serializer.rb

@@ -7,6 +7,13 @@ module Spree
         # One line of a claim — what went wrong, and what is being sent or
         # refunded to put it right.
         class ClaimLineItemSerializer < V3::ClaimLineItemSerializer
+          without_formatted_money(:seller)
+
+          # No guest price gating here, so the inherited money fields are always present.
+          typelize refund_amount: [:string, nullable: false], paid_amount: [:string, nullable: false],
+                   pre_tax_amount: [:string, nullable: false], included_tax_total: [:string, nullable: false],
+                   additional_tax_total: [:string, nullable: false], tax_total: [:string, nullable: false]
+
           typelize name: [:string, nullable: true]
 
           attribute :name do |line|

data/app/serializers/spree/api/v3/seller/claim_serializer.rb

@@ -9,6 +9,11 @@ module Spree
         # Built on the shared V3 serializer rather than the admin one, which
         # expands the order and the customer behind it.
         class ClaimSerializer < V3::ClaimSerializer
+          without_formatted_money(:seller)
+
+          # No guest price gating here, so the inherited money fields are always present.
+          typelize refund_total: [:string, nullable: false]
+
           typelize memo: [:string, nullable: true]
 
           attributes :memo

data/app/serializers/spree/api/v3/seller/country_serializer.rb

@@ -0,0 +1,19 @@
+module Spree
+  module Api
+    module V3
+      module Seller
+        # A country as the seller panel's address forms need it. The panel
+        # names countries with Intl.DisplayNames in the seller's own language,
+        # so the Seller API sends the ISO code alone.
+        class CountrySerializer < V3::CountrySerializer
+          _attributes.delete(:name)
+          _attributes.delete(:market)
+
+          many :states,
+               resource: proc { Spree.api.seller_state_serializer },
+               if: proc { params[:expand]&.include?('states') }
+        end
+      end
+    end
+  end
+end

data/app/serializers/spree/api/v3/seller/delivery_method_rule_serializer.rb

@@ -12,8 +12,7 @@ module Spree
         class DeliveryMethodRuleSerializer < BaseSerializer
           typelize type: [:string, comment: 'Rule type. Built-in: item_total_rule, weight_rule, excluded_products_rule, channel_rule, volume_rule, company_rule. Extensions may register more.'],
                    active: :boolean,
-                   preferences: 'Record<string, unknown>',
-                   preference_schema: "Array<{ key: string; type: string; default: unknown; choices?: string[] }>"
+                   preferences: 'Record<string, unknown>'
 
           attributes :active
 
@@ -24,7 +23,6 @@ module Spree
           end
 
           attribute :preferences, &:serialized_preferences
-          attribute :preference_schema, &:serialized_preference_schema
         end
       end
     end

data/app/serializers/spree/api/v3/seller/delivery_method_serializer.rb

@@ -22,8 +22,7 @@ module Spree
                    editable: :boolean,
                    delivery_profile_id: [:string, nullable: true],
                    delivery_zone_id: [:string, nullable: true],
-                   calculator_type: [:string, nullable: true],
-                   calculator_preferences: ['Record<string, unknown>', nullable: true]
+                   calculator: 'TypedDeliveryCalculator | null'
 
           attributes :admin_name, :storefront_visible, :tracking_url,
                      created_at: :iso8601, updated_at: :iso8601
@@ -39,12 +38,9 @@ module Spree
 
           prefixed_id_attributes :delivery_profile, :delivery_zone
 
-          attribute :calculator_type do |record|
-            record.calculator&.class&.api_type
-          end
-
-          attribute :calculator_preferences do |record|
-            record.calculator.respond_to?(:serialized_preferences) ? record.calculator.serialized_preferences : record.calculator&.preferences
+          attribute :calculator do |record|
+            calculator = record.calculator
+            { type: calculator.class.api_type, preferences: calculator.serialized_preferences } if calculator
           end
         end
       end

data/app/serializers/spree/api/v3/seller/delivery_rate_serializer.rb

@@ -10,18 +10,19 @@ module Spree
         class DeliveryRateSerializer < V3::BaseSerializer
           typelize name: :string,
                    selected: :boolean,
-                   cost: :string,
-                   display_cost: :string,
-                   total: :string,
-                   display_total: :string,
                    carrier: [:string, nullable: true],
                    service_level: [:string, nullable: true],
-                   estimated_delivery_date: [:string, nullable: true]
+                   estimated_delivery_date: [:string, nullable: true],
+                   unpriced: :boolean
 
-          attributes :name, :selected, :cost, :total,
-                     :carrier, :service_level, :estimated_delivery_date
+          attributes :name, :selected
 
-          attributes display_cost: :string, display_total: :string
+          money_attributes :cost, :total
+
+          attributes :carrier, :service_level, :estimated_delivery_date, :unpriced
+
+          typelize cost: [:string, nullable: false],
+                   total: [:string, nullable: false]
         end
       end
     end

data/app/serializers/spree/api/v3/seller/exchange_line_item_serializer.rb

@@ -7,6 +7,11 @@ module Spree
         # One line of an exchange — what came back and what goes out in its
         # place. Both variants expand through the seller's own serializer.
         class ExchangeLineItemSerializer < V3::ExchangeLineItemSerializer
+          # No guest price gating here, so the inherited money fields are always present.
+          typelize original_price: [:string, nullable: false], new_variant_price: [:string, nullable: false],
+                   price_difference: [:string, nullable: false], original_tax_total: [:string, nullable: false],
+                   new_tax_total: [:string, nullable: false]
+
           typelize name: [:string, nullable: true],
                    new_variant_name: [:string, nullable: true]
 

data/app/serializers/spree/api/v3/seller/exchange_serializer.rb

@@ -9,6 +9,11 @@ module Spree
         # Built on the shared V3 serializer rather than the admin one, which
         # expands the order and the customer behind it.
         class ExchangeSerializer < V3::ExchangeSerializer
+          without_formatted_money(:seller)
+
+          # No guest price gating here, so the inherited money fields are always present.
+          typelize price_difference: [:string, nullable: false]
+
           typelize memo: [:string, nullable: true],
                    stock_location_id: [:string, nullable: true]
 

data/app/serializers/spree/api/v3/seller/file_upload_serializer.rb

@@ -0,0 +1,11 @@
+module Spree
+  module Api
+    module V3
+      module Seller
+        class FileUploadSerializer < V3::FileUploadSerializer
+          one :upload_target, key: :upload, resource: proc { Spree.api.seller_file_upload_target_serializer }
+        end
+      end
+    end
+  end
+end

data/app/serializers/spree/api/v3/seller/file_upload_target_serializer.rb

@@ -0,0 +1,10 @@
+module Spree
+  module Api
+    module V3
+      module Seller
+        class FileUploadTargetSerializer < V3::FileUploadTargetSerializer
+        end
+      end
+    end
+  end
+end

data/app/serializers/spree/api/v3/seller/import_serializer.rb

@@ -15,7 +15,7 @@ module Spree
           typelize completed_rows_count: :number,
                    failed_rows_count: :number,
                    processing_errors: [:string, nullable: true],
-                   preferred_delimiter: :string,
+                   delimiter: :string,
                    schema_fields: 'Array<{ name: string; label: string; required: boolean }>',
                    csv_headers: [:string, multi: true],
                    sample_row: 'Record<string, string | null>',
@@ -23,7 +23,7 @@ module Spree
                    original_byte_size: [:number, nullable: true],
                    original_file_url: [:string, nullable: true]
 
-          attributes :processing_errors, :preferred_delimiter
+          attributes :processing_errors, :delimiter
 
           # The file the seller uploaded. `original_file_url` is this branch's
           # own streaming endpoint (JWT-authenticated), not a signed

data/app/serializers/spree/api/v3/seller/media_serializer.rb

@@ -9,12 +9,9 @@ module Spree
         # it is cropped, and which variants it belongs to.
         class MediaSerializer < V3::MediaSerializer
           typelize position: :number,
-                   variant_ids: [:string, multi: true],
-                   focal_point_x: [:number, nullable: true],
-                   focal_point_y: [:number, nullable: true]
+                   variant_ids: [:string, multi: true]
 
-          attributes :position, :focal_point_x, :focal_point_y,
-                     created_at: :iso8601, updated_at: :iso8601
+          attributes :position, created_at: :iso8601, updated_at: :iso8601
 
           attribute :variant_ids do |media|
             media.variants.map(&:prefixed_id)

data/app/serializers/spree/api/v3/seller/order_line_item_serializer.rb

@@ -12,14 +12,15 @@ module Spree
         # this branch's generated types.
         class OrderLineItemSerializer < V3::BaseSerializer
           typelize name: :string, sku: [:string, nullable: true], options_text: [:string, nullable: true],
-                   quantity: :number, currency: :string, variant_id: [:string, nullable: true],
+                   quantity: :number, currency: [:string, enum: Spree::Money::Rounding::CURRENCY_CODES, enum_type_name: 'CurrencyCode'], variant_id: [:string, nullable: true],
                    thumbnail_url: [:string, nullable: true]
 
           attributes :name, :options_text, :quantity, :currency
 
           # The tax charged on top is what a claim refunds beside the goods.
-          money_attributes :price, :display_price, :discounted_amount, :display_discounted_amount,
-                           :additional_tax_total, :total, :display_total
+          money_attributes :price, unit_price: true
+          money_attributes :discounted_amount,
+                           :additional_tax_total, :total
 
           prefixed_id_attributes :variant
 

data/app/serializers/spree/api/v3/seller/order_serializer.rb

@@ -21,7 +21,7 @@ module Spree
         # the one contact detail that lets a marketplace's customer be taken
         # off it, and it is not needed to pack, post or invoice.
         class OrderSerializer < V3::BaseSerializer
-          typelize number: :string, customer_note: [:string, nullable: true], currency: :string,
+          typelize number: :string, customer_note: [:string, nullable: true], currency: [:string, enum: Spree::Money::Rounding::CURRENCY_CODES, enum_type_name: 'CurrencyCode'],
                    total_quantity: :number,
                    fulfillment_status: [:string, nullable: true, enum: Spree::Order::FULFILLMENT_STATUSES],
                    payment_status: [:string, nullable: true, enum: Spree::Order::PAYMENT_STATUSES],
@@ -47,16 +47,16 @@ module Spree
           # What this seller is owed for the goods, and what the buyer paid for
           # them. Deliberately not the whole money surface: gift cards, store
           # credit and the payment breakdown belong to the marketplace.
-          money_attributes :item_total, :display_item_total,
-                           :delivery_total, :display_delivery_total,
-                           :discount_total, :display_discount_total,
-                           :adjustment_total, :display_adjustment_total,
-                           :included_tax_total, :display_included_tax_total,
-                           :additional_tax_total, :display_additional_tax_total,
-                           :tax_total, :display_tax_total,
-                           :total, :display_total,
-                           :payment_total, :display_payment_total,
-                           :amount_due, :display_amount_due
+          money_attributes :item_total,
+                           :delivery_total,
+                           :discount_total,
+                           :adjustment_total,
+                           :included_tax_total,
+                           :additional_tax_total,
+                           :tax_total,
+                           :total,
+                           :payment_total,
+                           :amount_due
 
           # What the marketplace charged the seller on this sale, and the tax
           # on that charge. The ledger remains where a seller sees what they
@@ -64,9 +64,9 @@ module Spree
           # commission is a B2B supply from the platform, so this is the
           # seller's input tax to reclaim, and it has to be attributable to
           # the sale that produced it.
-          money_attributes :commission_amount_total, :display_commission_amount_total,
-                           :commission_tax_total, :display_commission_tax_total,
-                           :commission_total, :display_commission_total
+          money_attributes :commission_amount_total,
+                           :commission_tax_total,
+                           :commission_total
 
           # Why the sale was called off, when it was. The reason is the
           # marketplace's vocabulary, so it is rendered as a name rather than
@@ -89,8 +89,8 @@ module Spree
           many :payment_splits, resource: proc { Spree.api.seller_payment_split_serializer },
                                 if: proc { expand?('payment_splits') }
           many :fulfillments, resource: proc { Spree.api.seller_fulfillment_serializer }
-          one :shipping_address, resource: proc { Spree.api.address_serializer }
-          one :billing_address, resource: proc { Spree.api.address_serializer }
+          one :shipping_address, resource: proc { Spree.api.seller_address_serializer }
+          one :billing_address, resource: proc { Spree.api.seller_address_serializer }
         end
       end
     end