mpp-rb 0.1.6 → 0.1.7

data/lib/mpp/methods/tempo/schemas.rb

@@ -7,8 +7,8 @@ module Mpp
       module Schemas
         HEX_PATTERN = /\A0x[a-fA-F0-9]+\z/
 
-        MethodDetails = Data.define(:chain_id, :fee_payer, :fee_payer_url, :memo) do
-          def initialize(chain_id: 4217, fee_payer: false, fee_payer_url: nil, memo: nil)
+        MethodDetails = Data.define(:chain_id, :fee_payer, :fee_payer_url) do
+          def initialize(chain_id: 4217, fee_payer: false, fee_payer_url: nil)
             super
           end
 
@@ -18,8 +18,7 @@ module Mpp
             new(
               chain_id: hash["chainId"] || 4217,
               fee_payer: hash["feePayer"] || false,
-              fee_payer_url: hash["feePayerUrl"],
-              memo: hash["memo"]
+              fee_payer_url: hash["feePayerUrl"]
             )
           end
         end

data/lib/mpp/parsing.rb

@@ -58,10 +58,17 @@ module Mpp
     def parse_auth_params(params_str)
       params = {}
       params_str.scan(AUTH_PARAM_RE) do |key, quoted_val, token_val|
-        Kernel.raise Mpp::ParseError, "Duplicate parameter: #{key}" if params.key?(key)
+        # Auth-parameter names are case-insensitive (RFC 9110 §11.2). Normalize
+        # to lowercase for both the duplicate check and storage, so "id" and
+        # "ID" are treated as the same parameter -- otherwise both get stored
+        # under their original casing and only the lowercase lookup downstream
+        # is ever read, silently ignoring the other value instead of rejecting
+        # the ambiguous header.
+        normalized_key = key.downcase
+        Kernel.raise Mpp::ParseError, "Duplicate parameter: #{key}" if params.key?(normalized_key)
 
         value = quoted_val.nil? ? token_val : unescape_quoted(quoted_val)
-        params[key] = value
+        params[normalized_key] = value
       end
       params
     end

data/lib/mpp/server/compose.rb

@@ -140,7 +140,7 @@ module Mpp
 
       sig { params(handler: T.untyped, entries: T::Array[T.untyped]).returns(ComposedHandler) }
       def self.from_entries(handler, entries)
-        new(handler: handler, offers: entries.map { |entry| offer_from_entry(handler, entry) })
+        new(handler: handler, offers: entries.flat_map { |entry| offers_from_entry(handler, entry) })
       end
 
       # Flatten nested compositions into a single handler.
@@ -200,8 +200,9 @@ module Mpp
 
       private
 
-      sig { params(handler: T.untyped, entry: T.untyped).returns(ComposeOffer) }
-      def self.offer_from_entry(handler, entry)
+      # A method accepting several currencies yields one offer per currency.
+      sig { params(handler: T.untyped, entry: T.untyped).returns(T::Array[ComposeOffer]) }
+      def self.offers_from_entry(handler, entry)
         unless entry.is_a?(Array) && entry.length == 2
           Kernel.raise ArgumentError, "compose() entries must be [method, options] tuples"
         end
@@ -212,9 +213,13 @@ module Mpp
           Kernel.raise ArgumentError, "compose() options must be a Hash"
         end
 
-        ComposeOffer.new(handler, handler.resolve_method(method_ref), options)
+        method = handler.resolve_method(method_ref)
+        currencies = Mpp::Server::MethodHelper.offer_currencies(method, options)
+        return [ComposeOffer.new(handler, method, options)] if currencies.nil?
+
+        currencies.map { |currency| ComposeOffer.new(handler, method, options.merge(currency: currency)) }
       end
-      private_class_method :offer_from_entry
+      private_class_method :offers_from_entry
 
       sig do
         params(

data/lib/mpp/server/intent.rb

@@ -6,7 +6,11 @@ module Mpp
     extend T::Sig
 
     # Intent interface (duck type):
-    #   name  -> String
+    #   name -> String
+    #   validate(credential, request) -> Validation
+    #   broadcast(credential, request) -> Receipt
+    #
+    # Intents may temporarily implement only the deprecated verify API:
     #   verify(credential, request) -> Receipt
     #
     # Implement this interface for custom payment intents.
@@ -25,6 +29,7 @@ module Mpp
       end
 
       sig { params(credential: Mpp::Credential, request: T::Hash[String, T.untyped]).returns(Mpp::Receipt) }
+      # @deprecated Implement #validate and #broadcast for new intents.
       def verify(credential, request)
         @verify_fn.call(credential, request)
       end

data/lib/mpp/server/intent_lifecycle.rb

@@ -0,0 +1,41 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Mpp
+  module Server
+    # Dispatches an intent through its optional two-phase lifecycle.
+    #
+    # Two-phase intents expose separate non-mutating validation and terminal
+    # payment operations:
+    #   validate(credential, request) -> Validation
+    #   broadcast(credential, request) -> Receipt
+    #
+    # Broadcast receives the original inputs rather than trusting a prior
+    # validation result, matching mppx's re-validation behavior.
+    #
+    # Intents that only implement the deprecated #verify API continue to work
+    # through the legacy path.
+    module IntentLifecycle
+      extend T::Sig
+
+      module_function
+
+      sig { params(intent: T.untyped, credential: Mpp::Credential, request: T::Hash[String, T.untyped]).returns(Mpp::Receipt) }
+      def call(intent, credential, request)
+        has_validate = intent.respond_to?(:validate)
+        has_broadcast = intent.respond_to?(:broadcast)
+
+        if has_validate != has_broadcast
+          Kernel.raise ArgumentError, "intent must implement both #validate and #broadcast"
+        end
+
+        if has_validate
+          intent.validate(credential, request)
+          intent.broadcast(credential, request)
+        else
+          intent.verify(credential, request)
+        end
+      end
+    end
+  end
+end

data/lib/mpp/server/method.rb

@@ -24,6 +24,20 @@ module Mpp
         end
       end
 
+      # Give a method a chance to create a request-scoped intent view and to
+      # remove private server input before the canonical request is built.
+      sig { params(method: T.untyped, intent: T.untyped, input: T::Hash[Symbol, T.untyped]).returns([T.untyped, T::Hash[Symbol, T.untyped]]) }
+      def prepare_intent(method, intent, input)
+        return [intent, input] unless method.respond_to?(:prepare_intent)
+
+        prepared = method.prepare_intent(intent, input)
+        unless prepared.is_a?(Array) && prepared.length == 2 && prepared[1].is_a?(Hash)
+          Kernel.raise ArgumentError, "prepare_intent must return [intent, request_input]"
+        end
+
+        [prepared[0], prepared[1]]
+      end
+
       # Check whether a method should be advertised for a canonical request.
       # This only governs composing new 402 offers, never credential redemption.
       sig { params(method: T.untyped, request: T::Hash[String, T.untyped]).returns(T::Boolean) }
@@ -37,6 +51,18 @@ module Mpp
 
         available
       end
+
+      # Currencies to fan out into one offer each, in order. Returns nil when
+      # the offer needs no fan-out: the method accepts at most one currency or
+      # the request already pins a currency.
+      sig { params(method: T.untyped, options: T::Hash[T.untyped, T.untyped]).returns(T.nilable(T::Array[String])) }
+      def offer_currencies(method, options)
+        return nil unless options[:currency].nil? && options["currency"].nil?
+        return nil unless method.respond_to?(:currencies)
+
+        currencies = method.currencies
+        (currencies.is_a?(Array) && currencies.length > 1) ? currencies : nil
+      end
     end
   end
 end

data/lib/mpp/server/mpp_handler.rb

@@ -130,9 +130,10 @@ module Mpp
 
       # Handle a charge intent.
       #
-      # With a single registered charge method this returns Challenge or
-      # [Credential, Receipt]. With multiple charge methods it implicitly
-      # composes them and returns a ComposedResult.
+      # With a single registered charge method offering a single currency this
+      # returns Challenge or [Credential, Receipt]. With multiple charge methods,
+      # or a method accepting several currencies, it implicitly composes one
+      # offer per method and currency and returns a ComposedResult.
       sig { params(authorization: T.nilable(String), amount: String, kwargs: T.untyped).returns(T.untyped) }
       def charge(authorization, amount, **kwargs)
         charge_methods = @methods.select { |candidate| candidate.intents.key?("charge") }
@@ -142,7 +143,7 @@ module Mpp
         offer_opts = kwargs.except(*REQUEST_OPTION_KEYS)
         payment = payment_credential_value(authorization, request_opts[:payment_authorization])
 
-        if charge_methods.length == 1
+        if charge_methods.length == 1 && MethodHelper.offer_currencies(charge_methods.first, offer_opts).nil?
           return charge_one(
             charge_methods.first,
             payment,
@@ -176,6 +177,7 @@ module Mpp
         url = kwargs[:url]
         payment_signature = kwargs[:payment_signature]
         offer_opts = kwargs.except(*REQUEST_OPTION_KEYS)
+        intent, offer_opts = Mpp::Server::MethodHelper.prepare_intent(method, intent, offer_opts)
         request = build_charge_request(method, amount, **offer_opts)
         return nil if request_guard && !request_guard.call(request)
 
@@ -215,7 +217,6 @@ module Mpp
         currency = kwargs[:currency]
         recipient = kwargs[:recipient]
         external_id = kwargs[:external_id]
-        memo = kwargs[:memo]
         fee_payer = if kwargs.key?(:fee_payer)
           kwargs[:fee_payer]
         else
@@ -225,7 +226,7 @@ module Mpp
         extra = kwargs[:extra]
         mppx_scope = kwargs[:mppx_scope]
 
-        resolved_currency = currency || (method.respond_to?(:currency) ? method.currency : nil)
+        resolved_currency = currency || primary_currency(method)
         resolved_recipient = recipient || (method.respond_to?(:recipient) ? method.recipient : nil)
         raise ArgumentError, "currency must be set on the method or passed to charge()" unless resolved_currency
         raise ArgumentError, "recipient must be set on the method or passed to charge()" unless resolved_recipient
@@ -256,10 +257,9 @@ module Mpp
         resolved_chain_id = chain_id
         resolved_chain_id ||= method.chain_id if method.respond_to?(:chain_id)
 
-        if memo || fee_payer || !resolved_chain_id.nil?
+        if fee_payer || !resolved_chain_id.nil?
           method_details = {}
           method_details["chainId"] = resolved_chain_id unless resolved_chain_id.nil?
-          method_details["memo"] = memo if memo
           method_details["feePayer"] = true if fee_payer
           request["methodDetails"] = method_details
         end
@@ -296,6 +296,15 @@ module Mpp
         list
       end
 
+      # A method's first accepted currency, else its singular currency.
+      sig { params(method: T.untyped).returns(T.untyped) }
+      def primary_currency(method)
+        currencies = method.respond_to?(:currencies) ? method.currencies : nil
+        return currencies.first if currencies.is_a?(Array) && !currencies.empty?
+
+        method.respond_to?(:currency) ? method.currency : nil
+      end
+
       sig { params(key: String).returns(T.untyped) }
       def resolve_method_key(key)
         name, intent = key.split("/", 2)
@@ -346,7 +355,7 @@ module Mpp
             body: body,
             http_method: http_method
           )
-          receipt = intent.verify(credential, challenge.request)
+          receipt = IntentLifecycle.call(intent, credential, challenge.request)
         rescue => error
           if @events.has_handlers?(Mpp::Events::PAYMENT_FAILED)
             Verify.emit_payment_failed(
@@ -359,6 +368,9 @@ module Mpp
               retry_challenge: challenge
             )
           end
+          if error.is_a?(Mpp::PaymentError) && error.status != 402
+            raise
+          end
           if error.is_a?(Mpp::ParseError) || error.is_a?(Mpp::VerificationError) || error.is_a?(Mpp::PaymentError)
             if @events.has_handlers?(Mpp::Events::CHALLENGE_CREATED)
               Verify.emit_challenge_created(

data/lib/mpp/server/verify.rb

@@ -158,7 +158,7 @@ module Mpp
         end
 
         begin
-          receipt = intent.verify(credential, request)
+          receipt = IntentLifecycle.call(intent, credential, request)
         rescue => e
           if dispatcher&.has_handlers?(Mpp::Events::PAYMENT_FAILED)
             emit_payment_failed(

data/lib/mpp/server.rb

@@ -6,6 +6,7 @@ module Mpp
     autoload :Defaults, "mpp/server/defaults"
     autoload :Intent, "mpp/server/intent"
     autoload :FunctionalIntent, "mpp/server/intent"
+    autoload :IntentLifecycle, "mpp/server/intent_lifecycle"
     autoload :Method, "mpp/server/method"
     autoload :Verify, "mpp/server/verify"
     autoload :MppHandler, "mpp/server/mpp_handler"

data/lib/mpp/validation.rb

@@ -0,0 +1,27 @@
+# typed: true
+# frozen_string_literal: true
+
+module Mpp
+  # Non-mutating validation result, matching mppx's Method.Validation fields.
+  # Details are method-specific, not a receipt or a guarantee of settlement.
+  # Challenge issuance and route binding are checked by the server, not by
+  # constructing this record or calling a rail's validate method directly.
+  Validation = Data.define(:challenge, :credential, :intent, :method, :request, :details, :source) do
+    extend T::Sig
+
+    sig do
+      params(
+        challenge: Mpp::ChallengeEcho,
+        credential: Mpp::Credential,
+        intent: String,
+        method: String,
+        request: T::Hash[String, T.untyped],
+        details: T.untyped,
+        source: T.nilable(String)
+      ).void
+    end
+    def initialize(challenge:, credential:, intent:, method:, request:, details:, source: nil)
+      super
+    end
+  end
+end

data/lib/mpp/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Mpp
-  VERSION = "0.1.6"
+  VERSION = "0.1.7"
 end

data/lib/mpp.rb

@@ -18,6 +18,7 @@ module Mpp
   autoload :ChallengeEcho, "mpp/challenge_echo"
   autoload :Credential, "mpp/credential"
   autoload :Receipt, "mpp/receipt"
+  autoload :Validation, "mpp/validation"
   autoload :Parsing, "mpp/parsing"
   autoload :Json, "mpp/json"
   autoload :BodyDigest, "mpp/body_digest"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mpp-rb
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Stripe
@@ -87,11 +87,14 @@ files:
 - lib/mpp/methods/evm/charge_intent.rb
 - lib/mpp/methods/evm/evm_method.rb
 - lib/mpp/methods/stripe.rb
+- lib/mpp/methods/stripe/analytics_metadata.rb
 - lib/mpp/methods/stripe/charge_intent.rb
 - lib/mpp/methods/stripe/client_method.rb
 - lib/mpp/methods/stripe/crypto_payment_recorder.rb
 - lib/mpp/methods/stripe/defaults.rb
 - lib/mpp/methods/stripe/machine_payments.rb
+- lib/mpp/methods/stripe/payment_intent_method.rb
+- lib/mpp/methods/stripe/payment_intent_options.rb
 - lib/mpp/methods/stripe/stripe_method.rb
 - lib/mpp/methods/tempo.rb
 - lib/mpp/methods/tempo/account.rb
@@ -117,6 +120,7 @@ files:
 - lib/mpp/server/decorator.rb
 - lib/mpp/server/defaults.rb
 - lib/mpp/server/intent.rb
+- lib/mpp/server/intent_lifecycle.rb
 - lib/mpp/server/method.rb
 - lib/mpp/server/middleware.rb
 - lib/mpp/server/mpp_handler.rb
@@ -124,6 +128,7 @@ files:
 - lib/mpp/server/verify.rb
 - lib/mpp/store.rb
 - lib/mpp/units.rb
+- lib/mpp/validation.rb
 - lib/mpp/version.rb
 - lib/mpp/x402.rb
 - lib/mpp/x402/facilitator.rb