mpp-rb 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 033c7cfeecb0955e5241cac709e73c0ebd7c4fc7761881614c5ce11128b342f7
-  data.tar.gz: d5611e4ed86e15ad49f04ca482a44b07b89e4c107cec0adc0e2a647a8fcfd04a
+  metadata.gz: 7accbb98302b70cc76e32afc99bf2b5672c445194f79e9fd1cdfb0e5d7f058dd
+  data.tar.gz: 3538fdc0cd0851816ac29f294de441e18fefb45f0bd00b44cad6295ca6a1e1f1
 SHA512:
-  metadata.gz: 6b88426e6a71a1c46a089f2eeabf502a8ba58267dafaf7a800a8781befcb043313112f3813d8def6aa03fccfe264f03d019e9da8f6c9a2e03262a55f2ae8e500
-  data.tar.gz: 15690c57ad85fe973be97c9c0fd0e199c865dd65793ffe86507ee118a32589e42055cf61e4bc04e9aad86e84587d882bf7e9ce5a59d8e6fe293fd3ab839d6732
+  metadata.gz: b6cd8af4a9376b0db632aab578f1d9fb0e9e6d3327c926e40f35badb16750d06a15774fe7444debde1a402a7d3b51133d25bfd43d577de726fe646c35bc4f522
+  data.tar.gz: 2997bf04f49594dce0246c917075d5aba8a9f974e6ed4ff6cda586e8ae9361db110cf5197ee977fa8d795b5f0affc701f34170f4c75654f5485853608fb6776c

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

@@ -80,6 +80,19 @@ module Mpp
           memo_server == fingerprint(server_id)
         end
 
+        # Verify challenge-bound nonce in memo.
+        def verify_challenge_binding(memo, challenge_id)
+          return false unless challenge_id
+          return false unless mpp_memo?(memo)
+
+          begin
+            memo_nonce = [memo[52, 14]].pack("H*")
+          rescue ArgumentError
+            return false
+          end
+          memo_nonce == keccak256(challenge_id.encode(Encoding::UTF_8))[0, 7]
+        end
+
         # Decoded memo structure.
         DecodedMemo = Data.define(:version, :server_fingerprint, :client_fingerprint, :nonce)
 

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

@@ -17,8 +17,8 @@ module Mpp
           Kernel.require "rlp"
 
           sender_sig = signed_tx.sender_signature
-          sig_bytes = sender_sig.respond_to?(:to_bytes) ? sender_sig.to_bytes : sender_sig.to_s.b
-          sender_addr = signed_tx.sender_address.to_s.b
+          sig_bytes = normalize_signature(sender_sig.respond_to?(:to_bytes) ? sender_sig.to_bytes : sender_sig.to_s.b)
+          sender_addr = pack_hex(signed_tx.sender_address)
 
           fields = [
             signed_tx.chain_id,
@@ -26,12 +26,12 @@ module Mpp
             signed_tx.max_fee_per_gas,
             signed_tx.gas_limit,
             signed_tx.calls.map(&:as_rlp_list),
-            signed_tx.access_list.map(&:as_rlp_list),
+            signed_tx.access_list.map { |entry| entry.respond_to?(:as_rlp_list) ? entry.as_rlp_list : entry },
             signed_tx.nonce_key,
             signed_tx.nonce,
             encode_optional_uint(signed_tx.valid_before),
             encode_optional_uint(signed_tx.valid_after),
-            signed_tx.fee_token ? signed_tx.fee_token.to_s.b : "".b,
+            signed_tx.fee_token ? pack_hex(signed_tx.fee_token) : "".b,
             sender_addr,
             signed_tx.tempo_authorization_list.to_a
           ]
@@ -39,7 +39,7 @@ module Mpp
           fields << RLP.decode(signed_tx.key_authorization) if signed_tx.key_authorization
           fields << sig_bytes
 
-          [TYPE_ID].pack("C") + RLP.include(fields)
+          [TYPE_ID].pack("C") + RLP.encode(fields)
         end
 
         # Decode a 0x78 fee payer envelope.
@@ -58,7 +58,7 @@ module Mpp
 
           # 15 fields = key_authorization present (index 13), signature at 14
           # 14 fields = no key_authorization, signature at 13
-          key_authorization = (RLP.include(decoded[13]) if decoded.length == 15)
+          key_authorization = (RLP.encode(decoded[13]) if decoded.length == 15)
 
           [decoded, sender_address.to_s.b, sender_signature.to_s.b, key_authorization]
         end
@@ -68,6 +68,21 @@ module Mpp
 
           value.is_a?(Integer) ? value : value.to_i
         end
+
+        def pack_hex(value)
+          [value.to_s.delete_prefix("0x")].pack("H*")
+        end
+
+        def normalize_signature(signature)
+          bytes = signature.b
+          Kernel.raise ArgumentError, "signature must be 65 bytes, got #{bytes.bytesize}" unless bytes.bytesize == 65
+
+          v = bytes.getbyte(64)
+          parity = (v >= 27) ? v - 27 : v
+          Kernel.raise ArgumentError, "signature parity must be 0 or 1, got #{v}" unless [0, 1].include?(parity)
+
+          bytes[0, 64] + [parity].pack("C")
+        end
       end
     end
   end

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

@@ -51,12 +51,12 @@ module Mpp
           case payload_data["type"]
           when "hash"
             payload = Schemas::HashCredentialPayload.new(type: "hash", hash: payload_data["hash"])
-            verify_hash(payload, req)
+            verify_hash(payload, req, credential: credential)
           when "transaction"
             payload = Schemas::TransactionCredentialPayload.new(
               type: "transaction", signature: payload_data["signature"]
             )
-            verify_transaction(payload, req)
+            verify_transaction(payload, req, credential: credential)
           when "proof"
             payload = Schemas::ProofCredentialPayload.new(
               type: "proof", signature: payload_data["signature"]
@@ -75,7 +75,7 @@ module Mpp
           @rpc_url
         end
 
-        def verify_hash(payload, request)
+        def verify_hash(payload, request, credential:)
           if @store
             store_key = "mpp:charge:#{payload.hash.downcase}"
             raise Mpp::VerificationError, "Transaction hash already used" unless @store.put_if_absent(store_key,
@@ -87,17 +87,17 @@ module Mpp
 
           raise Mpp::VerificationError, "Transaction not found" unless result
           raise Mpp::VerificationError, "Transaction reverted" unless result["status"] == "0x1"
-          unless verify_transfer_logs(
-            result, request
-          )
+          matched_logs = match_transfer_logs(result, request, expected_sender: result["from"])
+          unless matched_logs.any?
             raise Mpp::VerificationError,
               "Transaction must contain a Transfer log matching request parameters"
           end
+          assert_challenge_bound_memo(matched_logs, credential.challenge) unless request.method_details.memo
 
           Mpp::Receipt.success(payload.hash)
         end
 
-        def verify_transaction(payload, request)
+        def verify_transaction(payload, request, credential:)
           validate_transaction_payload(payload.signature, request)
 
           raw_tx = payload.signature
@@ -128,18 +128,23 @@ module Mpp
 
           raise Mpp::VerificationError, "Transaction receipt not found after retries" unless receipt_data
           raise Mpp::VerificationError, "Transaction reverted" unless receipt_data["status"] == "0x1"
-          unless verify_transfer_logs(
-            receipt_data, request
-          )
+          matched_logs = match_transfer_logs(receipt_data, request, expected_sender: receipt_data["from"])
+          unless matched_logs.any?
             raise Mpp::VerificationError,
               "Transaction must contain a Transfer log matching request parameters"
           end
+          assert_challenge_bound_memo(matched_logs, credential.challenge) unless request.method_details.memo
 
           Mpp::Receipt.success(tx_hash)
         end
 
         def verify_transfer_logs(receipt, request, expected_sender: nil)
+          match_transfer_logs(receipt, request, expected_sender: expected_sender).any?
+        end
+
+        def match_transfer_logs(receipt, request, expected_sender: nil)
           expected_memo = request.method_details.memo
+          matched_logs = []
 
           (receipt["logs"] || []).each do |log|
             next unless log["address"]&.downcase == request.currency.downcase
@@ -164,19 +169,42 @@ module Mpp
               memo = topics[3]
               memo_clean = expected_memo.downcase
               memo_clean = "0x#{memo_clean}" unless memo_clean.start_with?("0x")
-              return true if amount == Integer(request.amount) && memo.downcase == memo_clean
+              if amount == Integer(request.amount) && memo.downcase == memo_clean
+                matched_logs << {kind: :memo, memo: memo}
+              end
             else
-              next unless topics[0] == TRANSFER_TOPIC
+              case topics[0]
+              when TRANSFER_WITH_MEMO_TOPIC
+                next if topics.length < 4
+
+                data = log.fetch("data", "0x")
+                next if data.length < 66
+
+                amount = data[2, 64].to_i(16)
+                matched_logs << {kind: :memo, memo: topics[3]} if amount == Integer(request.amount)
+              when TRANSFER_TOPIC
+                data = log.fetch("data", "0x")
+                next if data.length < 66
+
+                amount = data.delete_prefix("0x").to_i(16)
+                matched_logs << {kind: :transfer} if amount == Integer(request.amount)
+              end
+            end
+          end
 
-              data = log.fetch("data", "0x")
-              next if data.length < 66
+          matched_logs.sort_by { |log| (log[:kind] == :memo) ? 0 : 1 }
+        end
 
-              amount = data.delete_prefix("0x").to_i(16)
-              return true if amount == Integer(request.amount)
-            end
+        def assert_challenge_bound_memo(matched_logs, challenge)
+          bound = matched_logs.any? do |log|
+            log[:kind] == :memo &&
+              Attribution.verify_server(log[:memo], challenge.realm) &&
+              Attribution.verify_challenge_binding(log[:memo], challenge.id)
           end
 
-          false
+          return if bound
+
+          raise Mpp::VerificationError, "Payment verification failed: memo is not bound to this challenge"
         end
 
         def validate_transaction_payload(signature, request)
@@ -335,7 +363,7 @@ module Mpp
             max_fee_per_gas: int.call(decoded[2]),
             gas_limit: int.call(decoded[3]),
             calls: calls,
-            access_list: Transaction::EMPTY_LIST,
+            access_list: decoded[5] || Transaction::EMPTY_LIST,
             nonce_key: int.call(decoded[6]),
             nonce: int.call(decoded[7]),
             valid_before: int.call(decoded[8]),
@@ -350,7 +378,7 @@ module Mpp
 
           # Verify sender signature
           sender_hash = tx_for_recovery.signature_hash
-          recovered = Eth::Key.personal_recover(sender_hash, "0x#{sender_sig.unpack1("H*")}")
+          recovered = Eth::Signature.recover(sender_hash, "0x#{sender_sig.unpack1("H*")}")
           recovered_addr = Eth::Util.public_key_to_address(recovered).to_s
           envelope_addr = "0x#{sender_addr_bytes.unpack1("H*")}"
 
@@ -364,7 +392,7 @@ module Mpp
 
           tx_to_sign = tx_for_recovery.with(fee_token: resolved_fee_token)
 
-          # Fee payer signs over fields including sender_signature
+          # Fee payer signs the 0x78 payload, which identifies the recovered sender.
           fee_payer_hash = tx_to_sign.fee_payer_signature_hash
           fee_payer_sig = fee_payer.sign_hash(fee_payer_hash)
 

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

data/lib/mpp/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Mpp
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: mpp-rb
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Stripe
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-23 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -26,7 +25,6 @@ dependencies:
         version: '0.3'
 description: Ruby SDK for the Machine Payments Protocol (MPP) — an HTTP 402 Payment
   Authentication scheme.
-email:
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -89,7 +87,6 @@ licenses:
 metadata:
   rubygems_mfa_required: 'true'
   source_code_uri: https://github.com/stripe/mpp-rb
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -104,8 +101,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: HTTP 402 Payment Authentication for Ruby
 test_files: []