mpp-rb 0.1.1 → 0.1.3

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

@@ -45,29 +45,50 @@ module Mpp
             require_eth!
             require_rlp!
 
-            Eth::Util.keccak256([TYPE_ID].pack("C") + RLP.encode(unsigned_rlp_fields))
+            Eth::Util.keccak256([TYPE_ID].pack("C") + RLP.encode(signing_rlp_fields))
           end
 
-          # Hash for fee payer to sign — includes sender_signature in the RLP.
+          # Hash for fee payer to sign.
           def fee_payer_signature_hash
             require_eth!
             require_rlp!
 
-            fields = unsigned_rlp_fields
-            fields.insert(11, sender_signature)
-            Eth::Util.keccak256([TYPE_ID].pack("C") + RLP.encode(fields))
+            Eth::Util.keccak256([FeePayer::TYPE_ID].pack("C") + RLP.encode(fee_payer_signing_rlp_fields))
           end
 
           private
 
           def rlp_fields
+            fields = signing_rlp_fields
+            fields << signature_envelope(sender_signature) if sender_signature
+            fields
+          end
+
+          def signing_rlp_fields
             fields = unsigned_rlp_fields
-            fields.insert(11, sender_signature)
-            fields.insert(12, fee_payer_signature || EMPTY_SIGNATURE)
+            fields << key_authorization if key_authorization
             fields
           end
 
           def unsigned_rlp_fields
+            [
+              chain_id,
+              max_priority_fee_per_gas,
+              max_fee_per_gas,
+              gas_limit,
+              calls.map(&:as_rlp_list),
+              access_list || EMPTY_LIST,
+              nonce_key,
+              nonce,
+              encode_optional_uint(valid_before),
+              encode_optional_uint(valid_after),
+              fee_token ? pack_hex(fee_token) : "".b,
+              fee_payer_field,
+              tempo_authorization_list || EMPTY_LIST
+            ]
+          end
+
+          def fee_payer_signing_rlp_fields
             fields = [
               chain_id,
               max_priority_fee_per_gas,
@@ -80,12 +101,48 @@ module Mpp
               encode_optional_uint(valid_before),
               encode_optional_uint(valid_after),
               fee_token ? pack_hex(fee_token) : "".b,
+              pack_hex(sender_address),
               tempo_authorization_list || EMPTY_LIST
             ]
             fields << key_authorization if key_authorization
             fields
           end
 
+          def fee_payer_field
+            return signature_tuple(fee_payer_signature) if fee_payer_signature && fee_payer_signature != EMPTY_SIGNATURE
+            return EMPTY_SIGNATURE if fee_token.nil?
+
+            "".b
+          end
+
+          def signature_tuple(signature)
+            normalized = normalized_signature(signature)
+            [
+              normalized.getbyte(64).zero? ? "".b : normalized[64],
+              trim_leading_zeroes(normalized[0, 32]),
+              trim_leading_zeroes(normalized[32, 32])
+            ]
+          end
+
+          def signature_envelope(signature)
+            normalized_signature(signature)
+          end
+
+          def normalized_signature(signature)
+            bytes = signature.b
+            raise ArgumentError, "signature must be 65 bytes, got #{bytes.bytesize}" unless bytes.bytesize == 65
+
+            v = bytes.getbyte(64)
+            parity = (v >= 27) ? v - 27 : v
+            raise ArgumentError, "signature parity must be 0 or 1, got #{v}" unless [0, 1].include?(parity)
+
+            bytes[0, 64] + [parity].pack("C")
+          end
+
+          def trim_leading_zeroes(value)
+            value.sub(/\A\x00+/n, "")
+          end
+
           def pack_hex(value)
             [value.delete_prefix("0x")].pack("H*")
           end
@@ -112,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,6 +1,8 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "stringio"
+
 module Mpp
   module Server
     # Rack middleware that intercepts requests requiring payment.
@@ -26,15 +28,20 @@ module Mpp
       sig { params(env: T.untyped).returns(T::Array[T.untyped]) }
       def call(env)
         authorization = env["HTTP_AUTHORIZATION"]
+        body_capture = capture_request_body(env)
         status, headers, body = @app.call(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)
@@ -43,9 +50,101 @@ module Mpp
 
         _credential, receipt = result
         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