mpp-rb 0.1.4 → 0.1.6

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

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

@@ -1,7 +1,7 @@
 # typed: false
 # frozen_string_literal: true
 
-require "openssl"
+require "digest/keccak"
 require "securerandom"
 
 module Mpp
@@ -13,15 +13,9 @@ module Mpp
 
         module_function
 
-        # Compute keccak256 hash. Uses OpenSSL if available, otherwise pure Ruby.
+        # Ethereum Keccak-256. SHA3-256 is not a substitute (different padding).
         def keccak256(data)
-          # Try eth gem's keccak first
-          Kernel.require "eth"
-          Eth::Util.keccak256(data)
-        rescue LoadError
-          # Fallback: use OpenSSL's SHA3-256 (not exactly keccak, but close)
-          # For production, the eth gem should be installed
-          OpenSSL::Digest.new("SHA3-256").digest(data)
+          Digest::Keccak.digest(data, 256)
         end
 
         # Compute TAG = keccak256("mpp")[0:4]

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

@@ -19,16 +19,25 @@ module Mpp
       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
+          :expected_recipients, :relay, :on_payment_success
         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)
+          expected_recipients: nil, fee_payer_allowed_fee_tokens: nil,
+          relay: nil, on_payment_success: nil, can_offer: 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_payer_allowed_fee_tokens =
             fee_payer_allowed_fee_tokens&.map { |token| token.to_s.downcase }
           @root_account = root_account
@@ -39,9 +48,17 @@ module Mpp
           @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
@@ -249,13 +266,20 @@ module Mpp
       # Factory function to create a configured TempoMethod.
       def self.tempo(intents:, account: nil, fee_payer: nil, chain_id: nil, rpc_url: nil,
         root_account: nil, currency: nil, recipient: nil, decimals: 6, client_id: nil,
-        expected_recipients: nil, fee_payer_allowed_fee_tokens: nil)
+        expected_recipients: nil, fee_payer_allowed_fee_tokens: nil, relay: nil,
+        on_payment_success: nil, can_offer: 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
+
         method = TempoMethod.new(
           account: account,
-          fee_payer: fee_payer,
+          fee_payer: FeePayerClient.resolve_optional(fee_payer),
           rpc_url: rpc_url,
           chain_id: chain_id,
           root_account: root_account,
@@ -264,12 +288,17 @@ module Mpp
           decimals: decimals,
           client_id: client_id,
           expected_recipients: expected_recipients,
-          fee_payer_allowed_fee_tokens: fee_payer_allowed_fee_tokens
+          fee_payer_allowed_fee_tokens: fee_payer_allowed_fee_tokens,
+          relay: Relay.resolve_optional(relay),
+          on_payment_success: on_payment_success,
+          can_offer: can_offer
         )
 
         intents.each_value do |intent|
           intent.rpc_url = rpc_url if intent.respond_to?(:rpc_url=) && intent.rpc_url.nil?
-          intent.instance_variable_set(:@_method, method) if intent.respond_to?(:fee_payer)
+          if intent.respond_to?(:fee_payer) || intent.respond_to?(:relay)
+            intent.instance_variable_set(:@_method, method)
+          end
         end
         method.intents = intents.dup
         method

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

@@ -0,0 +1,120 @@
+# typed: false
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+require_relative "../../http/headers"
+
+module Mpp
+  module Methods
+    module Tempo
+      # HTTP client for a hosted Tempo fee-payer JSON-RPC endpoint.
+      #
+      # `resolve` accepts:
+      #   * a URL string (public / unauthenticated sponsor)
+      #   * a config hash (`url:` plus optional `headers:` as a Hash or per-request proc)
+      #   * any object that responds to `#cosign`
+      class FeePayerClient
+        SIGN_METHOD = "eth_signRawTransaction"
+        DEFAULT_TIMEOUT = Rpc::DEFAULT_TIMEOUT
+
+        attr_reader :base_url
+
+        def initialize(url, headers: nil)
+          @base_url = Mpp::Http::Headers.normalize_base_url(url)
+          raise ArgumentError, "fee_payer url is required" if @base_url.empty?
+
+          @headers = headers
+        end
+
+        def self.resolve_optional(fee_payer)
+          return if fee_payer.nil? || fee_payer == false
+          return fee_payer unless hosted_config?(fee_payer)
+
+          resolve(fee_payer)
+        end
+
+        def self.resolve(fee_payer)
+          return fee_payer if fee_payer.is_a?(FeePayerClient)
+          return new(fee_payer) if fee_payer.is_a?(String) && !fee_payer.empty?
+          return from_config(fee_payer) if fee_payer.is_a?(Hash)
+          return fee_payer if duck_type?(fee_payer)
+
+          raise ArgumentError, "fee_payer must be an Account, URL, {url:, headers:}, or an object that implements #cosign"
+        end
+
+        def self.from_config(config)
+          cfg = Mpp::Http::Headers.symbolize(config)
+          url = cfg[:url] || cfg[:base_url] || cfg[:baseUrl]
+          new(url.to_s, headers: cfg[:headers])
+        end
+
+        def self.hosted_config?(fee_payer)
+          return true if fee_payer.is_a?(FeePayerClient)
+          return true if fee_payer.is_a?(String)
+          return true if fee_payer.is_a?(Hash)
+          return true if duck_type?(fee_payer) && !fee_payer.respond_to?(:sign_hash)
+
+          false
+        end
+
+        def self.duck_type?(fee_payer)
+          !fee_payer.nil? && fee_payer.respond_to?(:cosign)
+        end
+
+        def cosign(raw_tx)
+          result = post_rpc(SIGN_METHOD, [raw_tx])
+          unless result.is_a?(String) && !result.empty?
+            raise Mpp::VerificationFailedError.new(reason: "Fee payer returned no signed transaction")
+          end
+
+          result
+        end
+
+        private
+
+        def post_rpc(method, params)
+          uri = URI.parse(@base_url)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = uri.scheme == "https"
+          http.read_timeout = DEFAULT_TIMEOUT
+
+          request = Net::HTTP::Post.new(uri)
+          request["Content-Type"] = "application/json"
+          Mpp::Http::Headers.resolve(@headers, "/#{method}").each { |key, value| request[key] = value }
+          request.body = JSON.generate({
+            "jsonrpc" => "2.0",
+            "method" => method,
+            "params" => params,
+            "id" => 1
+          })
+
+          response = http.request(request)
+          unless response.is_a?(Net::HTTPSuccess)
+            raise Mpp::VerificationFailedError.new(reason: "fee payer returned HTTP #{response.code}")
+          end
+
+          body = response.body.to_s
+          if body.empty?
+            raise Mpp::VerificationFailedError.new(reason: "fee payer returned an empty body")
+          end
+
+          parsed = JSON.parse(body)
+          unless parsed.is_a?(Hash)
+            raise Mpp::VerificationFailedError.new(reason: "fee payer returned JSON that is not an object")
+          end
+          if parsed.key?("error")
+            raise Mpp::VerificationFailedError.new(reason: "fee payer RPC error: #{parsed["error"]}")
+          end
+
+          parsed["result"]
+        rescue JSON::ParserError
+          raise Mpp::VerificationFailedError.new(reason: "fee payer returned invalid JSON")
+        rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ETIMEDOUT, Net::OpenTimeout, Net::ReadTimeout, SocketError => e
+          raise Mpp::VerificationFailedError.new(reason: "fee payer request failed: #{e.message}")
+        end
+      end
+    end
+  end
+end