mpp-rb 0.1.2 → 0.1.4

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

@@ -6,16 +6,16 @@ module Mpp
     module Tempo
       # EIP-712 proof credentials for zero-amount challenges.
       #
-      # Domain: { name: "MPP", version: "1", chainId }
-      # Types:  { Proof: [{ name: "challengeId", type: "string" }] }
-      # Message: { challengeId: <challenge.id> }
+      # Domain: { name: "MPP", version: "2", chainId }
+      # Types:  { Proof: [{ name: "challengeId", type: "string" }, { name: "realm", type: "string" }] }
+      # Message: { challengeId: <challenge.id>, realm: <challenge.realm> }
       module Proof
         DOMAIN_NAME = "MPP"
-        DOMAIN_VERSION = "1"
+        DOMAIN_VERSION = "2"
 
         # EIP-712 domain separator type hash
         DOMAIN_TYPE_HASH = "EIP712Domain(string name,string version,uint256 chainId)"
-        PROOF_TYPE_HASH = "Proof(string challengeId)"
+        PROOF_TYPE_HASH = "Proof(string challengeId,string realm)"
 
         module_function
 
@@ -36,35 +36,36 @@ module Mpp
           )
         end
 
-        # Compute the EIP-712 struct hash for Proof(challengeId).
-        def struct_hash(challenge_id)
+        # Compute the EIP-712 struct hash for Proof(challengeId, realm).
+        def struct_hash(challenge_id, realm)
           keccak256(
             abi_encode(
               keccak256(PROOF_TYPE_HASH),
-              keccak256(challenge_id)
+              keccak256(challenge_id),
+              keccak256(realm)
             )
           )
         end
 
         # Compute the full EIP-712 signing hash.
-        def signing_hash(chain_id:, challenge_id:)
+        def signing_hash(chain_id:, challenge_id:, realm:)
           keccak256(
-            "\x19\x01".b + domain_separator(chain_id) + struct_hash(challenge_id)
+            "\x19\x01".b + domain_separator(chain_id) + struct_hash(challenge_id, realm)
           )
         end
 
         # Sign a proof credential (client-side).
-        def sign(account:, chain_id:, challenge_id:)
-          hash = signing_hash(chain_id: chain_id, challenge_id: challenge_id)
+        def sign(account:, chain_id:, challenge_id:, realm:)
+          hash = signing_hash(chain_id: chain_id, challenge_id: challenge_id, realm: realm)
           sig = account.sign_hash(hash)
           "0x#{sig.unpack1("H*")}"
         end
 
         # Verify a proof credential signature (server-side).
-        def verify(address:, chain_id:, challenge_id:, signature:)
+        def verify(address:, chain_id:, challenge_id:, realm:, signature:)
           Kernel.require "eth"
 
-          hash = signing_hash(chain_id: chain_id, challenge_id: challenge_id)
+          hash = signing_hash(chain_id: chain_id, challenge_id: challenge_id, realm: realm)
           sig_bytes = [signature.delete_prefix("0x")].pack("H*")
 
           # Recover the signer address from the signature
@@ -106,7 +107,10 @@ module Mpp
         end
 
         def uint256(value)
-          [value].pack("Q>").rjust(32, "\x00".b)
+          value = Integer(value)
+          raise ArgumentError, "uint256 out of range" if value.negative? || value >= (1 << 256)
+
+          [value.to_s(16).rjust(64, "0")].pack("H*")
         end
 
         def recover_address(hash, sig_bytes)

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

@@ -169,11 +169,12 @@ module Mpp
         module_function
 
         def build_signed_transfer(account:, chain_id:, gas_limit:, gas_price:, nonce:, nonce_key:,
-          currency:, transfer_data:, valid_before: nil, awaiting_fee_payer: false)
+          currency:, transfer_data:, max_priority_fee_per_gas: nil, max_fee_per_gas: nil,
+          valid_before: nil, awaiting_fee_payer: false)
           tx = SignedTransaction.new(
             chain_id: chain_id,
-            max_priority_fee_per_gas: gas_price,
-            max_fee_per_gas: gas_price,
+            max_priority_fee_per_gas: max_priority_fee_per_gas || gas_price,
+            max_fee_per_gas: max_fee_per_gas || gas_price,
             gas_limit: gas_limit,
             calls: [Call.new(to: currency, value: 0, data: transfer_data)],
             access_list: EMPTY_LIST,

data/lib/mpp/methods/tempo.rb

@@ -10,6 +10,7 @@ module Mpp
       autoload :Attribution, "mpp/methods/tempo/attribution"
       autoload :Rpc, "mpp/methods/tempo/rpc"
       autoload :Transaction, "mpp/methods/tempo/transaction"
+      autoload :FeePayerPolicy, "mpp/methods/tempo/fee_payer_policy"
       autoload :Schemas, "mpp/methods/tempo/schemas"
       # Eagerly require client_method so the Tempo.tempo factory method is available
       require_relative "tempo/client_method"

data/lib/mpp/parsing.rb

@@ -13,6 +13,7 @@ module Mpp
 
     # RFC 9110 auth-param regex: key="value" or key=token
     AUTH_PARAM_RE = /([a-zA-Z_][\w-]*+)\s*=\s*(?:"((?:[^"\\]|\\.)*)"|([^\s,]++))/
+    PAYMENT_METHOD_ID_RE = /\A[a-z]+\z/
 
     module_function
 
@@ -65,6 +66,11 @@ module Mpp
       params
     end
 
+    sig { params(method: T.untyped).void }
+    def validate_payment_method_id(method)
+      Kernel.raise Mpp::ParseError, "Invalid payment method ID" unless method.is_a?(String) && PAYMENT_METHOD_ID_RE.match?(method)
+    end
+
     # Parse a WWW-Authenticate header into a Challenge.
     sig { params(header: T.untyped).returns(Mpp::Challenge) }
     def parse_www_authenticate(header)
@@ -82,6 +88,7 @@ module Mpp
 
       method = params["method"]
       Kernel.raise Mpp::ParseError, "Missing 'method' field" unless method && !method.empty?
+      validate_payment_method_id(method)
 
       intent = params["intent"]
       Kernel.raise Mpp::ParseError, "Missing 'intent' field" unless intent && !intent.empty?
@@ -148,10 +155,13 @@ module Mpp
       Kernel.raise Mpp::ParseError, "Credential challenge must be an object" unless challenge_data.is_a?(Hash)
       Kernel.raise Mpp::ParseError, "Credential challenge missing required field: id" unless challenge_data.key?("id")
 
+      method = challenge_data["method"]
+      validate_payment_method_id(method)
+
       echo = Mpp::ChallengeEcho.new(
         id: challenge_data["id"].to_s,
         realm: (challenge_data["realm"] || "").to_s,
-        method: (challenge_data["method"] || "").to_s,
+        method: method,
         intent: (challenge_data["intent"] || "").to_s,
         request: (challenge_data["request"] || "").to_s,
         expires: challenge_data["expires"]&.to_s,
@@ -213,6 +223,8 @@ module Mpp
       Kernel.raise Mpp::ParseError, "Invalid receipt status" unless status == "success"
 
       timestamp = parse_timestamp(data["timestamp"].to_s)
+      method = data["method"]
+      validate_payment_method_id(method)
 
       extra = data["extra"]
       extra = nil unless extra.is_a?(Hash)
@@ -221,7 +233,7 @@ module Mpp
         status: status,
         timestamp: timestamp,
         reference: data["reference"].to_s,
-        method: (data["method"] || "").to_s,
+        method: method,
         external_id: data["externalId"]&.to_s,
         extra: extra
       )

data/lib/mpp/receipt.rb

@@ -18,13 +18,14 @@ module Mpp
     end
 
     # Create a success receipt with current timestamp.
-    def self.success(reference, timestamp: nil, method: "tempo", external_id: nil)
+    def self.success(reference, timestamp: nil, method: "tempo", external_id: nil, extra: nil)
       new(
         status: "success",
         timestamp: timestamp || Time.now.utc,
         reference: reference,
         method: method,
-        external_id: external_id
+        external_id: external_id,
+        extra: extra
       )
     end
   end

data/lib/mpp/server/decorator.rb

@@ -20,6 +20,7 @@ module Mpp
           "Cache-Control" => "no-store",
           "Content-Type" => "application/problem+json"
         }
+        Mpp::Server::Middleware.mark_authorization_bound_response(headers)
         {
           "_mpp_challenge" => true,
           "status" => 402,

data/lib/mpp/server/middleware.rb

@@ -1,40 +1,50 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "stringio"
+
 module Mpp
   module Server
-    # Rack middleware that intercepts requests requiring payment.
+    # Rack middleware that gates endpoints behind payment verification.
     #
-    # The downstream app signals payment is needed by setting env["mpp.charge"]
-    # to a hash with at least :amount, and optionally :currency, :recipient,
-    # :description, :expires, etc.
+    # The pricing proc determines which requests require payment and at what
+    # price. It receives the Rack env and must return a charge options hash
+    # (with at least :amount) or nil for free endpoints. The pricing proc
+    # MUST NOT produce side effects.
     #
-    # Example:
-    #   use Mpp::Server::Middleware, handler: my_handler
+    # Payment is verified BEFORE the downstream app runs — if verification
+    # fails, the app never executes and a 402 challenge is returned.
     #
-    #   # In your app:
-    #   env["mpp.charge"] = { amount: "1.00" }
+    # Example:
+    #   use Mpp::Server::Middleware,
+    #       handler: my_handler,
+    #       pricing: ->(env) { {amount: "1.00"} if env["PATH_INFO"] == "/paid" }
     class Middleware
       extend T::Sig
 
-      sig { params(app: T.untyped, handler: Mpp::Server::MppHandler).void }
-      def initialize(app, handler:)
+      sig { params(app: T.untyped, handler: Mpp::Server::MppHandler, pricing: T.untyped).void }
+      def initialize(app, handler:, pricing:)
         @app = T.let(app, T.untyped)
         @handler = T.let(handler, Mpp::Server::MppHandler)
+        @pricing = T.let(pricing, T.untyped)
       end
 
       sig { params(env: T.untyped).returns(T::Array[T.untyped]) }
       def call(env)
+        charge_opts = @pricing.call(env)
+        return @app.call(env) unless charge_opts
+
         authorization = env["HTTP_AUTHORIZATION"]
-        status, headers, body = @app.call(env)
+        body_capture = capture_request_body(env)
 
-        charge_opts = env["mpp.charge"]
-        return [status, headers, body] unless charge_opts
+        request_body = body_capture&.materialize
+        env["rack.input"] = StringIO.new(request_body || "") if body_capture
 
         amount = charge_opts[:amount]
-        opts = charge_opts.except(:amount)
+        opts = charge_opts.except(:amount, :body)
+        opts[:mppx_scope] ||= mppx_scope(env)
 
-        result = @handler.charge(authorization, amount, **opts)
+        result = @handler.charge(authorization, amount, **opts, body: request_body)
 
         if result.is_a?(Mpp::Challenge)
           resp = Mpp::Server::Decorator.make_challenge_response(result, @handler.realm)
@@ -42,10 +52,103 @@ module Mpp
         end
 
         _credential, receipt = result
+        status, headers, body = @app.call(env)
         headers["Payment-Receipt"] = receipt.to_payment_receipt
+        self.class.mark_authorization_bound_response(headers)
 
         [status, headers, body]
       end
+
+      sig { params(headers: T::Hash[T.untyped, T.untyped]).void }
+      def self.mark_authorization_bound_response(headers)
+        headers["Cache-Control"] = "no-store"
+
+        vary_values = headers["Vary"].to_s.split(",").map do |value|
+          value.strip.downcase
+        end
+        return if vary_values.include?("*") || vary_values.include?("authorization")
+
+        headers["Vary"] = [headers["Vary"], "Authorization"]
+          .compact
+          .reject(&:empty?)
+          .join(", ")
+      end
+
+      private
+
+      sig { params(env: T.untyped).returns(T.nilable(RackInputCapture)) }
+      def capture_request_body(env)
+        input = env["rack.input"]
+        return nil unless input&.respond_to?(:read)
+
+        capture = RackInputCapture.new(input)
+        env["rack.input"] = capture
+        capture
+      end
+
+      sig { params(env: T.untyped).returns(T::Hash[String, String]) }
+      def mppx_scope(env)
+        scope = T.let({}, T::Hash[String, String])
+        route = env["action_dispatch.route_uri_pattern"] || env["sinatra.route"] || env["roda.route"]
+        route = route.split(" ", 2).last if route.is_a?(String) && route.match?(/\A[A-Z]+\s+/)
+        scope["route"] = route if route.is_a?(String) && !route.empty?
+        path = env["PATH_INFO"]
+        scope["resource"] = path if path.is_a?(String) && !path.empty?
+        query = env["QUERY_STRING"]
+        scope["query"] = query if query.is_a?(String) && !query.empty?
+        scope
+      end
+
+      class RackInputCapture
+        extend T::Sig
+
+        sig { params(input: T.untyped).void }
+        def initialize(input)
+          @input = T.let(input, T.untyped)
+          @buffer = T.let(+"".b, String)
+        end
+
+        sig { params(args: T.untyped).returns(T.untyped) }
+        def read(*args)
+          chunk = @input.read(*args)
+          @buffer << chunk.b if chunk && !chunk.empty?
+          chunk
+        end
+
+        sig { params(args: T.untyped).returns(T.untyped) }
+        def gets(*args)
+          chunk = @input.gets(*args)
+          @buffer << chunk.b if chunk && !chunk.empty?
+          chunk
+        end
+
+        sig { params(block: T.nilable(T.proc.params(chunk: T.untyped).void)).returns(T.untyped) }
+        def each(&block)
+          return enum_for(:each) unless block
+
+          @input.each do |chunk|
+            @buffer << chunk.b if chunk && !chunk.empty?
+            block.call(chunk)
+          end
+        end
+
+        sig { returns(T.untyped) }
+        def rewind
+          @input.rewind if @input.respond_to?(:rewind)
+          @buffer = +"".b
+        end
+
+        sig { returns(T.untyped) }
+        def close
+          @input.close if @input.respond_to?(:close)
+        end
+
+        sig { returns(T.nilable(String)) }
+        def materialize
+          read
+          @buffer.empty? ? nil : @buffer.dup
+        end
+      end
     end
   end
 end

data/lib/mpp/server/mpp_handler.rb

@@ -22,28 +22,51 @@ module Mpp
       sig { returns(T::Hash[String, T.untyped]) }
       attr_reader :defaults
 
-      sig { params(method: T.untyped, realm: String, secret_key: String, defaults: T.nilable(T::Hash[String, T.untyped])).void }
-      def initialize(method:, realm:, secret_key:, defaults: nil)
+      sig { params(method: T.untyped, realm: String, secret_key: String, defaults: T.nilable(T::Hash[String, T.untyped]), events: T.nilable(Mpp::Events::Dispatcher)).void }
+      def initialize(method:, realm:, secret_key:, defaults: nil, events: nil)
         @method = T.let(method, T.untyped)
         @realm = T.let(realm, String)
         @secret_key = T.let(secret_key, String)
         @defaults = T.let(defaults || {}, T::Hash[String, T.untyped])
+        @events = T.let(events || Mpp::Events.server_dispatcher, Mpp::Events::Dispatcher)
       end
 
       # Create with auto-detected realm and secret_key.
-      sig { params(method: T.untyped, realm: T.untyped, secret_key: T.untyped).returns(T.attached_class) }
-      def self.create(method:, realm: nil, secret_key: nil)
+      sig { params(method: T.untyped, realm: T.untyped, secret_key: T.untyped, events: T.nilable(Mpp::Events::Dispatcher)).returns(T.attached_class) }
+      def self.create(method:, realm: nil, secret_key: nil, events: nil)
         new(
           method: method,
           realm: realm || Defaults.detect_realm,
-          secret_key: secret_key || Defaults.detect_secret_key
+          secret_key: secret_key || Defaults.detect_secret_key,
+          events: events
         )
       end
 
+      sig { params(name: String, handler: T.untyped, block: T.nilable(T.proc.params(payload: T.untyped).returns(T.untyped))).returns(T.proc.void) }
+      def on(name, handler = nil, &block)
+        @events.on(name, handler, &block)
+      end
+
+      sig { params(handler: T.untyped, block: T.nilable(T.proc.params(payload: T.untyped).returns(T.untyped))).returns(T.proc.void) }
+      def on_challenge_created(handler = nil, &block)
+        on(Mpp::Events::CHALLENGE_CREATED, handler, &block)
+      end
+
+      sig { params(handler: T.untyped, block: T.nilable(T.proc.params(payload: T.untyped).returns(T.untyped))).returns(T.proc.void) }
+      def on_payment_failed(handler = nil, &block)
+        on(Mpp::Events::PAYMENT_FAILED, handler, &block)
+      end
+
+      sig { params(handler: T.untyped, block: T.nilable(T.proc.params(payload: T.untyped).returns(T.untyped))).returns(T.proc.void) }
+      def on_payment_success(handler = nil, &block)
+        on(Mpp::Events::PAYMENT_SUCCESS, handler, &block)
+      end
+
       # Handle a charge intent.
-      sig { params(authorization: T.nilable(String), amount: String, currency: T.nilable(String), recipient: T.nilable(String), expires: T.nilable(String), description: T.nilable(String), memo: T.nilable(String), fee_payer: T::Boolean, chain_id: T.nilable(Integer), extra: T.nilable(T::Hash[String, String])).returns(T.untyped) }
+      sig { params(authorization: T.nilable(String), amount: String, currency: T.nilable(String), recipient: T.nilable(String), expires: T.nilable(String), description: T.nilable(String), external_id: T.nilable(String), memo: T.nilable(String), fee_payer: T::Boolean, chain_id: T.nilable(Integer), extra: T.nilable(T::Hash[String, String]), mppx_scope: T.nilable(T::Hash[String, String]), body: T.untyped).returns(T.untyped) }
       def charge(authorization, amount, currency: nil, recipient: nil, expires: nil,
-        description: nil, memo: nil, fee_payer: false, chain_id: nil, extra: nil)
+        description: nil, external_id: nil, memo: nil, fee_payer: false, chain_id: nil,
+        extra: nil, mppx_scope: nil, body: nil)
         intent = @method.intents["charge"]
         raise ArgumentError, "Method #{@method.name} does not support charge intent" unless intent
 
@@ -60,6 +83,7 @@ module Mpp
           "currency" => resolved_currency,
           "recipient" => resolved_recipient
         }
+        request["externalId"] = external_id unless external_id.nil?
 
         if extra
           extra.each do |k, v|
@@ -67,6 +91,12 @@ module Mpp
           end
           request["extra"] = extra
         end
+        if mppx_scope
+          mppx_scope.each do |k, v|
+            raise ArgumentError, "mppx_scope must be a dict[str, str]" unless k.is_a?(String) && v.is_a?(String)
+          end
+          request["_mppx_scope"] = mppx_scope
+        end
 
         resolved_chain_id = chain_id
         resolved_chain_id ||= @method.chain_id if @method.respond_to?(:chain_id)
@@ -89,7 +119,9 @@ module Mpp
           secret_key: @secret_key,
           method: @method.name,
           description: description,
-          expires: expires
+          expires: expires,
+          events: @events,
+          body: body
         )
       end
     end