mpp-rb 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c38b87554f2c1cbef8acfb7d2ba2197b14140500e52bff79276602c76051f8ed
-  data.tar.gz: c11b04aef7e116a9b298e3b4b4286dfc4194348b6bd2aca60b1d3f235911ac25
+  metadata.gz: d028d7ba9d07e95173c4d3618a688dd87d4674284195a58ecfa4d6d43a311bf7
+  data.tar.gz: 3a342589c1478477c42077297f11244550ce035e4d66f9e4afde2e9a125d091c
 SHA512:
-  metadata.gz: 795895e5b9b8a768d96468c7f34b468b9a205e694c2b212dc1fca00ecfd2e5906c95ec95455ac79432f1ba95b21a91ba31cd71ccecbb1dbc1226a3cf274ccbf8
-  data.tar.gz: 81855362a29e248846445b3cebb0a1bce2a4f2cc2164c49e462ac923ade2fc1d30ef527786579313ffe270d02c89ec8b32a0dd0c09a74403bc69820de112ee10
+  metadata.gz: bf7ad2c6e7db109dc6244609e24eaf42f444396f0df9a69dd428017635dca2abb001271d89cd6c1e715fa3c58bf352ee267455ea0e38623cfd6dc608cd2da609
+  data.tar.gz: 6f090b293910e66a99054316767d36913a1a258c9ae5e1989fd74b16f67c8bad236b2e5351f6c4582140f5f48a0f707f2395245196470ec4c2206b0fb41418ad

data/README.md

@@ -49,6 +49,18 @@ else
 end
 ```
 
+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 +74,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 +88,46 @@ 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.
+
 `evm.charge` additionally emits `PAYMENT-REQUIRED` and accepts `PAYMENT-SIGNATURE` (x402 v2 exact) when a facilitator is configured:
 
 ```ruby
@@ -152,6 +205,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/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/charge_intent.rb

@@ -61,10 +61,8 @@ 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
+          metadata = method_details["metadata"].is_a?(Hash) ? method_details["metadata"].transform_values(&:to_s) : {}
+          params[:metadata] = metadata.merge("machine_payment" => "true")
 
           unless @client
             begin
@@ -78,15 +76,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
 

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

@@ -0,0 +1,55 @@
+# typed: false
+# frozen_string_literal: true
+
+module Mpp
+  module Methods
+    module Stripe
+      # Records an already-verified 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
+
+          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 = @metadata.is_a?(Hash) ? @metadata.transform_values(&:to_s) : {}
+          params[:metadata] = metadata.merge("machine_payment" => "true")
+
+          @client.v1.payment_intents.create(
+            params,
+            {stripe_version: Defaults::MACHINE_PAYMENTS_API_VERSION, idempotency_key: reference}
+          )
+        rescue => error
+          Kernel.warn(
+            "[stripe] failed to record crypto payment " \
+              "network=#{@network.inspect} transaction_hash=#{reference.inspect}: #{error.class}: #{error.message}"
+          )
+          nil
+        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,130 @@
+# 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
+          recorder = CryptoPaymentRecorder.new(client: @client, network: "tempo", metadata: @metadata)
+          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) }
+          )
+        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
+          recorder = CryptoPaymentRecorder.new(client: @client, network: "base", metadata: @metadata)
+          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) }
+          )
+        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,20 @@ 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
+
         # Transform request - injects Stripe-specific methodDetails.
         def transform_request(request, _credential)
           method_details = request.fetch("methodDetails", {})
@@ -53,6 +68,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 +80,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,34 @@
 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 :MachinePayments, "mpp/methods/stripe/machine_payments"
+
+      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