mpp-rb 0.1.5 → 0.1.7

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

@@ -0,0 +1,92 @@
+# typed: false
+# frozen_string_literal: true
+
+module Mpp
+  module Methods
+    module Stripe
+      # Records an already-settled crypto transfer as a Stripe PaymentIntent.
+      class CryptoPaymentRecorder
+        RAW_UNITS_PER_CENT = 10_000
+
+        def initialize(client:, network:, metadata: nil)
+          @client = client
+          @network = network
+          @metadata = metadata
+        end
+
+        def call(payload)
+          reference = payload[:receipt]&.reference
+          return unless reference.is_a?(String)
+
+          amount = Integer(payload.fetch(:request).fetch("amount"))
+          cents = (amount + (RAW_UNITS_PER_CENT / 2)) / RAW_UNITS_PER_CENT
+          return if cents < 1
+
+          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,
+            payment_method_data: {type: "crypto"},
+            payment_method_types: ["crypto"],
+            payment_method_options: {
+              crypto: {
+                mode: "transaction_verification",
+                transaction_verification_options: {network: @network, transaction_hash: reference}
+              }
+            },
+            metadata: analytics
+          }
+          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
+
+          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
+end

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

@@ -6,6 +6,7 @@ module Mpp
     module Stripe
       module Defaults
         STRIPE_API_BASE = "https://api.stripe.com"
+        MACHINE_PAYMENTS_API_VERSION = "2026-07-29.preview"
         DEFAULT_CURRENCY = "usd"
         DEFAULT_DECIMALS = 2
       end

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

@@ -0,0 +1,128 @@
+# typed: false
+# frozen_string_literal: true
+
+module Mpp
+  module Methods
+    module Stripe
+      # Configures Stripe-backed MPP methods with static deposit addresses.
+      class MachinePayments
+        SPT_MINIMUM_MINOR_UNITS = 50
+
+        attr_reader :spt, :tempo, :base
+
+        def initialize(network_id:, livemode:, client:, deposit_addresses: nil, metadata: nil)
+          raise ArgumentError, "client must respond to #v1" unless client.respond_to?(:v1)
+
+          addresses = normalize_deposit_addresses(deposit_addresses)
+          @spt = SptFactory.new(network_id: network_id, client: client, metadata: metadata)
+          @tempo = TempoFactory.new(livemode: livemode, client: client, recipient: addresses[:tempo], metadata: metadata)
+          @base = BaseFactory.new(livemode: livemode, client: client, recipient: addresses[:base], metadata: metadata)
+        end
+
+        # Tempo is preferred when configured; Base requires an explicit facilitator.
+        def default_methods
+          methods = [spt.charge]
+          methods.unshift(tempo.charge) if tempo.configured?
+          methods
+        end
+
+        def self.minimum_amount(minimum)
+          lambda do |request|
+            Integer(request.fetch("amount")) >= minimum
+          rescue ArgumentError, TypeError, KeyError
+            false
+          end
+        end
+
+        private
+
+        def normalize_deposit_addresses(deposit_addresses)
+          return {} if deposit_addresses.nil?
+          raise ArgumentError, "deposit_addresses must be a Hash" unless deposit_addresses.is_a?(Hash)
+
+          deposit_addresses.each_with_object({}) do |(network, address), result|
+            unless [:tempo, :base].include?(network)
+              raise ArgumentError, "unsupported deposit address network: #{network}"
+            end
+            unless address.is_a?(String) && address.match?(/\A0x[0-9a-fA-F]{40}\z/)
+              raise ArgumentError, "deposit_addresses[:#{network}] must be a 0x-prefixed 40-hex-character address"
+            end
+
+            result[network] = address.dup.freeze
+          end
+        end
+      end
+
+      class SptFactory
+        def initialize(network_id:, client:, metadata:)
+          @network_id = network_id
+          @client = client
+          @metadata = metadata
+        end
+
+        def charge
+          method = Mpp::Methods::Stripe::StripeMethod.new(
+            secret_key: nil,
+            network_id: @network_id,
+            payment_methods: ["card", "link"],
+            metadata: @metadata,
+            can_offer: MachinePayments.minimum_amount(MachinePayments::SPT_MINIMUM_MINOR_UNITS)
+          )
+          method.intents = {"charge" => Mpp::Methods::Stripe::ChargeIntent.new(secret_key: nil, client: @client)}
+          method
+        end
+      end
+
+      class TempoFactory
+        def initialize(livemode:, client:, recipient:, metadata:)
+          @livemode = livemode
+          @client = client
+          @recipient = recipient
+          @metadata = metadata
+        end
+
+        def configured?
+          !@recipient.nil?
+        end
+
+        def charge
+          raise ArgumentError, "deposit_addresses[:tempo] is required for Tempo payments" unless configured?
+
+          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
+          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)
+          )
+          PaymentIntentMethod.new(method: method, client: @client, network: "tempo", metadata: @metadata)
+        end
+      end
+
+      class BaseFactory
+        def initialize(livemode:, client:, recipient:, metadata:)
+          @livemode = livemode
+          @client = client
+          @recipient = recipient
+          @metadata = metadata
+        end
+
+        def charge(x402:)
+          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
+          method = Mpp::Methods::Evm.charge(
+            currency: currency,
+            recipient: @recipient,
+            x402: x402,
+            can_offer: MachinePayments.minimum_amount(CryptoPaymentRecorder::RAW_UNITS_PER_CENT)
+          )
+          PaymentIntentMethod.new(method: method, client: @client, network: "base", metadata: @metadata)
+        end
+      end
+    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

@@ -9,17 +9,24 @@ module Mpp
       # Stripe payment method implementation.
       # Handles SPT-based payments through Stripe's Business Network.
       class StripeMethod
-        attr_reader :name, :currency, :recipient, :decimals
+        attr_reader :name, :currency, :recipient, :decimals, :on_payment_success
         attr_accessor :intents
 
         def initialize(secret_key:, network_id:, payment_methods: nil,
           metadata: nil, currency: Defaults::DEFAULT_CURRENCY,
-          decimals: Defaults::DEFAULT_DECIMALS, external_id: nil)
+          decimals: Defaults::DEFAULT_DECIMALS, external_id: nil,
+          on_payment_success: nil, can_offer: nil)
           unless payment_methods.is_a?(Array) &&
               payment_methods.any? &&
               payment_methods.all? { |type| type.is_a?(String) && !type.strip.empty? }
             raise ArgumentError, "payment_methods must be a non-empty array of Stripe payment method type strings"
           end
+          unless on_payment_success.nil? || on_payment_success.respond_to?(:call)
+            raise ArgumentError, "on_payment_success must be callable"
+          end
+          unless can_offer.nil? || can_offer.respond_to?(:call)
+            raise ArgumentError, "can_offer must be callable"
+          end
 
           @name = "stripe"
           @secret_key = secret_key
@@ -27,12 +34,28 @@ module Mpp
           @payment_methods = payment_methods
           @metadata = metadata
           @external_id = external_id
+          @on_payment_success = on_payment_success
+          @can_offer = can_offer
           @currency = currency
           @recipient = network_id
           @decimals = decimals
           @intents = {}
         end
 
+        def can_offer?(request)
+          return true unless @can_offer
+
+          @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", {})
@@ -53,6 +76,8 @@ module Mpp
         metadata: nil, currency: Defaults::DEFAULT_CURRENCY,
         decimals: Defaults::DEFAULT_DECIMALS,
         external_id: nil,
+        on_payment_success: nil,
+        can_offer: nil,
         api_base: Defaults::STRIPE_API_BASE)
         charge_intent = ChargeIntent.new(secret_key: secret_key, api_base: api_base)
 
@@ -63,7 +88,9 @@ module Mpp
           metadata: metadata,
           currency: currency,
           decimals: decimals,
-          external_id: external_id
+          external_id: external_id,
+          on_payment_success: on_payment_success,
+          can_offer: can_offer
         )
 
         method.intents = {"charge" => charge_intent}

data/lib/mpp/methods/stripe.rb

@@ -4,11 +4,37 @@
 module Mpp
   module Methods
     module Stripe
+      extend T::Sig
+
       autoload :Defaults, "mpp/methods/stripe/defaults"
       # Eagerly require stripe_method so the Stripe.stripe factory method is available
       require_relative "stripe/stripe_method"
       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(
+          network_id: String,
+          livemode: T::Boolean,
+          client: T.untyped,
+          deposit_addresses: T.untyped,
+          metadata: T.untyped
+        ).returns(MachinePayments)
+      end
+      def self.create(network_id:, livemode:, client:, deposit_addresses: nil, metadata: nil)
+        MachinePayments.new(
+          network_id: network_id,
+          livemode: livemode,
+          client: client,
+          deposit_addresses: deposit_addresses,
+          metadata: metadata
+        )
+      end
     end
   end
 end

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

@@ -18,32 +18,50 @@ module Mpp
       # Handles client-side credential creation for Tempo payments.
       class TempoMethod
         attr_reader :name, :account, :fee_payer, :fee_payer_allowed_fee_tokens,
-          :root_account, :rpc_url, :chain_id, :currency, :recipient, :decimals, :client_id,
-          :expected_recipients, :relay
+          :root_account, :rpc_url, :chain_id, :currency, :currencies, :recipient, :decimals, :client_id,
+          :expected_recipients, :relay, :on_payment_success, :fee_token
         attr_accessor :intents
 
         def initialize(account: nil, fee_payer: nil, root_account: nil,
           rpc_url: Defaults::RPC_URL, chain_id: nil, currency: nil,
           recipient: nil, decimals: 6, client_id: nil,
           expected_recipients: nil, fee_payer_allowed_fee_tokens: nil,
-          relay: nil)
+          relay: nil, on_payment_success: nil, can_offer: nil, currencies: nil, fee_token: nil)
+          unless 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 = "tempo"
           @account = account
           @fee_payer = fee_payer
           @relay = relay
+          @fee_token = fee_token
           @fee_payer_allowed_fee_tokens =
             fee_payer_allowed_fee_tokens&.map { |token| token.to_s.downcase }
           @root_account = root_account
           @rpc_url = rpc_url
           @chain_id = chain_id
-          @currency = currency
+          # Ordered currencies offered by a server; the first is the primary.
+          @currencies = (currencies || [currency].compact).dup.freeze
+          @currency = currency || @currencies.first
           @recipient = recipient
           @decimals = decimals
           @client_id = client_id
           @expected_recipients = expected_recipients&.map(&:downcase)&.to_set
+          @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
+
         # Create a credential to satisfy the given challenge.
         #
         # mode: :pull (default) — return signed transaction for server to broadcast
@@ -67,8 +85,7 @@ module Mpp
             nonce_key = nonce_key.start_with?("0x") ? nonce_key.to_i(16) : nonce_key.to_i
           end
 
-          memo = method_details["memo"]
-          memo ||= Attribution.encode(server_id: challenge.realm, client_id: @client_id, challenge_id: challenge.id)
+          memo = Attribution.encode(server_id: challenge.realm, client_id: @client_id, challenge_id: challenge.id)
 
           # Resolve RPC URL from challenge's chainId. Normalize the configured pin
           # once (it may be a String from ENV/config) so it compares equal to
@@ -249,31 +266,60 @@ module Mpp
       end
 
       # Factory function to create a configured TempoMethod.
-      def self.tempo(intents:, account: nil, fee_payer: nil, chain_id: nil, rpc_url: nil,
+      #
+      # A server offers one charge per accepted currency, in order. Without
+      # `currencies:` it offers OUSD then USDC.e on mainnet and OUSD then
+      # pathUSD on Moderato; other chains keep their single default.
+      # `currencies:` replaces the defaults. The deprecated `currency:` accepts
+      # exactly that token. `currency` keeps its previous default for clients.
+      #
+      # A local fee payer pays gas in `fee_token:` when set, else in the first
+      # allowed fee token it holds, independent of the charge currency.
+      def self.tempo(intents:, account: nil, fee_payer: nil, chain_id: Defaults::CHAIN_ID, rpc_url: nil,
         root_account: nil, currency: nil, recipient: nil, decimals: 6, client_id: nil,
-        expected_recipients: nil, fee_payer_allowed_fee_tokens: nil, relay: nil)
+        expected_recipients: nil, fee_payer_allowed_fee_tokens: nil, relay: nil,
+        on_payment_success: nil, can_offer: nil, currencies: nil, fee_token: nil)
         rpc_url ||= chain_id ? Defaults.rpc_url_for_chain(chain_id) : Defaults::RPC_URL
-        currency ||= Defaults.default_currency_for_chain(chain_id)
 
         if fee_payer == true
           raise ArgumentError, "fee_payer: true requires account:" unless account
 
           fee_payer = account
         end
+        fee_payer = FeePayerClient.resolve_optional(fee_payer)
+        if fee_token && (fee_payer.nil? || FeePayerClient.hosted_config?(fee_payer))
+          raise ArgumentError, "fee_token can only be configured for a local fee payer"
+        end
+
+        if fee_token && !Defaults::ADDRESS_PATTERN.match?(fee_token)
+          raise ArgumentError, "Invalid Tempo fee token address: #{fee_token.inspect}"
+        end
+        if fee_payer_allowed_fee_tokens&.empty?
+          raise ArgumentError, "fee_payer_allowed_fee_tokens must contain at least one token"
+        end
+
+        legacy_currency = Defaults.default_currency_for_chain(chain_id)
+        primary_currency = currency || currencies&.first || legacy_currency
+        # `currency:` is deprecated in favor of `currencies: [currency]`.
+        currencies = Defaults.accepted_currencies(chain_id: chain_id, currency: currency, currencies: currencies)
 
         method = TempoMethod.new(
           account: account,
-          fee_payer: FeePayerClient.resolve_optional(fee_payer),
+          fee_payer: fee_payer,
           rpc_url: rpc_url,
           chain_id: chain_id,
           root_account: root_account,
-          currency: currency,
+          currency: primary_currency,
+          currencies: currencies,
           recipient: recipient,
           decimals: decimals,
           client_id: client_id,
           expected_recipients: expected_recipients,
           fee_payer_allowed_fee_tokens: fee_payer_allowed_fee_tokens,
-          relay: Relay.resolve_optional(relay)
+          relay: Relay.resolve_optional(relay),
+          on_payment_success: on_payment_success,
+          can_offer: can_offer,
+          fee_token: fee_token
         )
 
         intents.each_value do |intent|