mpp-rb 0.1.3 → 0.1.5

data/lib/mpp/methods/evm/evm_method.rb

@@ -0,0 +1,117 @@
+# typed: false
+# frozen_string_literal: true
+
+module Mpp
+  module Methods
+    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_accessor :intents
+
+        def initialize(currency:, recipient:, decimals:, chain_id:, authorization:, x402:)
+          @name = "evm"
+          @currency = Authorization.checksum_address(currency)
+          @recipient = Authorization.checksum_address(recipient)
+          @decimals = decimals
+          @chain_id = chain_id
+          @authorization = authorization
+          @x402 = x402
+          @intents = {}
+        end
+
+        def transform_request(request, _credential)
+          method_details = request.fetch("methodDetails", {})
+          method_details = {} unless method_details.is_a?(Hash)
+
+          method_details["chainId"] = @chain_id
+          method_details["credentialTypes"] = ["authorization"]
+          request.merge("methodDetails" => method_details, "currency" => @currency, "recipient" => @recipient)
+        end
+
+        def payment_requirements(request)
+          charge_intent.payment_requirements(request)
+        end
+
+        def x402_matches?(payload, request)
+          accepted = payload["accepted"]
+          return false unless accepted.is_a?(Hash)
+
+          Mpp::X402::Server.canonical_equal?(accepted, payment_requirements(request))
+        end
+
+        def decorate_challenge(headers, challenge, url: nil, http_method: nil, request: nil)
+          return headers if url.nil? || url.empty?
+
+          requirements = payment_requirements(request || challenge.request)
+          extensions = Mpp::X402::Server.route_extensions(challenge, http_method)
+          body = Mpp::X402::Server.payment_required_body(
+            requirements: requirements,
+            resource_url: url,
+            extensions: extensions,
+            error: "#{Mpp::X402::PAYMENT_SIGNATURE_HEADER} header is required"
+          )
+          headers["PAYMENT-REQUIRED"] = Mpp::X402::Header.encode_payment_required(body)
+          headers
+        end
+
+        def decorate_receipt(headers, receipt, credential, payment_signature: nil)
+          return headers if payment_signature.nil? || payment_signature.empty?
+
+          payload = credential.payload
+          request = decode_request(credential)
+          chain_id = request.dig("methodDetails", "chainId") || @chain_id
+          headers["PAYMENT-RESPONSE"] = Mpp::X402::Header.encode_payment_response({
+            "network" => "eip155:#{chain_id}",
+            "payer" => payload["from"],
+            "success" => true,
+            "transaction" => receipt.reference
+          })
+          headers
+        end
+
+        def bind_x402_credential(payment_signature, challenge:, request:, url:, body:, http_method: nil)
+          payment_payload = Mpp::X402::Header.decode_payment_signature(payment_signature)
+          requirements = payment_requirements(request)
+          authorization = Mpp::X402::Server.bind_credential(
+            payment_payload: payment_payload,
+            requirements: requirements,
+            resource_url: url,
+            challenge: challenge,
+            body: body,
+            route_binding: @x402[:route_binding],
+            http_method: http_method
+          )
+          echo = challenge.to_echo
+          Mpp::Credential.new(
+            challenge: echo,
+            payload: authorization.merge("_x402" => true),
+            source: source_for(authorization["from"])
+          )
+        end
+
+        private
+
+        def charge_intent
+          intent = @intents["charge"]
+          raise ArgumentError, "evm method is missing charge intent" unless intent
+
+          intent
+        end
+
+        def decode_request(credential)
+          echo = credential.challenge
+          return {} if echo.request.nil? || echo.request.empty?
+
+          Mpp::Parsing.b64_decode(echo.request)
+        rescue Mpp::ParseError
+          {}
+        end
+
+        def source_for(address)
+          "did:pkh:eip155:#{@chain_id}:#{Authorization.checksum_address(address)}"
+        end
+      end
+    end
+  end
+end

data/lib/mpp/methods/evm.rb

@@ -0,0 +1,64 @@
+# typed: true
+# frozen_string_literal: true
+
+module Mpp
+  module Methods
+    module Evm
+      autoload :Assets, "mpp/methods/evm/assets"
+      autoload :Authorization, "mpp/methods/evm/authorization"
+      autoload :ChargeIntent, "mpp/methods/evm/charge_intent"
+      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)
+        resolved = Assets.resolve(
+          currency,
+          authorization: authorization,
+          chain_id: chain_id,
+          decimals: decimals
+        )
+        x402_options = normalize_x402(x402)
+
+        charge_intent = ChargeIntent.new(
+          authorization: resolved.fetch(:authorization),
+          facilitator: X402::Facilitator.resolve(x402_options.fetch(:facilitator)),
+          max_timeout_seconds: x402_options.fetch(:max_timeout_seconds),
+          route_binding: x402_options.fetch(:route_binding)
+        )
+
+        method = EvmMethod.new(
+          currency: resolved.fetch(:address),
+          recipient: recipient,
+          decimals: resolved.fetch(:decimals),
+          chain_id: resolved.fetch(:chain_id),
+          authorization: resolved.fetch(:authorization),
+          x402: x402_options
+        )
+        method.intents = {"charge" => charge_intent}
+        method
+      end
+
+      def self.normalize_x402(x402)
+        options = x402.each_with_object({}) do |(key, value), acc|
+          acc[key.to_sym] = value
+        end
+        facilitator = options[:facilitator]
+        if facilitator.nil? || (facilitator.is_a?(String) && facilitator.empty?)
+          raise ArgumentError, "evm.charge requires x402: { facilitator: ... }"
+        end
+
+        route_binding = (options[:route_binding] || options[:routeBinding] || :resource).to_sym
+        unless [:resource, :required].include?(route_binding)
+          raise ArgumentError, "x402 route_binding must be :resource or :required"
+        end
+
+        {
+          facilitator: facilitator,
+          max_timeout_seconds: Integer(options[:max_timeout_seconds] || options[:maxTimeoutSeconds] || 300),
+          route_binding: route_binding
+        }
+      end
+      private_class_method :normalize_x402
+    end
+  end
+end

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

@@ -106,8 +106,11 @@ module Mpp
 
         private
 
+        # Include the SPT so a retry with a fresh token is a new PaymentIntent,
+        # matching mppx (`prefix_challengeId_spt`). Same challenge + same SPT
+        # still collapses via Stripe idempotency.
         def stripe_idempotency_key(credential)
-          "mpp-stripe-charge-#{credential.challenge.id}"
+          "mpp_#{credential.challenge.id}_#{credential.payload["spt"]}"
         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,18 @@ 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
         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)
           @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
@@ -249,13 +251,19 @@ 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)
         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 +272,15 @@ 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)
         )
 
         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

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

@@ -39,6 +39,10 @@ module Mpp
           @_method&.fee_payer_allowed_fee_tokens
         end
 
+        def relay
+          @_method&.relay
+        end
+
         def verify(credential, request)
           req = Schemas::ChargeRequest.from_hash(request)
 
@@ -49,6 +53,8 @@ module Mpp
             raise Mpp::VerificationError, "Request has expired" if expires < Time.now.utc
           end
 
+          return relay.verify(credential, request) if relay
+
           payload_data = credential.payload
           unless payload_data.is_a?(Hash) && payload_data.key?("type")
             raise Mpp::VerificationError,
@@ -141,14 +147,13 @@ module Mpp
           simulate_payload = nil
 
           if request.method_details.fee_payer
-            if fee_payer
+            payer = fee_payer
+            raise Mpp::VerificationError, "No fee payer configured" unless payer
+
+            if local_fee_payer?(payer)
               raw_tx, simulate_payload = cosign_as_fee_payer(raw_tx, request.currency, request: request, challenge: credential.challenge)
             else
-              fee_payer_url = request.method_details.fee_payer_url || Defaults::DEFAULT_FEE_PAYER_URL
-              result = Rpc.call(fee_payer_url, "eth_signRawTransaction", [raw_tx])
-              raise Mpp::VerificationError, "Fee payer returned no signed transaction" unless result
-
-              raw_tx = result
+              raw_tx = payer.cosign(raw_tx)
             end
           end
 
@@ -458,6 +463,10 @@ module Mpp
           Mpp::Receipt.success(credential.challenge.id)
         end
 
+        def local_fee_payer?(payer)
+          !FeePayerClient.hosted_config?(payer)
+        end
+
         def cosign_as_fee_payer(raw_tx, fee_token, request: nil, challenge: nil)
           require "eth"
           require "rlp"
@@ -703,6 +712,10 @@ module Mpp
           }
         end
 
+        # Expected calldata length for transferWithMemo(address,uint256,bytes32):
+        # 4 (selector) + 32 (address) + 32 (amount) + 32 (memo) = 100 bytes = 200 hex chars
+        MAX_TRANSFER_CALLDATA_HEX_LENGTH = 200
+
         def validate_fee_payer_calls(calls, request, challenge: nil)
           if calls.length != 1
             raise Mpp::VerificationError, "Invalid transaction: contains unauthorized extra calls"
@@ -715,7 +728,14 @@ module Mpp
           unless call.to.downcase == request.currency.downcase
             raise Mpp::VerificationError, "Invalid transaction: no matching payment call found"
           end
-          unless match_transfer_calldata(call.data.delete_prefix("0x"), request, challenge: challenge)
+
+          call_data_hex = call.data.delete_prefix("0x")
+          if call_data_hex.length > MAX_TRANSFER_CALLDATA_HEX_LENGTH
+            raise Mpp::VerificationError,
+              "Invalid transaction: calldata contains trailing padding (#{call_data_hex.length / 2} bytes, expected #{MAX_TRANSFER_CALLDATA_HEX_LENGTH / 2})"
+          end
+
+          unless match_transfer_calldata(call_data_hex, request, challenge: challenge)
             raise Mpp::VerificationError, "Invalid transaction: no matching payment call found"
           end
         end

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

@@ -6,16 +6,23 @@ module Mpp
     module Tempo
       # EIP-712 proof credentials for zero-amount challenges.
       #
-      # Domain: { name: "MPP", version: "2", chainId }
-      # Types:  { Proof: [{ name: "challengeId", type: "string" }, { name: "realm", type: "string" }] }
-      # Message: { challengeId: <challenge.id>, realm: <challenge.realm> }
+      # Domain: { name: "MPP", version: "3", chainId }
+      # Types:  { Proof: [{ name: "account", type: "address" },
+      #                   { name: "challengeId", type: "string" },
+      #                   { name: "realm", type: "string" }] }
+      # Message: { account: <payer>, challengeId: <challenge.id>, realm: <challenge.realm> }
+      #
+      # The account field binds the signature to one payer wallet, so a proof
+      # signed for one account cannot be replayed against another. This matches
+      # mpp-go, mpp-rs and mppx, which all sign and verify domain version "3"
+      # and reject version "2".
       module Proof
         DOMAIN_NAME = "MPP"
-        DOMAIN_VERSION = "2"
+        DOMAIN_VERSION = "3"
 
         # EIP-712 domain separator type hash
         DOMAIN_TYPE_HASH = "EIP712Domain(string name,string version,uint256 chainId)"
-        PROOF_TYPE_HASH = "Proof(string challengeId,string realm)"
+        PROOF_TYPE_HASH = "Proof(address account,string challengeId,string realm)"
 
         module_function
 
@@ -36,11 +43,12 @@ module Mpp
           )
         end
 
-        # Compute the EIP-712 struct hash for Proof(challengeId, realm).
-        def struct_hash(challenge_id, realm)
+        # Compute the EIP-712 struct hash for Proof(account, challengeId, realm).
+        def struct_hash(account, challenge_id, realm)
           keccak256(
             abi_encode(
               keccak256(PROOF_TYPE_HASH),
+              address_word(account),
               keccak256(challenge_id),
               keccak256(realm)
             )
@@ -48,15 +56,20 @@ module Mpp
         end
 
         # Compute the full EIP-712 signing hash.
-        def signing_hash(chain_id:, challenge_id:, realm:)
+        def signing_hash(chain_id:, account:, challenge_id:, realm:)
           keccak256(
-            "\x19\x01".b + domain_separator(chain_id) + struct_hash(challenge_id, realm)
+            "\x19\x01".b + domain_separator(chain_id) + struct_hash(account, challenge_id, realm)
           )
         end
 
-        # Sign a proof credential (client-side).
+        # Sign a proof credential (client-side). The signer is also the payer.
         def sign(account:, chain_id:, challenge_id:, realm:)
-          hash = signing_hash(chain_id: chain_id, challenge_id: challenge_id, realm: realm)
+          hash = signing_hash(
+            chain_id: chain_id,
+            account: account.address.to_s,
+            challenge_id: challenge_id,
+            realm: realm
+          )
           sig = account.sign_hash(hash)
           "0x#{sig.unpack1("H*")}"
         end
@@ -65,7 +78,12 @@ module Mpp
         def verify(address:, chain_id:, challenge_id:, realm:, signature:)
           Kernel.require "eth"
 
-          hash = signing_hash(chain_id: chain_id, challenge_id: challenge_id, realm: realm)
+          hash = signing_hash(
+            chain_id: chain_id,
+            account: address,
+            challenge_id: challenge_id,
+            realm: realm
+          )
           sig_bytes = [signature.delete_prefix("0x")].pack("H*")
 
           # Recover the signer address from the signature
@@ -94,6 +112,15 @@ module Mpp
           nil
         end
 
+        # Encode an address as a 32-byte EIP-712 word. Unlike a string field the
+        # address is not hashed, it is the raw 20 bytes left-padded to 32.
+        def address_word(address)
+          hex = address.to_s.delete_prefix("0x")
+          raise ArgumentError, "invalid address: #{address}" unless hex.match?(/\A[a-fA-F0-9]{40}\z/)
+
+          [hex].pack("H*")
+        end
+
         # ABI-encode values (packed 32-byte words).
         def abi_encode(*values)
           values.map { |v|