mpp-rb 0.1.0

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

@@ -0,0 +1,259 @@
+# typed: false
+# frozen_string_literal: true
+
+require_relative "defaults"
+require_relative "transaction"
+
+module Mpp
+  module Methods
+    module Tempo
+      DEFAULT_GAS_LIMIT = 1_000_000
+      EXPIRING_NONCE_KEY = (1 << 256) - 1 # U256::MAX
+      FEE_PAYER_VALID_BEFORE_SECS = 25
+
+      class TransactionError < StandardError; end
+
+      # Tempo payment method implementation.
+      # Handles client-side credential creation for Tempo payments.
+      class TempoMethod
+        attr_reader :name, :account, :fee_payer, :root_account, :rpc_url,
+          :chain_id, :currency, :recipient, :decimals, :client_id,
+          :expected_recipients
+        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)
+          @name = "tempo"
+          @account = account
+          @fee_payer = fee_payer
+          @root_account = root_account
+          @rpc_url = rpc_url
+          @chain_id = chain_id
+          @currency = currency
+          @recipient = recipient
+          @decimals = decimals
+          @client_id = client_id
+          @expected_recipients = expected_recipients&.map(&:downcase)&.to_set
+          @intents = {}
+        end
+
+        # Create a credential to satisfy the given challenge.
+        #
+        # mode: :pull (default) — return signed transaction for server to broadcast
+        #        :push — broadcast on-chain, return transaction hash
+        #        :proof — zero-amount transaction proving account ownership
+        def create_credential(challenge, mode: nil)
+          raise ArgumentError, "No account configured for signing" unless @account
+          raise ArgumentError, "Unsupported intent: #{challenge.intent}" unless challenge.intent == "charge"
+
+          mode ||= :pull
+          request = challenge.request
+          method_details = request["methodDetails"]
+          method_details = {} unless method_details.is_a?(Hash)
+
+          validate_recipients(request, method_details) if @expected_recipients
+
+          use_fee_payer = method_details.fetch("feePayer", false)
+
+          nonce_key = request.fetch("nonce_key", 0)
+          if nonce_key.is_a?(String)
+            nonce_key = nonce_key.start_with?("0x") ? nonce_key.to_i(16) : nonce_key.to_i
+          end
+
+          memo = method_details["memo"]
+          memo ||= Attribution.encode(server_id: challenge.realm, client_id: @client_id, challenge_id: challenge.id)
+
+          # Resolve RPC URL from challenge's chainId
+          resolved_rpc_url = @rpc_url
+          expected_chain_id = nil
+          challenge_chain_id = method_details["chainId"]
+          if challenge_chain_id
+            begin
+              parsed_chain_id = Integer(challenge_chain_id)
+              resolved = Defaults::CHAIN_RPC_URLS[parsed_chain_id]
+              if resolved
+                resolved_rpc_url = resolved
+                expected_chain_id = parsed_chain_id
+              end
+            rescue ArgumentError, TypeError
+              # ignore
+            end
+          end
+
+          expected_chain_id ||= @chain_id
+
+          # Proof mode: sign EIP-712 typed data (no transaction needed)
+          if mode == :proof
+            chain_id = expected_chain_id || @chain_id
+            raise ArgumentError, "chain_id required for proof mode" unless chain_id
+
+            signature = Proof.sign(
+              account: @account,
+              chain_id: chain_id,
+              challenge_id: challenge.id
+            )
+
+            return Mpp::Credential.new(
+              challenge: challenge.to_echo,
+              payload: {"type" => "proof", "signature" => signature},
+              source: Proof.source(address: @account.address, chain_id: chain_id)
+            )
+          end
+
+          raw_tx, chain_id = build_tempo_transfer(
+            amount: request["amount"],
+            currency: request["currency"],
+            recipient: request["recipient"],
+            nonce_key: nonce_key,
+            memo: memo,
+            rpc_url: resolved_rpc_url,
+            expected_chain_id: expected_chain_id,
+            awaiting_fee_payer: use_fee_payer
+          )
+
+          payload = if mode == :push
+            tx_hash = Rpc.call(resolved_rpc_url, "eth_sendRawTransaction", [raw_tx])
+            raise TransactionError, "No transaction hash returned" unless tx_hash
+            {"type" => "hash", "hash" => tx_hash}
+          else
+            {"type" => "transaction", "signature" => raw_tx}
+          end
+
+          Mpp::Credential.new(
+            challenge: challenge.to_echo,
+            payload: payload,
+            source: "did:pkh:eip155:#{chain_id}:#{@account.address}"
+          )
+        end
+
+        # Transform request - adds default methodDetails if needed.
+        def transform_request(request, _credential)
+          request
+        end
+
+        private
+
+        def validate_recipients(request, method_details)
+          recipient = request["recipient"]
+          if recipient && !@expected_recipients.include?(recipient.downcase)
+            raise ArgumentError, "Unexpected recipient: #{recipient}"
+          end
+
+          splits = method_details["splits"]
+          return unless splits.is_a?(Array)
+
+          splits.each do |split|
+            addr = split["recipient"]
+            next unless addr
+            unless @expected_recipients.include?(addr.downcase)
+              raise ArgumentError, "Unexpected split recipient: #{addr}"
+            end
+          end
+        end
+
+        def build_tempo_transfer(amount:, currency:, recipient:, nonce_key: 0,
+          memo: nil, rpc_url: nil, expected_chain_id: nil,
+          awaiting_fee_payer: false)
+          raise ArgumentError, "No account configured" unless @account
+
+          resolved_rpc = rpc_url || @rpc_url
+
+          transfer_data = if memo
+            encode_transfer_with_memo(recipient, Integer(amount), memo)
+          else
+            encode_transfer(recipient, Integer(amount))
+          end
+
+          chain_id, on_chain_nonce, gas_price = Rpc.get_tx_params(resolved_rpc, @account.address)
+
+          if expected_chain_id && chain_id != expected_chain_id
+            raise TransactionError,
+              "Chain ID mismatch: RPC returned #{chain_id}, expected #{expected_chain_id} from challenge"
+          end
+
+          if awaiting_fee_payer
+            resolved_nonce_key = EXPIRING_NONCE_KEY
+            resolved_nonce = 0
+            valid_before = Time.now.to_i + FEE_PAYER_VALID_BEFORE_SECS
+          else
+            resolved_nonce_key = nonce_key
+            resolved_nonce = on_chain_nonce
+            valid_before = nil
+          end
+
+          gas_limit = DEFAULT_GAS_LIMIT
+          begin
+            estimated = Rpc.estimate_gas(resolved_rpc, @account.address, currency, transfer_data)
+            gas_limit = [gas_limit, estimated + 5_000].max
+          rescue
+            # fallback to default
+          end
+          Transaction.build_signed_transfer(
+            account: @account,
+            chain_id: chain_id,
+            gas_limit: gas_limit,
+            gas_price: gas_price,
+            nonce: resolved_nonce,
+            nonce_key: resolved_nonce_key,
+            currency: currency,
+            transfer_data: transfer_data,
+            valid_before: valid_before,
+            awaiting_fee_payer: awaiting_fee_payer
+          )
+        rescue LoadError => e
+          raise TransactionError, e.message
+        end
+
+        def encode_transfer(to, amount)
+          selector = "a9059cbb"
+          to_padded = to.delete_prefix("0x").downcase.rjust(64, "0")
+          amount_padded = amount.to_s(16).rjust(64, "0")
+          "0x#{selector}#{to_padded}#{amount_padded}"
+        end
+
+        def encode_transfer_with_memo(to, amount, memo)
+          selector = "95777d59"
+          to_padded = to.delete_prefix("0x").downcase.rjust(64, "0")
+          amount_padded = amount.to_s(16).rjust(64, "0")
+          memo_clean = memo.delete_prefix("0x")
+          unless memo_clean.length == 64
+            raise ArgumentError,
+              "memo must be exactly 32 bytes (64 hex chars), got #{memo_clean.length}"
+          end
+
+          "0x#{selector}#{to_padded}#{amount_padded}#{memo_clean.downcase}"
+        end
+      end
+
+      # 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)
+        rpc_url ||= chain_id ? Defaults.rpc_url_for_chain(chain_id) : Defaults::RPC_URL
+        currency ||= Defaults.default_currency_for_chain(chain_id)
+
+        method = TempoMethod.new(
+          account: account,
+          fee_payer: fee_payer,
+          rpc_url: rpc_url,
+          chain_id: chain_id,
+          root_account: root_account,
+          currency: currency,
+          recipient: recipient,
+          decimals: decimals,
+          client_id: client_id,
+          expected_recipients: expected_recipients
+        )
+
+        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)
+        end
+        method.intents = intents.dup
+        method
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Mpp
+  module Methods
+    module Tempo
+      module Defaults
+        # Mainnet
+        CHAIN_ID = 4217
+        RPC_URL = "https://rpc.tempo.xyz"
+        PATH_USD = "0x20c0000000000000000000000000000000000000"
+        USDC = "0x20C000000000000000000000b9537d11c60E8b50"
+        PATH_USD_DECIMALS = 6
+
+        # Testnet (Moderato)
+        TESTNET_CHAIN_ID = 42_431
+        TESTNET_RPC_URL = "https://rpc.moderato.tempo.xyz"
+
+        # Testnet only - fee payer service sponsors gas on testnet
+        DEFAULT_FEE_PAYER_URL = "https://sponsor.moderato.tempo.xyz"
+
+        # Chain ID -> default currency mapping
+        DEFAULT_CURRENCIES = T.let({
+          CHAIN_ID => USDC,
+          TESTNET_CHAIN_ID => PATH_USD
+        }.freeze, T::Hash[T.untyped, T.untyped])
+
+        # Chain ID -> default RPC URL mapping
+        CHAIN_RPC_URLS = T.let({
+          CHAIN_ID => RPC_URL,
+          TESTNET_CHAIN_ID => TESTNET_RPC_URL
+        }.freeze, T::Hash[T.untyped, T.untyped])
+
+        # Chain ID -> escrow contract address mapping
+        ESCROW_CONTRACTS = T.let({
+          CHAIN_ID => "0x33b901018174DDabE4841042ab76ba85D4e24f25",
+          TESTNET_CHAIN_ID => "0xe1c4d3dce17bc111181ddf716f75bae49e61a336"
+        }.freeze, T::Hash[T.untyped, T.untyped])
+
+        extend T::Sig
+
+        module_function
+
+        sig { params(chain_id: Integer).returns(String) }
+        def rpc_url_for_chain(chain_id)
+          url = CHAIN_RPC_URLS[chain_id]
+          return url if url
+
+          Kernel.raise ArgumentError,
+            "Unknown chain_id #{chain_id}. Known chains: #{CHAIN_RPC_URLS.keys}. Pass rpc_url explicitly."
+        end
+
+        sig { params(chain_id: T.nilable(Integer)).returns(String) }
+        def default_currency_for_chain(chain_id)
+          return PATH_USD if chain_id.nil?
+
+          DEFAULT_CURRENCIES.fetch(chain_id, PATH_USD)
+        end
+
+        sig { params(chain_id: T.nilable(Integer), testnet: T::Boolean).returns(String) }
+        def resolve_currency(chain_id: nil, testnet: false)
+          id = chain_id || (testnet ? TESTNET_CHAIN_ID : CHAIN_ID)
+          DEFAULT_CURRENCIES.fetch(id, PATH_USD)
+        end
+
+        sig { params(chain_id: Integer).returns(String) }
+        def escrow_contract_for_chain(chain_id)
+          addr = ESCROW_CONTRACTS[chain_id]
+          return addr if addr
+
+          Kernel.raise ArgumentError,
+            "Unknown chain_id #{chain_id}. Known chains: #{ESCROW_CONTRACTS.keys}. Pass escrow_contract explicitly."
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# typed: false
+# frozen_string_literal: true
+
+module Mpp
+  module Methods
+    module Tempo
+      module FeePayer
+        TYPE_ID = 0x78
+
+        module_function
+
+        # Encode a sender-signed transaction as a 0x78 fee payer envelope.
+        # Requires the `rlp` gem.
+        #
+        # Wire format: 0x78 || RLP([fields...])
+        def encode(signed_tx)
+          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
+
+          fields = [
+            signed_tx.chain_id,
+            signed_tx.max_priority_fee_per_gas,
+            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.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,
+            sender_addr,
+            signed_tx.tempo_authorization_list.to_a
+          ]
+
+          fields << RLP.decode(signed_tx.key_authorization) if signed_tx.key_authorization
+          fields << sig_bytes
+
+          [TYPE_ID].pack("C") + RLP.include(fields)
+        end
+
+        # Decode a 0x78 fee payer envelope.
+        #
+        # Returns [decoded_fields, sender_address_bytes, sender_signature_bytes, key_authorization_or_nil]
+        def decode(data)
+          Kernel.require "rlp"
+
+          Kernel.raise ArgumentError, "Not a fee payer envelope (expected 0x78 prefix)" unless data.getbyte(0) == TYPE_ID
+
+          decoded = RLP.decode(data[1..])
+          Kernel.raise ArgumentError, "Malformed fee payer envelope" unless decoded.is_a?(Array) && decoded.length >= 14
+
+          sender_address = decoded[11]
+          sender_signature = decoded[-1]
+
+          # 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)
+
+          [decoded, sender_address.to_s.b, sender_signature.to_s.b, key_authorization]
+        end
+
+        def encode_optional_uint(value)
+          return "".b unless value
+
+          value.is_a?(Integer) ? value : value.to_i
+        end
+      end
+    end
+  end
+end