mpp-rb 0.1.5 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c38b87554f2c1cbef8acfb7d2ba2197b14140500e52bff79276602c76051f8ed
-  data.tar.gz: c11b04aef7e116a9b298e3b4b4286dfc4194348b6bd2aca60b1d3f235911ac25
+  metadata.gz: 04e4e82ccc2c911599a59b725c6e57baf05244119b60fc53c8d04fe2973c55ec
+  data.tar.gz: 298544b059706fa7de2b2845f93d3e7e061dd6c9a7cf2e27aae9a485418bf2ac
 SHA512:
-  metadata.gz: 795895e5b9b8a768d96468c7f34b468b9a205e694c2b212dc1fca00ecfd2e5906c95ec95455ac79432f1ba95b21a91ba31cd71ccecbb1dbc1226a3cf274ccbf8
-  data.tar.gz: 81855362a29e248846445b3cebb0a1bce2a4f2cc2164c49e462ac923ade2fc1d30ef527786579313ffe270d02c89ec8b32a0dd0c09a74403bc69820de112ee10
+  metadata.gz: e387986b40d742b24fa10c2b6dc455d157ffa325b7bb33efe53b7ab2e2742cbf97840fbb663c652611bf7255c8ea46e6d525458e825529138f4e18437510c9d2
+  data.tar.gz: 9879963916f463a68568bcb0b7e219d12402a4344db77d324ba877ded2e95bf2110826aa9cff7cb02328f1dbd9e3905b9a7c3d43787159c8bb568a371017a1e7

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,46 @@ 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
+server = Mpp.create(method: tempo, requires_auth: true)
+
+result = server.charge(
+  env["HTTP_AUTHORIZATION"],
+  "0.50",
+  payment_authorization: env["HTTP_PAYMENT_AUTHORIZATION"],
+)
+```
+
 ### Multiple methods
 
 ```ruby
@@ -62,6 +106,7 @@ paid = server.compose(
 
 result = paid.call(
   authorization: env["HTTP_AUTHORIZATION"],
+  payment_authorization: env["HTTP_PAYMENT_AUTHORIZATION"],
   payment_signature: env["HTTP_PAYMENT_SIGNATURE"],
   accept_payment: env["HTTP_ACCEPT_PAYMENT"],
   url: request.url,
@@ -75,6 +120,99 @@ else
 end
 ```
 
+### Stripe machine payments
+
+`Mpp::Methods::Stripe.create` configures Stripe Payment Tokens and static
+crypto deposit addresses from an injected Stripe client. Add the `stripe` gem
+to your application, then configure the methods:
+
+```ruby
+require "stripe"
+
+stripe_client = Stripe::StripeClient.new(ENV.fetch("STRIPE_SECRET_KEY"))
+payments = Mpp::Methods::Stripe.create(
+  client: stripe_client,
+  network_id: ENV.fetch("STRIPE_NETWORK_ID"),
+  livemode: false,
+  deposit_addresses: {
+    tempo: ENV.fetch("TEMPO_DEPOSIT_ADDRESS"),
+    base: ENV.fetch("BASE_DEPOSIT_ADDRESS")
+  },
+  metadata: {"product" => "example"}
+)
+
+server = Mpp.create(methods: payments.default_methods)
+```
+
+With no deposit addresses, defaults are Stripe Payment Tokens only.
+`default_methods` adds Tempo when its static address is configured. Add Base
+explicitly with its x402 facilitator:
+
+```ruby
+base = payments.base.charge(
+  x402: {facilitator: "https://x402.org/facilitator"}
+)
+server = Mpp.create(methods: [*payments.default_methods, base])
+```
+
+When composed, SPT offers below $0.50 and Tempo/Base offers below one cent are
+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
@@ -152,6 +290,18 @@ end
 
 Client events are `challenge.received`, `credential.created`, `payment.response`, and `payment.failed`. Server events are `challenge.created`, `payment.success`, and `payment.failed`.
 
+When a side effect belongs to one payment method, attach it to the method instead. The hook only receives successful payments for that method and intent; an exception in the hook does not invalidate the payment.
+
+```ruby
+method = Mpp::Methods::Tempo.tempo(
+  intents: {"charge" => Mpp::Methods::Tempo::ChargeIntent.new},
+  recipient: "0x0000000000000000000000000000000000000001",
+  on_payment_success: ->(payload) {
+    record_payment(payload[:receipt], payload[:request])
+  },
+)
+```
+
 ### Rack Middleware
 
 ```ruby

data/lib/mpp/challenge.rb

@@ -16,16 +16,30 @@ module Mpp
     :digest,
     :expires,
     :description,
-    :opaque
+    :opaque,
+    :header
   ) do
     def initialize(id:, method:, intent:, request:, realm: "", request_b64: "", digest: nil, expires: nil,
-      description: nil, opaque: nil)
-      super
+      description: nil, opaque: nil, header: nil)
+      super(
+        id: id,
+        method: method,
+        intent: intent,
+        request: request,
+        realm: realm,
+        request_b64: request_b64,
+        digest: digest,
+        expires: expires,
+        description: description,
+        opaque: opaque,
+        header: Mpp.advertised_credential_header(header)
+      )
     end
 
     # Create a Challenge with an HMAC-bound ID.
     def self.create(secret_key:, realm:, method:, intent:, request:, expires: nil, digest: nil, description: nil,
-      meta: nil)
+      meta: nil, header: nil)
+      header = Mpp.advertised_credential_header(header)
       challenge_id = Mpp.generate_challenge_id(
         secret_key: secret_key,
         realm: realm,
@@ -34,7 +48,8 @@ module Mpp
         request: request,
         expires: expires,
         digest: digest,
-        opaque: meta
+        opaque: meta,
+        header: header
       )
       request_json = Mpp::Json.compact_encode(request)
       request_b64 = Mpp.b64url_encode(request_json)
@@ -49,7 +64,8 @@ module Mpp
         digest: digest,
         expires: expires,
         description: description,
-        opaque: meta
+        opaque: meta,
+        header: header
       )
     end
 
@@ -152,6 +168,11 @@ module Mpp
       Mpp::Parsing.format_www_authenticate(self, realm)
     end
 
+    # HTTP field a client must use for the payment credential.
+    def credential_header
+      header || Mpp::AUTHORIZATION_HEADER
+    end
+
     # Verify the challenge ID matches the expected HMAC.
     def verify(secret_key, realm)
       expected_id = Mpp.generate_challenge_id(
@@ -162,7 +183,8 @@ module Mpp
         request: request,
         expires: expires,
         digest: digest,
-        opaque: opaque
+        opaque: opaque,
+        header: header
       )
       Mpp.secure_compare(id, expected_id)
     end
@@ -183,7 +205,8 @@ module Mpp
         request: request_b64,
         expires: expires,
         digest: digest,
-        opaque: opaque_b64
+        opaque: opaque_b64,
+        header: header
       )
     end
   end

data/lib/mpp/challenge_echo.rb

@@ -10,10 +10,21 @@ module Mpp
     :request,
     :expires,
     :digest,
-    :opaque
+    :opaque,
+    :header
   ) do
-    def initialize(id:, realm:, method:, intent:, request:, expires: nil, digest: nil, opaque: nil)
-      super
+    def initialize(id:, realm:, method:, intent:, request:, expires: nil, digest: nil, opaque: nil, header: nil)
+      super(
+        id: id,
+        realm: realm,
+        method: method,
+        intent: intent,
+        request: request,
+        expires: expires,
+        digest: digest,
+        opaque: opaque,
+        header: Mpp.advertised_credential_header(header)
+      )
     end
   end
 end

data/lib/mpp/challenge_id.rb

@@ -9,13 +9,18 @@ module Mpp
 
   module_function
 
+  # RFC 9110 token used as an HTTP field name.
+  HTTP_HEADER_NAME_RE = T.let(/\A[!#$%&'*+.^_`|~0-9A-Za-z-]+\z/, Regexp)
+
   # Generate HMAC-SHA256 challenge ID per spec.
   #
   # HMAC input format: realm|method|intent|request_b64|expires|digest|opaque_b64
-  # All fields always included; absent optional fields use empty string.
+  # Challenges that advertise a credential header insert it immediately before
+  # the final opaque slot. Authorization is the implicit default and is never
+  # included, preserving the legacy binding.
   # Output: base64url(HMAC-SHA256(secret_key, input))
-  sig { params(secret_key: T.untyped, realm: T.untyped, method: T.untyped, intent: T.untyped, request: T.untyped, expires: T.untyped, digest: T.untyped, opaque: T.untyped).returns(String) }
-  def generate_challenge_id(secret_key:, realm:, method:, intent:, request:, expires: nil, digest: nil, opaque: nil)
+  sig { params(secret_key: T.untyped, realm: T.untyped, method: T.untyped, intent: T.untyped, request: T.untyped, expires: T.untyped, digest: T.untyped, opaque: T.untyped, header: T.untyped).returns(String) }
+  def generate_challenge_id(secret_key:, realm:, method:, intent:, request:, expires: nil, digest: nil, opaque: nil, header: nil)
     request_json = Json.compact_encode(request)
     request_b64 = b64url_encode(request_json)
 
@@ -32,14 +37,33 @@ module Mpp
       intent,
       request_b64,
       expires || "",
-      digest || "",
-      opaque_b64
-    ].join("|")
+      digest || ""
+    ]
+    advertised = advertised_credential_header(header)
+    hmac_input << advertised if advertised
+    hmac_input << opaque_b64
+    hmac_input = hmac_input.join("|")
 
     mac = OpenSSL::HMAC.digest("SHA256", secret_key.encode(Encoding::UTF_8), hmac_input.encode(Encoding::UTF_8))
     Base64.urlsafe_encode64(mac, padding: false)
   end
 
+  # True when the credential header is omitted or is the implicit Authorization default.
+  sig { params(header: T.untyped).returns(T::Boolean) }
+  def default_credential_header?(header)
+    header.nil? || header.to_s.empty? || header.to_s.casecmp(AUTHORIZATION_HEADER).zero?
+  end
+
+  # Returns an advertised credential header, or nil for the Authorization default.
+  sig { params(header: T.untyped).returns(T.nilable(String)) }
+  def advertised_credential_header(header)
+    return nil if default_credential_header?(header)
+
+    name = header.to_s
+    Kernel.raise ArgumentError, "Invalid HTTP header name" unless HTTP_HEADER_NAME_RE.match?(name)
+    name
+  end
+
   # Encode string to base64url without padding.
   sig { params(data: T.untyped).returns(String) }
   def b64url_encode(data)

data/lib/mpp/client/transport.rb

@@ -117,7 +117,7 @@ module Mpp
           raise
         end
 
-        retry_headers = headers.merge("Authorization" => auth_header)
+        retry_headers = headers.merge(challenge.credential_header => auth_header)
         payment_response = nil
         begin
           payment_response = send_request(uri, method, retry_headers, body)

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/evm/evm_method.rb

@@ -6,10 +6,18 @@ module Mpp
     module Evm
       # EVM payment method. Speaks native Payment-auth and x402 exact.
       class EvmMethod
-        attr_reader :name, :currency, :recipient, :decimals, :chain_id, :authorization, :x402
+        attr_reader :name, :currency, :recipient, :decimals, :chain_id, :authorization, :x402,
+          :on_payment_success
         attr_accessor :intents
 
-        def initialize(currency:, recipient:, decimals:, chain_id:, authorization:, x402:)
+        def initialize(currency:, recipient:, decimals:, chain_id:, authorization:, x402:, on_payment_success: nil, can_offer: nil)
+          if !on_payment_success.nil? && !on_payment_success.respond_to?(:call)
+            raise ArgumentError, "on_payment_success must be callable"
+          end
+          if !can_offer.nil? && !can_offer.respond_to?(:call)
+            raise ArgumentError, "can_offer must be callable"
+          end
+
           @name = "evm"
           @currency = Authorization.checksum_address(currency)
           @recipient = Authorization.checksum_address(recipient)
@@ -17,9 +25,17 @@ module Mpp
           @chain_id = chain_id
           @authorization = authorization
           @x402 = x402
+          @on_payment_success = on_payment_success
+          @can_offer = can_offer
           @intents = {}
         end
 
+        def can_offer?(request)
+          return true unless @can_offer
+
+          @can_offer.call(request)
+        end
+
         def transform_request(request, _credential)
           method_details = request.fetch("methodDetails", {})
           method_details = {} unless method_details.is_a?(Hash)

data/lib/mpp/methods/evm.rb

@@ -10,7 +10,8 @@ module Mpp
       autoload :EvmMethod, "mpp/methods/evm/evm_method"
 
       # Factory for a server-side EVM charge method with inline x402 exact support.
-      def self.charge(currency:, recipient:, x402:, authorization: nil, chain_id: nil, decimals: nil)
+      def self.charge(currency:, recipient:, x402:, authorization: nil, chain_id: nil, decimals: nil,
+        on_payment_success: nil, can_offer: nil)
         resolved = Assets.resolve(
           currency,
           authorization: authorization,
@@ -32,7 +33,9 @@ module Mpp
           decimals: resolved.fetch(:decimals),
           chain_id: resolved.fetch(:chain_id),
           authorization: resolved.fetch(:authorization),
-          x402: x402_options
+          x402: x402_options,
+          on_payment_success: on_payment_success,
+          can_offer: can_offer
         )
         method.intents = {"charge" => charge_intent}
         method

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,10 +79,14 @@ module Mpp
             payment_method_types: payment_method_types
           }
 
-          # Include metadata from methodDetails if present
-          if method_details["metadata"].is_a?(Hash)
-            params[:metadata] = method_details["metadata"].transform_values(&:to_s)
-          end
+          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] = AnalyticsMetadata.build(credential.challenge)
+            .merge(metadata)
+            .merge(payment_intent_options.fetch(:metadata, {}))
 
           unless @client
             begin
@@ -78,15 +100,16 @@ module Mpp
             client = @client || ::Stripe::StripeClient.new(@secret_key)
             result = client.v1.payment_intents.create(
               params,
-              {idempotency_key: stripe_idempotency_key(credential)}
+              {stripe_version: Defaults::MACHINE_PAYMENTS_API_VERSION, idempotency_key: stripe_idempotency_key(credential)}
             )
           rescue => e
             raise Mpp::VerificationError, e.message
           end
 
           # https://docs.stripe.com/error-low-level#idempotency
-          if result.respond_to?(:last_response) &&
-              result.last_response&.headers&.[]("idempotent-replayed") == "true"
+          last_response = result.last_response if result.respond_to?(:last_response)
+          response_headers = last_response.respond_to?(:http_headers) ? last_response.http_headers : last_response&.headers
+          if response_headers&.[]("idempotent-replayed") == "true"
             raise Mpp::VerificationError, "Payment has already been processed."
           end