mpp-rb 0.1.6 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d028d7ba9d07e95173c4d3618a688dd87d4674284195a58ecfa4d6d43a311bf7
-  data.tar.gz: 3a342589c1478477c42077297f11244550ce035e4d66f9e4afde2e9a125d091c
+  metadata.gz: e5d5c20207eb5f09b4f077cea8bdd1fb1f2acc15d12c5d00928cc7e8eddcf627
+  data.tar.gz: 1f080945c2a322985b47d184ccaf00b543931bcb6f4623c070175d03efab5cd8
 SHA512:
-  metadata.gz: bf7ad2c6e7db109dc6244609e24eaf42f444396f0df9a69dd428017635dca2abb001271d89cd6c1e715fa3c58bf352ee267455ea0e38623cfd6dc608cd2da609
-  data.tar.gz: 6f090b293910e66a99054316767d36913a1a258c9ae5e1989fd74b16f67c8bad236b2e5351f6c4582140f5f48a0f707f2395245196470ec4c2206b0fb41418ad
+  metadata.gz: 7044c78ebef4814fce755614c194a6723c39df930071762aab94e19e944bb241f33bfd554fdc18ed0ef5f7b3f9cdc9d219923ab4a9aac6278e94896069b2634c
+  data.tar.gz: d71d6869c20d1a569a0425cde39dd39938688735d0360db47fe82f80ac454f3d4ec015624f942c1bf1760c271e9297ca848300ac63d5d0366496b57a2475efc6

data/README.md

@@ -42,6 +42,10 @@ if result.is_a?(Mpp::Challenge)
   # Return 402 with WWW-Authenticate header
   resp = Mpp::Server::Decorator.make_challenge_response(result, server.realm)
   # resp["status"], resp["headers"], resp["body"]
+elsif result.is_a?(Mpp::Server::ComposedResult)
+  # Several offers (methods or currencies); see "Accepted currencies"
+  resp = result.to_response if result.payment_required?
+  credential, receipt = result.payment unless result.payment_required?
 else
   credential, receipt = result
   # credential.source — payer address
@@ -49,6 +53,34 @@ else
 end
 ```
 
+### Accepted currencies
+
+A Tempo server method offers one charge per accepted currency, in order, and
+accepts a credential for any of them. With the default `chain_id: 4217` (mainnet) the
+defaults are OUSD then USDC.e; with `chain_id: 42431` (Moderato) they are OUSD
+then pathUSD. Other chains, or an explicit `chain_id: nil`, keep the single pathUSD default.
+Several accepted currencies make `charge` return a `Mpp::Server::ComposedResult`.
+
+```ruby
+Mpp::Methods::Tempo.tempo(
+  intents: {"charge" => Mpp::Methods::Tempo::ChargeIntent.new},
+  chain_id: 4217,
+  recipient: "0x0000000000000000000000000000000000000001",
+  currencies: [Mpp::Methods::Tempo::Defaults::USDC] # replaces the defaults
+)
+```
+
+An explicit `currencies:` list replaces the defaults. The deprecated
+`currency:` option accepts exactly one token; pass one or the other. A
+`currency:` passed to `charge` or a compose entry still issues a single offer.
+Sponsored charges choose the fee token independently of the charge currency.
+A local fee payer accepts `fee_payer_allowed_fee_tokens:` when set, otherwise
+pathUSD and the chain's default currency (pathUSD and USDC.e on mainnet,
+pathUSD on Moderato). It pays gas in `fee_token:` when set, otherwise in the
+first allowed token it holds a balance of, otherwise in the first allowed
+token. `fee_token:` is only valid with a local fee payer; hosted sponsors
+choose their own fee token.
+
 If the endpoint already uses `Authorization` (API keys, Bearer tokens), create the server with `requires_auth: true`. Challenges then advertise `header="Payment-Authorization"`, and clients send the Payment credential in that header instead of `Authorization`.
 
 ```ruby
@@ -128,6 +160,59 @@ not advertised. Successful Tempo and Base payments are best-effort recorded as
 Stripe crypto transaction-verification PaymentIntents. Metadata is included on
 every Stripe PaymentIntent.
 
+Stripe machine-payment methods also accept private, request-scoped
+`payment_intent_options` in `charge` or composed-offer input. Supported fields
+match mppx: `customer`, `receipt_email`, `metadata`, and Stripe Tax calculation
+hooks. The value can be a static hash or a deferred callable:
+
+```ruby
+options = lambda do |challenge:, credential:, request:|
+  calculation = stripe_client.v1.tax.calculations.create(
+    tax_params,
+    {idempotency_key: "mpp_tax_#{challenge.id}"}
+  )
+  {hooks: {inputs: {tax: {calculation: calculation.id}}}}
+end
+
+payment = server.compose(
+  [payments.tempo.charge, {amount: "0.50", payment_intent_options: options}],
+  [payments.spt.charge, {amount: "0.50", payment_intent_options: options}]
+)
+```
+
+For SPT, deferred callables run after credential validation and immediately
+before PaymentIntent creation. For crypto, they run after the rail's `validate`
+and immediately before `broadcast` when supported, or before legacy `verify`
+otherwise. Tempo and Base both support the split path, including relay and x402.
+The options are not serialized in the MPP challenge. Recorded crypto payments
+retry once without optional fields only when Stripe definitively rejects them.
+
+Two-phase intents implement `validate(credential, request)` and
+`broadcast(credential, request)`. Validation returns an `Mpp::Validation` record
+with `challenge`, `credential`, `request`, `method`, `intent`, `source`, and
+method-specific `details`, matching mppx's validation-result fields. Failed
+checks raise; validation must not settle a payment or consume replay state.
+Use an empty hash for `details` when none are available; `source` defaults to
+`nil`. The record is not a settlement receipt or independent proof of challenge
+issuance. Broadcast receives
+the original inputs and returns a receipt; the combined lifecycle does not pass
+the validation record into broadcast.
+
+Tempo and EVM charge intents expose `validate(credential, request)` and
+`broadcast(credential, request)` using this contract. Validation does not submit
+payments, co-sign transactions, or consume replay state. `verify` is deprecated
+and calls both phases in order.
+Like [mppx](https://github.com/wevm/mppx/tree/43ec92c36f575339cf7c45ae466507048783a0d3/src),
+local Tempo broadcast repeats credential checks, while EVM and relay broadcast
+delegate to settlement without repeating the remote validation call. Validation
+is a preflight check, not a guarantee that settlement will succeed.
+
+Tempo retains its existing validation: transaction preflight is best-effort,
+local sponsorship checks run before co-signing, and hosted payers and relays
+retain their own validation policies. This split does not add mppx's stronger
+transaction preflight checks; final transaction acceptance still depends on the
+node or payment service.
+
 `evm.charge` additionally emits `PAYMENT-REQUIRED` and accepts `PAYMENT-SIGNATURE` (x402 v2 exact) when a facilitator is configured:
 
 ```ruby

data/lib/mpp/extensions/mcp/verify.rb

@@ -94,7 +94,7 @@ module Mpp
         core_credential = mcp_credential.to_core
 
         begin
-          core_receipt = intent.verify(core_credential, request)
+          core_receipt = Mpp::Server::IntentLifecycle.call(intent, core_credential, request)
         rescue Mpp::VerificationError => e
           Kernel.raise PaymentVerificationError.new(
             challenges: [new_challenge.call],

data/lib/mpp/methods/evm/charge_intent.rb

@@ -18,7 +18,13 @@ module Mpp
           @route_binding = route_binding
         end
 
+        # @deprecated Use #validate followed by #broadcast.
         def verify(credential, request)
+          validate(credential, request)
+          broadcast(credential, request)
+        end
+
+        def validate(credential, request)
           payload = credential.payload
           unless payload.is_a?(Hash) && payload["type"] == "authorization"
             raise Mpp::VerificationError, "EVM authorization credentials are not supported for this challenge"
@@ -65,7 +71,36 @@ module Mpp
             raise Mpp::VerificationFailedError.new(reason: "EVM authorization source mismatch")
           end
 
-          settled = settle(payload, request)
+          payment_payload, requirements = facilitator_input(payload, request)
+          verified = @facilitator.verify(payment_payload, requirements)
+          unless verified["isValid"]
+            raise Mpp::VerificationFailedError.new(
+              reason: verified["invalidMessage"] || verified["invalidReason"] || "EVM facilitator verify failed"
+            )
+          end
+
+          Mpp::Validation.new(
+            challenge: credential.challenge,
+            credential: credential,
+            details: {payer: checksummed_from},
+            intent: name,
+            method: "evm",
+            request: request,
+            source: credential.source
+          )
+        end
+
+        # Like mppx, settlement relies on a preceding #validate and the
+        # facilitator's terminal checks; it does not repeat /verify.
+        def broadcast(credential, request)
+          payment_payload, requirements = facilitator_input(credential.payload, request)
+          settled = @facilitator.settle(payment_payload, requirements)
+          unless settled["success"]
+            raise Mpp::VerificationFailedError.new(
+              reason: settled["errorMessage"] || settled["errorReason"] || "EVM facilitator settlement failed"
+            )
+          end
+
           Mpp::Receipt.success(settled.fetch("transaction"), method: "evm")
         end
 
@@ -79,7 +114,7 @@ module Mpp
 
         private
 
-        def settle(payload, request)
+        def facilitator_input(payload, request)
           requirements = payment_requirements(request)
           payment_payload = {
             "accepted" => requirements,
@@ -97,21 +132,7 @@ module Mpp
             "x402Version" => Mpp::X402::VERSION
           }
 
-          verified = @facilitator.verify(payment_payload, requirements)
-          unless verified["isValid"]
-            raise Mpp::VerificationFailedError.new(
-              reason: verified["invalidMessage"] || verified["invalidReason"] || "EVM facilitator verify failed"
-            )
-          end
-
-          settled = @facilitator.settle(payment_payload, requirements)
-          unless settled["success"]
-            raise Mpp::VerificationFailedError.new(
-              reason: settled["errorMessage"] || settled["errorReason"] || "EVM facilitator settlement failed"
-            )
-          end
-
-          settled
+          [payment_payload, requirements]
         end
 
         def x402_credential?(credential)

data/lib/mpp/methods/stripe/analytics_metadata.rb

@@ -0,0 +1,24 @@
+# typed: false
+# frozen_string_literal: true
+
+module Mpp
+  module Methods
+    module Stripe
+      # Builds Stripe-owned metadata used to identify MPP payments.
+      module AnalyticsMetadata
+        LIMIT = 500
+
+        module_function
+
+        def build(challenge)
+          {
+            "machine_payment" => "true",
+            "mpp_sdk" => "mpp-rb/#{Mpp::VERSION}",
+            "mpp_challenge_id" => challenge.id.to_s,
+            "mpp_intent" => challenge.intent.to_s
+          }.transform_values { |value| value.each_char.first(LIMIT).join }
+        end
+      end
+    end
+  end
+end

data/lib/mpp/methods/stripe/charge_intent.rb

@@ -11,11 +11,22 @@ module Mpp
       class ChargeIntent
         attr_reader :name
 
-        def initialize(secret_key:, api_base: Defaults::STRIPE_API_BASE, client: nil)
+        def initialize(secret_key:, api_base: Defaults::STRIPE_API_BASE, client: nil,
+          payment_intent_options: nil)
           @name = "charge"
           @secret_key = secret_key
           @api_base = api_base
           @client = client
+          @payment_intent_options = payment_intent_options
+        end
+
+        def with_payment_intent_options(payment_intent_options)
+          self.class.new(
+            secret_key: @secret_key,
+            api_base: @api_base,
+            client: @client,
+            payment_intent_options: payment_intent_options
+          )
         end
 
         def verify(credential, request)
@@ -27,11 +38,11 @@ module Mpp
           end
 
           payload_data = credential.payload
-          unless payload_data.is_a?(Hash) && payload_data.key?("spt")
-            raise Mpp::VerificationError, "Invalid credential payload: missing spt"
+          spt = payload_data["spt"] if payload_data.is_a?(Hash)
+          unless spt.is_a?(String) && !spt.empty?
+            raise Mpp::VerificationError, "Invalid credential payload: missing or invalid spt"
           end
 
-          spt = payload_data["spt"]
           credential_external_id = payload_data["externalId"]
           request_external_id = request["externalId"]
           if !request_external_id.nil? && credential_external_id != request_external_id
@@ -52,6 +63,13 @@ module Mpp
             raise Mpp::VerificationError, "Invalid or missing methodDetails.paymentMethodTypes"
           end
 
+          payment_intent_options = PaymentIntentOptions.resolve(
+            @payment_intent_options,
+            challenge: credential.challenge,
+            credential: credential,
+            request: request
+          ) || {}
+
           # Build PaymentIntent params
           params = {
             amount: Integer(request["amount"]),
@@ -61,8 +79,14 @@ module Mpp
             payment_method_types: payment_method_types
           }
 
+          params[:customer] = payment_intent_options[:customer] if payment_intent_options.key?(:customer)
+          params[:hooks] = payment_intent_options[:hooks] if payment_intent_options.key?(:hooks)
+          params[:receipt_email] = payment_intent_options[:receipt_email] if payment_intent_options.key?(:receipt_email)
+
           metadata = method_details["metadata"].is_a?(Hash) ? method_details["metadata"].transform_values(&:to_s) : {}
-          params[:metadata] = metadata.merge("machine_payment" => "true")
+          params[:metadata] = AnalyticsMetadata.build(credential.challenge)
+            .merge(metadata)
+            .merge(payment_intent_options.fetch(:metadata, {}))
 
           unless @client
             begin

data/lib/mpp/methods/stripe/crypto_payment_recorder.rb

@@ -4,7 +4,7 @@
 module Mpp
   module Methods
     module Stripe
-      # Records an already-verified crypto transfer as a Stripe PaymentIntent.
+      # Records an already-settled crypto transfer as a Stripe PaymentIntent.
       class CryptoPaymentRecorder
         RAW_UNITS_PER_CENT = 10_000
 
@@ -22,7 +22,11 @@ module Mpp
           cents = (amount + (RAW_UNITS_PER_CENT / 2)) / RAW_UNITS_PER_CENT
           return if cents < 1
 
-          params = {
+          analytics = AnalyticsMetadata.build(payload.fetch(:challenge))
+          options = payload[:payment_intent_options] || {}
+          configured_metadata = @metadata.is_a?(Hash) ? @metadata.transform_keys(&:to_s).transform_values(&:to_s) : {}
+          optional_metadata = configured_metadata.merge(options.fetch(:metadata, {}))
+          required_params = {
             amount: cents,
             currency: "usd",
             confirm: true,
@@ -33,22 +37,55 @@ module Mpp
                 mode: "transaction_verification",
                 transaction_verification_options: {network: @network, transaction_hash: reference}
               }
-            }
+            },
+            metadata: analytics
           }
-          metadata = @metadata.is_a?(Hash) ? @metadata.transform_values(&:to_s) : {}
-          params[:metadata] = metadata.merge("machine_payment" => "true")
+          params = required_params.dup
+          params[:customer] = options[:customer] if options.key?(:customer)
+          params[:hooks] = options[:hooks] if options.key?(:hooks)
+          params[:receipt_email] = options[:receipt_email] if options.key?(:receipt_email)
+          params[:metadata] = analytics.merge(optional_metadata)
+          has_optional_params = !optional_metadata.empty? || [:customer, :hooks, :receipt_email].any? do |key|
+            options.key?(key)
+          end
 
-          @client.v1.payment_intents.create(
-            params,
-            {stripe_version: Defaults::MACHINE_PAYMENTS_API_VERSION, idempotency_key: reference}
-          )
+          create(params, reference)
         rescue => error
+          if defined?(required_params) && has_optional_params && definitive_invalid_request?(error)
+            Kernel.warn(
+              "[stripe] optional PaymentIntent recording fields were rejected; retrying without them: " \
+                "#{error.class}: #{error.message}"
+            )
+            begin
+              return create(required_params, "#{reference}_fallback")
+            rescue => fallback_error
+              error = fallback_error
+            end
+          end
+
           Kernel.warn(
             "[stripe] failed to record crypto payment " \
               "network=#{@network.inspect} transaction_hash=#{reference.inspect}: #{error.class}: #{error.message}"
           )
           nil
         end
+
+        private
+
+        def create(params, idempotency_key)
+          @client.v1.payment_intents.create(
+            params,
+            {stripe_version: Defaults::MACHINE_PAYMENTS_API_VERSION, idempotency_key: idempotency_key}
+          )
+        end
+
+        def definitive_invalid_request?(error)
+          return true if defined?(::Stripe::InvalidRequestError) && error.is_a?(::Stripe::InvalidRequestError)
+          return true if error.respond_to?(:type) && error.type == "StripeInvalidRequestError"
+          return true if error.respond_to?(:error) && error.error.respond_to?(:type) && error.error.type == "invalid_request_error"
+
+          false
+        end
       end
     end
   end

data/lib/mpp/methods/stripe/machine_payments.rb

@@ -90,16 +90,15 @@ module Mpp
 
           chain_id = @livemode ? Mpp::Methods::Tempo::Defaults::CHAIN_ID : Mpp::Methods::Tempo::Defaults::TESTNET_CHAIN_ID
           currency = @livemode ? Mpp::Methods::Tempo::Defaults::USDC : Mpp::Methods::Tempo::Defaults::PATH_USD
-          recorder = CryptoPaymentRecorder.new(client: @client, network: "tempo", metadata: @metadata)
-          Mpp::Methods::Tempo.tempo(
+          method = Mpp::Methods::Tempo.tempo(
             intents: {"charge" => Mpp::Methods::Tempo::ChargeIntent.new(chain_id: chain_id)},
             chain_id: chain_id,
             currency: currency,
             recipient: @recipient,
             decimals: Mpp::Methods::Tempo::Defaults::PATH_USD_DECIMALS,
-            can_offer: MachinePayments.minimum_amount(CryptoPaymentRecorder::RAW_UNITS_PER_CENT),
-            on_payment_success: ->(payload) { recorder.call(payload) }
+            can_offer: MachinePayments.minimum_amount(CryptoPaymentRecorder::RAW_UNITS_PER_CENT)
           )
+          PaymentIntentMethod.new(method: method, client: @client, network: "tempo", metadata: @metadata)
         end
       end
 
@@ -115,14 +114,13 @@ module Mpp
           raise ArgumentError, "deposit_addresses[:base] is required for Base payments" if @recipient.nil?
 
           currency = @livemode ? Mpp::Methods::Evm::Assets::BASE_USDC : Mpp::Methods::Evm::Assets::BASE_SEPOLIA_USDC
-          recorder = CryptoPaymentRecorder.new(client: @client, network: "base", metadata: @metadata)
-          Mpp::Methods::Evm.charge(
+          method = Mpp::Methods::Evm.charge(
             currency: currency,
             recipient: @recipient,
             x402: x402,
-            can_offer: MachinePayments.minimum_amount(CryptoPaymentRecorder::RAW_UNITS_PER_CENT),
-            on_payment_success: ->(payload) { recorder.call(payload) }
+            can_offer: MachinePayments.minimum_amount(CryptoPaymentRecorder::RAW_UNITS_PER_CENT)
           )
+          PaymentIntentMethod.new(method: method, client: @client, network: "base", metadata: @metadata)
         end
       end
     end

data/lib/mpp/methods/stripe/payment_intent_method.rb

@@ -0,0 +1,103 @@
+# typed: false
+# frozen_string_literal: true
+
+module Mpp
+  module Methods
+    module Stripe
+      # Decorates a crypto method with private, request-scoped Stripe input.
+      class PaymentIntentMethod
+        def initialize(method:, client:, network:, metadata: nil)
+          @method = method
+          @client = client
+          @network = network
+          @metadata = metadata
+        end
+
+        def prepare_intent(intent, input)
+          options_input = input[:payment_intent_options]
+          PaymentIntentOptions.validate_input(options_input)
+          sanitized = input.except(:payment_intent_options)
+          decorated = WrappedIntent.new(
+            intent: intent,
+            options_input: options_input,
+            client: @client,
+            network: @network,
+            metadata: @metadata
+          )
+          [decorated, sanitized]
+        end
+
+        def method_missing(name, *args, **kwargs, &block)
+          return super unless @method.respond_to?(name)
+
+          @method.public_send(name, *args, **kwargs, &block)
+        end
+
+        def respond_to_missing?(name, include_private = false)
+          @method.respond_to?(name, include_private) || super
+        end
+
+        # Per-attempt intent view retaining resolved input outside protocol state.
+        class WrappedIntent
+          attr_reader :name
+
+          def initialize(intent:, options_input:, client:, network:, metadata:)
+            @intent = intent
+            @name = intent.name
+            @options_input = options_input
+            @client = client
+            @network = network
+            @metadata = metadata
+
+            # Mirror the rail's capabilities so server dispatch can validate
+            # before entering the terminal operation that resolves options.
+            if intent.respond_to?(:validate)
+              define_singleton_method(:validate) do |credential, request|
+                @intent.validate(credential, request)
+              end
+            end
+            if intent.respond_to?(:broadcast)
+              define_singleton_method(:broadcast) do |credential, request|
+                options = resolve_options(credential, request)
+                receipt = @intent.broadcast(credential, request)
+                record_payment(credential, request, receipt, options)
+              end
+            end
+          end
+
+          # @deprecated Use #validate and #broadcast when supported by the rail.
+          def verify(credential, request)
+            if respond_to?(:validate) || respond_to?(:broadcast)
+              return Mpp::Server::IntentLifecycle.call(self, credential, request)
+            end
+
+            options = resolve_options(credential, request)
+            receipt = @intent.verify(credential, request)
+            record_payment(credential, request, receipt, options)
+          end
+
+          private
+
+          def resolve_options(credential, request)
+            PaymentIntentOptions.resolve(
+              @options_input,
+              challenge: credential.challenge,
+              credential: credential,
+              request: request
+            )
+          end
+
+          def record_payment(credential, request, receipt, options)
+            CryptoPaymentRecorder.new(client: @client, network: @network, metadata: @metadata).call(
+              challenge: credential.challenge,
+              receipt: receipt,
+              request: request,
+              payment_intent_options: options
+            )
+            receipt
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mpp/methods/stripe/payment_intent_options.rb

@@ -0,0 +1,81 @@
+# typed: false
+# frozen_string_literal: true
+
+module Mpp
+  module Methods
+    module Stripe
+      # Validation and deferred resolution for request-scoped PaymentIntent input.
+      module PaymentIntentOptions
+        module_function
+
+        def validate_input(input)
+          return input if input.nil? || input.respond_to?(:call)
+
+          validate(input)
+        end
+
+        def resolve(input, challenge:, credential:, request:)
+          value = if input.respond_to?(:call)
+            input.call(challenge: challenge, credential: credential, request: request)
+          else
+            input
+          end
+          return if value.nil?
+
+          validate(value)
+        end
+
+        def validate(value)
+          raise ArgumentError, "payment_intent_options must be a Hash or callable" unless value.is_a?(Hash)
+
+          input = symbolize(value)
+          options = {}
+          options[:customer] = non_empty_string(input[:customer], "customer") if input.key?(:customer)
+          options[:receipt_email] = non_empty_string(input[:receipt_email], "receipt_email") if input.key?(:receipt_email)
+          options[:metadata] = metadata(input[:metadata]) if input.key?(:metadata)
+          options[:hooks] = hooks(input[:hooks]) if input.key?(:hooks)
+          options.freeze
+        end
+
+        def metadata(value)
+          raise ArgumentError, "payment_intent_options metadata must be a Hash" unless value.is_a?(Hash)
+
+          value.each_with_object({}) do |(key, entry), result|
+            valid_key = key.is_a?(String) || key.is_a?(Symbol)
+            unless valid_key && entry.is_a?(String)
+              raise ArgumentError, "payment_intent_options metadata must contain string values"
+            end
+            result[key.to_s] = entry
+          end.freeze
+        end
+
+        def hooks(value)
+          hooks = symbolize_hash(value, "hooks")
+          inputs = symbolize_hash(hooks[:inputs], "hooks.inputs")
+          tax = symbolize_hash(inputs[:tax], "hooks.inputs.tax")
+          calculation = non_empty_string(tax[:calculation], "hooks.inputs.tax.calculation")
+          {inputs: {tax: {calculation: calculation}}}.freeze
+        end
+
+        def non_empty_string(value, name)
+          unless value.is_a?(String) && !value.empty?
+            raise ArgumentError, "payment_intent_options #{name} must be a non-empty String"
+          end
+          value
+        end
+
+        def symbolize_hash(value, name)
+          raise ArgumentError, "payment_intent_options #{name} must be a Hash" unless value.is_a?(Hash)
+
+          symbolize(value)
+        end
+
+        def symbolize(value)
+          value.each_with_object({}) do |(key, entry), result|
+            result[key.respond_to?(:to_sym) ? key.to_sym : key] = entry
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mpp/methods/stripe/stripe_method.rb

@@ -48,6 +48,14 @@ module Mpp
           @can_offer.call(request)
         end
 
+        # Keep Stripe-only request input out of the canonical challenge while
+        # retaining it on an isolated SPT intent for terminal verification.
+        def prepare_intent(intent, input)
+          options_input = input[:payment_intent_options]
+          PaymentIntentOptions.validate_input(options_input)
+          [intent.with_payment_intent_options(options_input), input.except(:payment_intent_options)]
+        end
+
         # Transform request - injects Stripe-specific methodDetails.
         def transform_request(request, _credential)
           method_details = request.fetch("methodDetails", {})

data/lib/mpp/methods/stripe.rb

@@ -12,7 +12,10 @@ module Mpp
       autoload :ChargeIntent, "mpp/methods/stripe/charge_intent"
       autoload :ClientMethod, "mpp/methods/stripe/client_method"
       autoload :CryptoPaymentRecorder, "mpp/methods/stripe/crypto_payment_recorder"
+      autoload :AnalyticsMetadata, "mpp/methods/stripe/analytics_metadata"
       autoload :MachinePayments, "mpp/methods/stripe/machine_payments"
+      autoload :PaymentIntentMethod, "mpp/methods/stripe/payment_intent_method"
+      autoload :PaymentIntentOptions, "mpp/methods/stripe/payment_intent_options"
 
       sig do
         params(