mpp-rb 0.1.4 → 0.1.6

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

@@ -22,7 +22,9 @@ module Mpp
         attr_reader :name
         attr_accessor :rpc_url
 
-        def initialize(chain_id: nil, rpc_url: nil, timeout: 30, store: nil, validate_sender: nil)
+        def initialize(chain_id: nil, rpc_url: nil, timeout: 30, store: Mpp::MemoryStore.new, validate_sender: nil)
+          raise ArgumentError, "store is required" if store.nil?
+
           @name = "charge"
           @rpc_url = rpc_url || (chain_id ? Defaults.rpc_url_for_chain(chain_id) : nil)
           @_method = nil
@@ -39,6 +41,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 +55,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,
@@ -105,11 +113,9 @@ module Mpp
           # Validate the source before reserving the hash.
           source_address = parse_hash_credential_source(credential.source, request.method_details.chain_id)
 
-          if @store
-            store_key = "mpp:charge:#{payload.hash.downcase}"
-            raise Mpp::VerificationError, "Transaction hash already used" unless @store.put_if_absent(store_key,
-              payload.hash)
-          end
+          store_key = "mpp:charge:#{payload.hash.downcase}"
+          raise Mpp::VerificationError, "Transaction hash already used" unless @store.put_if_absent(store_key,
+            payload.hash)
 
           rpc_url = get_rpc_url
           result = Rpc.call(rpc_url, "eth_getTransactionReceipt", [payload.hash])
@@ -141,31 +147,26 @@ 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
 
           rpc_url = get_rpc_url
-          reserved_tx_hash = T.let(nil, T.nilable(String))
-          store_key = T.let(nil, T.nilable(String))
-          if @store
-            reserved_tx_hash = raw_transaction_hash(raw_tx)
-            store_key = "mpp:charge:#{reserved_tx_hash.downcase}"
-            unless @store.put_if_absent(store_key, TRANSACTION_PENDING)
-              raise Mpp::VerificationError, "Transaction hash already used" unless @store.get(store_key) == TRANSACTION_PENDING
+          reserved_tx_hash = raw_transaction_hash(raw_tx)
+          store_key = "mpp:charge:#{reserved_tx_hash.downcase}"
+          unless @store.put_if_absent(store_key, TRANSACTION_PENDING)
+            raise Mpp::VerificationError, "Transaction hash already used" unless @store.get(store_key) == TRANSACTION_PENDING
 
-              receipt_data = fetch_transaction_receipt(rpc_url, reserved_tx_hash)
-              verify_transaction_receipt!(receipt_data, request, credential: credential)
-              @store.put(store_key, TRANSACTION_VERIFIED)
-              return Mpp::Receipt.success(reserved_tx_hash)
-            end
+            receipt_data = fetch_transaction_receipt(rpc_url, reserved_tx_hash)
+            verify_transaction_receipt!(receipt_data, request, credential: credential)
+            @store.put(store_key, TRANSACTION_VERIFIED)
+            return Mpp::Receipt.success(reserved_tx_hash)
           end
 
           # We pay the gas, so simulate the co-signed tx first and bail if it
@@ -173,7 +174,7 @@ module Mpp
           begin
             simulate_before_broadcast(simulate_payload, rpc_url) if simulate_payload
           rescue
-            @store.delete(store_key) if @store && store_key
+            @store.delete(store_key)
             raise
           end
 
@@ -181,33 +182,36 @@ module Mpp
           begin
             tx_hash = Rpc.call(rpc_url, "eth_sendRawTransaction", [raw_tx])
           rescue => e
-            if reserved_tx_hash && store_key && transaction_submission_may_have_succeeded?(e)
+            if transaction_submission_may_have_succeeded?(e)
               receipt_data = fetch_transaction_receipt(rpc_url, reserved_tx_hash)
               verify_transaction_receipt!(receipt_data, request, credential: credential)
-              @store&.put(store_key, TRANSACTION_VERIFIED)
+              @store.put(store_key, TRANSACTION_VERIFIED)
               return Mpp::Receipt.success(reserved_tx_hash)
             end
 
-            @store.delete(store_key) if @store && store_key
+            @store.delete(store_key)
             raise Mpp::VerificationError, "Transaction submission failed: #{e.message}"
           end
 
           unless tx_hash
-            @store.delete(store_key) if @store && store_key
+            @store.delete(store_key)
             raise Mpp::VerificationError, "No transaction hash returned"
           end
 
-          if reserved_tx_hash && tx_hash.downcase != reserved_tx_hash.downcase
-            @store.delete(store_key) if @store && store_key
-            raise Mpp::VerificationError, "Returned transaction hash does not match submitted transaction"
-          end
+          # Tempo nodes hash canonical RLP, which can differ from keccak(raw
+          # bytes). Replay keys must follow the chain hash so a later hash
+          # credential for the same payment is rejected. Keep the raw-hash
+          # claim until verification finishes so a concurrent retry cannot
+          # rebroadcast the same payload.
+          raw_store_key = store_key
+          store_key, reserved_tx_hash = rebase_reservation_to_chain_hash(store_key, reserved_tx_hash, tx_hash)
 
-          tx_hash = reserved_tx_hash || tx_hash
-          receipt_data = fetch_transaction_receipt(rpc_url, tx_hash)
+          receipt_data = fetch_transaction_receipt(rpc_url, reserved_tx_hash)
           verify_transaction_receipt!(receipt_data, request, credential: credential)
-          @store.put(store_key, TRANSACTION_VERIFIED) if @store && store_key
+          @store.put(store_key, TRANSACTION_VERIFIED)
+          @store.put(raw_store_key, TRANSACTION_VERIFIED) if raw_store_key != store_key
 
-          Mpp::Receipt.success(tx_hash)
+          Mpp::Receipt.success(reserved_tx_hash)
         end
 
         def transaction_submission_may_have_succeeded?(error)
@@ -384,17 +388,32 @@ module Mpp
         end
 
         def raw_transaction_hash(raw_tx)
-          Kernel.require "eth"
-
           hex = raw_tx.delete_prefix("0x")
           unless hex.match?(/\A[0-9a-fA-F]+\z/) && hex.length.even?
             raise Mpp::VerificationError, "Invalid transaction signature"
           end
 
-          "0x#{Eth::Util.keccak256([hex].pack("H*")).unpack1("H*")}"
-        rescue LoadError
-          raise Mpp::VerificationError,
-            "eth gem is required to compute transaction hash for transaction replay protection"
+          "0x#{Attribution.keccak256([hex].pack("H*")).unpack1("H*")}"
+        end
+
+        def normalize_tx_hash(tx_hash)
+          hex = tx_hash.to_s.downcase
+          hex.start_with?("0x") ? hex : "0x#{hex}"
+        end
+
+        def rebase_reservation_to_chain_hash(store_key, reserved_tx_hash, returned_tx_hash)
+          canonical = normalize_tx_hash(returned_tx_hash)
+          return [store_key, reserved_tx_hash] if canonical == reserved_tx_hash.downcase
+
+          canonical_key = "mpp:charge:#{canonical}"
+          unless @store.put_if_absent(canonical_key, TRANSACTION_PENDING)
+            unless @store.get(canonical_key) == TRANSACTION_PENDING
+              @store.put(store_key, TRANSACTION_VERIFIED)
+              raise Mpp::VerificationError, "Transaction hash already used"
+            end
+          end
+
+          [canonical_key, canonical]
         end
 
         def match_transfer_calldata(call_data_hex, request, challenge: nil)
@@ -450,14 +469,16 @@ module Mpp
           )
           raise Mpp::VerificationError, "Proof signature does not match source" unless valid
 
-          if @store
-            store_key = "mpp:proof:#{credential.challenge.id}"
-            raise Mpp::VerificationError, "Proof credential has already been used" unless @store.put_if_absent(store_key, true)
-          end
+          store_key = "mpp:proof:#{credential.challenge.id}"
+          raise Mpp::VerificationError, "Proof credential has already been used" unless @store.put_if_absent(store_key, true)
 
           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 +724,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 +740,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|

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

@@ -0,0 +1,257 @@
+# typed: false
+# frozen_string_literal: true
+
+require "digest"
+require "json"
+require "net/http"
+require "time"
+require "uri"
+require_relative "../../http/headers"
+require_relative "attribution"
+
+module Mpp
+  module Methods
+    module Tempo
+      # HTTP client for a Tempo API-compatible MPP relay.
+      #
+      # `resolve` accepts:
+      #   * a URL string (unauthenticated relay)
+      #   * a config hash (`url:` plus optional `headers:`, or mppx-style
+      #     `api_base_url:` / `api_key:`)
+      #   * any object that responds to `#validate` and `#broadcast`
+      class Relay
+        DEFAULT_API_BASE_URL = "https://api.tempo.xyz"
+        VALIDATE_PATH = "/v1/mpp/validate"
+        BROADCAST_PATH = "/v1/mpp/broadcast"
+        DEFAULT_TIMEOUT = Rpc::DEFAULT_TIMEOUT
+
+        ERROR_CODES = %w[
+          already_used
+          broadcast_failed
+          expired
+          invalid_payment
+          insufficient_funds
+          policy_denied
+          screen_rejected
+          simulation_failed
+          temporarily_unavailable
+          unsupported
+          unknown
+        ].freeze
+
+        attr_reader :base_url
+
+        def initialize(url, headers: nil)
+          @base_url = Mpp::Http::Headers.normalize_base_url(url)
+          raise ArgumentError, "relay url is required" if @base_url.empty?
+
+          @headers = headers
+        end
+
+        def self.resolve_optional(relay)
+          return if relay.nil? || relay == false
+
+          resolve(relay)
+        end
+
+        def self.resolve(relay)
+          return relay if relay.is_a?(Relay)
+          return new(relay) if relay.is_a?(String) && !relay.empty?
+          return from_config(relay) if relay.is_a?(Hash)
+          return relay if duck_type?(relay)
+
+          raise ArgumentError, "relay must be a URL, {url:, headers:}, or an object that implements #validate and #broadcast"
+        end
+
+        def self.from_config(config)
+          cfg = Mpp::Http::Headers.symbolize(config)
+          url = cfg[:url] || cfg[:api_base_url] || cfg[:apiBaseUrl] || cfg[:base_url] || cfg[:baseUrl]
+          url = DEFAULT_API_BASE_URL if url.nil? || url.to_s.empty?
+          headers = merge_api_key_headers(cfg[:headers], cfg[:api_key] || cfg[:apiKey])
+          new(url.to_s, headers: headers)
+        end
+
+        def self.duck_type?(relay)
+          !relay.nil? && relay.respond_to?(:validate) && relay.respond_to?(:broadcast)
+        end
+
+        def self.merge_api_key_headers(headers, api_key)
+          return headers if api_key.nil? || api_key.to_s.empty?
+
+          defaults = {"tempo-api-key" => api_key.to_s}
+          return defaults if headers.nil?
+
+          if headers.respond_to?(:call)
+            original = headers
+            ->(path) {
+              extra = (original.arity == 0) ? original.call : original.call(path)
+              extra = {} unless extra.is_a?(Hash)
+              defaults.merge(Mpp::Http::Headers.stringify(extra))
+            }
+          elsif headers.is_a?(Hash)
+            defaults.merge(Mpp::Http::Headers.stringify(headers))
+          else
+            defaults
+          end
+        end
+        private_class_method :merge_api_key_headers
+
+        def verify(credential, _request = nil)
+          input = to_relay_input(credential)
+          validate(input)
+          broadcast(input)
+        end
+
+        def validate(input)
+          response = post(VALIDATE_PATH, input)
+          raise failure(response) unless success?(response)
+
+          true
+        end
+
+        def broadcast(input)
+          response = post(BROADCAST_PATH, input, extra_headers: {
+            "Idempotency-Key" => idempotency_key(input)
+          })
+          raise failure(response) unless broadcast_success?(response)
+
+          to_receipt(response.fetch("receipt"))
+        end
+
+        private
+
+        def post(path, input, extra_headers: {})
+          uri = URI.parse("#{@base_url}#{path}")
+          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["Accept"] = "application/json"
+          request["Content-Type"] = "application/json"
+          Mpp::Http::Headers.resolve(@headers, path).each { |key, value| request[key] = value }
+          extra_headers.each { |key, value| request[key] = value }
+          request.body = JSON.generate(input)
+
+          response = http.request(request)
+          unless response.is_a?(Net::HTTPSuccess)
+            raise Mpp::VerificationFailedError.new(reason: "relay #{path} returned HTTP #{response.code}")
+          end
+
+          body = response.body.to_s
+          if body.empty?
+            raise Mpp::VerificationFailedError.new(reason: "relay #{path} returned an empty body")
+          end
+
+          parsed = JSON.parse(body)
+          unless parsed.is_a?(Hash)
+            raise Mpp::VerificationFailedError.new(reason: "relay #{path} returned JSON that is not an object")
+          end
+
+          parsed
+        rescue JSON::ParserError
+          raise Mpp::VerificationFailedError.new(reason: "relay #{path} returned invalid JSON")
+        rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ETIMEDOUT, Net::OpenTimeout, Net::ReadTimeout, SocketError => e
+          raise Mpp::VerificationFailedError.new(reason: "relay request failed: #{e.message}")
+        end
+
+        def to_relay_input(credential)
+          echo = credential.challenge
+          challenge = {
+            "id" => echo.id,
+            "realm" => echo.realm,
+            "method" => echo.method,
+            "intent" => echo.intent,
+            "request" => decode_request(echo.request)
+          }
+          challenge["expires"] = echo.expires if echo.expires
+          challenge["digest"] = echo.digest if echo.digest
+          challenge["opaque"] = echo.opaque if echo.opaque
+
+          input = {
+            "challenge" => challenge,
+            "payload" => credential.payload
+          }
+          input["source"] = credential.source if credential.source
+          input
+        end
+
+        def decode_request(request)
+          return request if request.is_a?(Hash)
+          return request unless request.is_a?(String) && !request.empty?
+
+          Mpp::Parsing.b64_decode(request)
+        rescue Mpp::ParseError
+          request
+        end
+
+        def idempotency_key(input)
+          payload = input["payload"]
+          if payload.is_a?(Hash) && payload["type"] == "transaction" && payload["signature"].is_a?(String)
+            hex = payload["signature"].delete_prefix("0x")
+            if hex.match?(/\A[0-9a-fA-F]+\z/) && hex.length.even?
+              hash = Attribution.keccak256([hex].pack("H*"))
+              return "mpp_0x#{hash.unpack1("H*")}"
+            end
+          end
+
+          digest = Digest::SHA256.hexdigest(Mpp::Json.compact_encode(input))
+          "mpp_0x#{digest}"
+        end
+
+        def success?(response)
+          response.is_a?(Hash) && response["success"] == true
+        end
+
+        def broadcast_success?(response)
+          success?(response) && relay_receipt?(response["receipt"])
+        end
+
+        def relay_receipt?(value)
+          value.is_a?(Hash) &&
+            value["method"].is_a?(String) &&
+            value["reference"].is_a?(String) &&
+            value["timestamp"].is_a?(String) &&
+            (value["externalId"].nil? || value["externalId"].is_a?(String))
+        end
+
+        def to_receipt(receipt)
+          timestamp = begin
+            Time.iso8601(receipt["timestamp"].to_s.gsub("Z", "+00:00"))
+          rescue ArgumentError
+            raise failure
+          end
+
+          Mpp::Receipt.success(
+            receipt["reference"],
+            timestamp: timestamp,
+            method: receipt["method"],
+            external_id: receipt["externalId"]
+          )
+        end
+
+        def failure(response = nil)
+          code = relay_error_code(response)
+          return Mpp::PaymentExpiredError.new if code == "expired"
+
+          reason = case code
+          when "already_used", "broadcast_failed", "insufficient_funds", "invalid_payment",
+            "simulation_failed", "unsupported", "temporarily_unavailable"
+            code.tr("_", " ")
+          end
+          Mpp::VerificationFailedError.new(reason: reason)
+        end
+
+        def relay_error_code(value)
+          return unless value.is_a?(Hash)
+
+          error = value["error"]
+          return unless error.is_a?(Hash)
+
+          code = error["code"]
+          code if ERROR_CODES.include?(code)
+        end
+      end
+    end
+  end
+end

data/lib/mpp/methods/tempo.rb

@@ -11,6 +11,8 @@ module Mpp
       autoload :Rpc, "mpp/methods/tempo/rpc"
       autoload :Transaction, "mpp/methods/tempo/transaction"
       autoload :FeePayerPolicy, "mpp/methods/tempo/fee_payer_policy"
+      autoload :FeePayerClient, "mpp/methods/tempo/fee_payer_client"
+      autoload :Relay, "mpp/methods/tempo/relay"
       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

@@ -101,6 +101,12 @@ module Mpp
       opaque_b64 = params["opaque"]
       opaque = (opaque_b64 && !opaque_b64.empty?) ? b64_decode(opaque_b64) : nil
 
+      header = begin
+        Mpp.advertised_credential_header(params["header"])
+      rescue ArgumentError => e
+        Kernel.raise Mpp::ParseError, e.message
+      end
+
       Mpp::Challenge.new(
         id: id,
         method: method,
@@ -111,7 +117,8 @@ module Mpp
         digest: params["digest"],
         expires: params["expires"],
         description: params["description"],
-        opaque: opaque
+        opaque: opaque,
+        header: header
       )
     end
 
@@ -131,6 +138,9 @@ module Mpp
       parts << "digest=\"#{escape_quoted(challenge.digest)}\"" if challenge.digest
       parts << "expires=\"#{escape_quoted(challenge.expires)}\"" if challenge.expires
       parts << "description=\"#{escape_quoted(challenge.description)}\"" if challenge.description
+      if challenge.header
+        parts << "header=\"#{escape_quoted(challenge.header)}\""
+      end
       if challenge.opaque
         opaque_b64 = b64_encode(challenge.opaque)
         parts << "opaque=\"#{opaque_b64}\""
@@ -158,6 +168,12 @@ module Mpp
       method = challenge_data["method"]
       validate_payment_method_id(method)
 
+      header = begin
+        Mpp.advertised_credential_header(challenge_data["header"]&.to_s)
+      rescue ArgumentError => e
+        Kernel.raise Mpp::ParseError, e.message
+      end
+
       echo = Mpp::ChallengeEcho.new(
         id: challenge_data["id"].to_s,
         realm: (challenge_data["realm"] || "").to_s,
@@ -166,7 +182,8 @@ module Mpp
         request: (challenge_data["request"] || "").to_s,
         expires: challenge_data["expires"]&.to_s,
         digest: challenge_data["digest"]&.to_s,
-        opaque: challenge_data["opaque"]&.to_s
+        opaque: challenge_data["opaque"]&.to_s,
+        header: header
       )
 
       Mpp::Credential.new(
@@ -188,6 +205,7 @@ module Mpp
       }
       challenge_dict["expires"] = credential.challenge.expires if credential.challenge.expires
       challenge_dict["digest"] = credential.challenge.digest if credential.challenge.digest
+      challenge_dict["header"] = credential.challenge.header if credential.challenge.header
       challenge_dict["opaque"] = credential.challenge.opaque if credential.challenge.opaque
 
       payload = {
@@ -235,6 +253,7 @@ module Mpp
         reference: data["reference"].to_s,
         method: method,
         external_id: data["externalId"]&.to_s,
+        subscription_id: data["subscriptionId"]&.to_s,
         extra: extra
       )
     end
@@ -256,6 +275,7 @@ module Mpp
         "timestamp" => timestamp_str
       }
       payload["externalId"] = receipt.external_id if receipt.external_id
+      payload["subscriptionId"] = receipt.subscription_id if receipt.subscription_id
       payload["extra"] = receipt.extra if receipt.extra
 
       b64_encode(payload)