eth 0.5.14 → 0.5.16

data/lib/eth/eip712.rb

@@ -47,7 +47,12 @@ module Eth
 
         # recursively look for further nested dependencies
         types[primary_type.to_sym].each do |t|
-          dependency = type_dependencies t[:type], types, result
+          nested_type = t[:type]
+          # unpack arrays to their inner types to resolve dependencies
+          if nested_type.end_with?("]")
+            nested_type = nested_type.partition("[").first
+          end
+          dependency = type_dependencies nested_type, types, result
         end
         return result
       end
@@ -113,19 +118,12 @@ module Eth
       types[primary_type.to_sym].each do |field|
         value = data[field[:name].to_sym]
         type = field[:type]
-        if type == "string"
-          encoded_types.push "bytes32"
-          encoded_values.push Util.keccak256 value
-        elsif type == "bytes"
-          encoded_types.push "bytes32"
-          value = Util.hex_to_bin value
-          encoded_values.push Util.keccak256 value
-        elsif !types[type.to_sym].nil?
+        if type.end_with?("]")
+          encoded_types.push type
+          encoded_values.push encode_array(type, value, types)
+        elsif type == "string" || type == "bytes" || !types[type.to_sym].nil?
           encoded_types.push "bytes32"
-          value = encode_data type, value, types
-          encoded_values.push Util.keccak256 value
-        elsif type.end_with? "]"
-          raise NotImplementedError, "Arrays currently unimplemented for EIP-712."
+          encoded_values.push encode_value(type, value, types)
         else
           encoded_types.push type
           encoded_values.push value
@@ -136,6 +134,43 @@ module Eth
       return Abi.encode encoded_types, encoded_values
     end
 
+    # Encodes a single value according to its type following EIP-712 rules.
+    # Returns a 32-byte binary string.
+    def encode_value(type, value, types)
+      if type == "string"
+        return Util.keccak256 value
+      elsif type == "bytes"
+        value = Util.hex_to_bin value
+        return Util.keccak256 value
+      elsif !types[type.to_sym].nil?
+        nested = encode_data type, value, types
+        return Util.keccak256 nested
+      else
+        # encode basic types via ABI to get 32-byte representation
+        return Abi.encode([type], [value])
+      end
+    end
+
+    # Prepares array values by encoding each element according to its
+    # base type. Returns an array compatible with Abi.encode.
+    def encode_array(type, value, types)
+      inner_type = type.slice(0, type.rindex("["))
+      return [] if value.nil?
+      value.map do |v|
+        if inner_type.end_with?("]")
+          encode_array inner_type, v, types
+        elsif inner_type == "string"
+          Util.keccak256 v
+        elsif inner_type == "bytes"
+          Util.keccak256 Util.hex_to_bin(v)
+        elsif !types[inner_type.to_sym].nil?
+          Util.keccak256 encode_data(inner_type, v, types)
+        else
+          v
+        end
+      end
+    end
+
     # Recursively ABI-encodes and hashes all data and types.
     #
     # @param primary_type [String] the primary type which we want to hash.

data/lib/eth/key.rb

@@ -75,7 +75,7 @@ module Eth
       signature = compact.bytes
       v = Chain.to_v recovery_id, chain_id
       leading_zero = true
-      [v].pack("N").unpack("C*").each do |byte|
+      [v].pack("Q>").unpack("C*").each do |byte|
         leading_zero = false if byte > 0 and leading_zero
         signature.append byte unless leading_zero and byte === 0
       end

data/lib/eth/tx/eip1559.rb

@@ -78,7 +78,7 @@ module Eth
       # @option params [Integer] :max_gas_fee the max transaction fee per gas.
       # @option params [Integer] :gas_limit the gas limit.
       # @option params [Eth::Address] :from the sender address.
-      # @option params [Eth::Address] :to the reciever address.
+      # @option params [Eth::Address] :to the receiver address.
       # @option params [Integer] :value the transaction value.
       # @option params [String] :data the transaction data payload.
       # @option params [Array] :access_list an optional access list.
@@ -148,13 +148,13 @@ module Eth
         raise ParameterError, "Transaction missing fields!" if tx.size < 9
 
         # populate the 9 payload fields
-        chain_id = Util.deserialize_big_endian_to_int tx[0]
-        nonce = Util.deserialize_big_endian_to_int tx[1]
-        priority_fee = Util.deserialize_big_endian_to_int tx[2]
-        max_gas_fee = Util.deserialize_big_endian_to_int tx[3]
-        gas_limit = Util.deserialize_big_endian_to_int tx[4]
+        chain_id = Util.deserialize_rlp_int tx[0]
+        nonce = Util.deserialize_rlp_int tx[1]
+        priority_fee = Util.deserialize_rlp_int tx[2]
+        max_gas_fee = Util.deserialize_rlp_int tx[3]
+        gas_limit = Util.deserialize_rlp_int tx[4]
         to = Util.bin_to_hex tx[5]
-        value = Util.deserialize_big_endian_to_int tx[6]
+        value = Util.deserialize_rlp_int tx[6]
         data = tx[7]
         access_list = tx[8]
 
@@ -257,6 +257,31 @@ module Eth
         return hash
       end
 
+      # Signs the transaction with a provided signature blob.
+      #
+      # @param signature [String] the concatenated `r`, `s`, and `v` values.
+      # @return [String] a transaction hash.
+      # @raise [Signature::SignatureError] if transaction is already signed.
+      # @raise [Signature::SignatureError] if sender address does not match signer.
+      def sign_with(signature)
+        if Tx.signed? self
+          raise Signature::SignatureError, "Transaction is already signed!"
+        end
+
+        # ensure the sender address matches the signature
+        unless @sender.nil? or sender.empty?
+          public_key = Signature.recover(unsigned_hash, signature, @chain_id)
+          signer_address = Tx.sanitize_address Util.public_key_to_address(public_key).to_s
+          from_address = Tx.sanitize_address @sender
+          raise Signature::SignatureError, "Signer does not match sender" unless signer_address == from_address
+        end
+
+        r, s, v = Signature.dissect signature
+        recovery_id = Chain.to_recovery_id v.to_i(16), @chain_id
+        send :_set_signature, recovery_id, r, s
+        return hash
+      end
+
       # Encodes a raw transaction object, wraps it in an EIP-2718 envelope
       # with an EIP-1559 type prefix.
       #

data/lib/eth/tx/eip2930.rb

@@ -76,7 +76,7 @@ module Eth
       # @option params [Integer] :gas_price the gas price.
       # @option params [Integer] :gas_limit the gas limit.
       # @option params [Eth::Address] :from the sender address.
-      # @option params [Eth::Address] :to the reciever address.
+      # @option params [Eth::Address] :to the receiver address.
       # @option params [Integer] :value the transaction value.
       # @option params [String] :data the transaction data payload.
       # @option params [Array] :access_list an optional access list.
@@ -145,12 +145,12 @@ module Eth
         raise ParameterError, "Transaction missing fields!" if tx.size < 8
 
         # populate the 8 payload fields
-        chain_id = Util.deserialize_big_endian_to_int tx[0]
-        nonce = Util.deserialize_big_endian_to_int tx[1]
-        gas_price = Util.deserialize_big_endian_to_int tx[2]
-        gas_limit = Util.deserialize_big_endian_to_int tx[3]
+        chain_id = Util.deserialize_rlp_int tx[0]
+        nonce = Util.deserialize_rlp_int tx[1]
+        gas_price = Util.deserialize_rlp_int tx[2]
+        gas_limit = Util.deserialize_rlp_int tx[3]
         to = Util.bin_to_hex tx[4]
-        value = Util.deserialize_big_endian_to_int tx[5]
+        value = Util.deserialize_rlp_int tx[5]
         data = tx[6]
         access_list = tx[7]
 
@@ -251,6 +251,31 @@ module Eth
         return hash
       end
 
+      # Signs the transaction with a provided signature blob.
+      #
+      # @param signature [String] the concatenated `r`, `s`, and `v` values.
+      # @return [String] a transaction hash.
+      # @raise [Signature::SignatureError] if transaction is already signed.
+      # @raise [Signature::SignatureError] if sender address does not match signer.
+      def sign_with(signature)
+        if Tx.signed? self
+          raise Signature::SignatureError, "Transaction is already signed!"
+        end
+
+        # ensure the sender address matches the signature
+        unless @sender.nil? or sender.empty?
+          public_key = Signature.recover(unsigned_hash, signature, @chain_id)
+          signer_address = Tx.sanitize_address Util.public_key_to_address(public_key).to_s
+          from_address = Tx.sanitize_address @sender
+          raise Signature::SignatureError, "Signer does not match sender" unless signer_address == from_address
+        end
+
+        r, s, v = Signature.dissect signature
+        recovery_id = Chain.to_recovery_id v.to_i(16), @chain_id
+        send :_set_signature, recovery_id, r, s
+        return hash
+      end
+
       # Encodes a raw transaction object, wraps it in an EIP-2718 envelope
       # with an EIP-2930 type prefix.
       #

data/lib/eth/tx/eip4844.rb

@@ -0,0 +1,401 @@
+# Copyright (c) 2016-2025 The Ruby-Eth Contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Provides the {Eth} module.
+module Eth
+
+  # Provides the `Tx` module supporting various transaction types.
+  module Tx
+
+    # Provides support for EIP-4844 transactions utilizing EIP-2718
+    # types and envelopes.
+    # Ref: https://eips.ethereum.org/EIPS/eip-4844
+    class Eip4844
+
+      # The blob gas consumed by a single blob.
+      GAS_PER_BLOB = (2 ** 17).freeze
+
+      # The target blob gas per block as per EIP-7691.
+      TARGET_BLOB_GAS_PER_BLOCK = 786_432.freeze
+
+      # The maximum blob gas allowed in a block as per EIP-7691.
+      MAX_BLOB_GAS_PER_BLOCK = 1_179_648.freeze
+
+      # The maximum number of blobs permitted in a single block.
+      MAX_BLOBS_PER_BLOCK = (MAX_BLOB_GAS_PER_BLOCK / GAS_PER_BLOB).freeze
+
+      # The EIP-155 Chain ID.
+      # Ref: https://eips.ethereum.org/EIPS/eip-155
+      attr_reader :chain_id
+
+      # The transaction nonce provided by the signer.
+      attr_reader :signer_nonce
+
+      # The transaction max priority fee per gas in Wei.
+      attr_reader :max_priority_fee_per_gas
+
+      # The transaction max fee per gas in Wei.
+      attr_reader :max_fee_per_gas
+
+      # The gas limit for the transaction.
+      attr_reader :gas_limit
+
+      # The recipient address.
+      attr_reader :destination
+
+      # The transaction amount in Wei.
+      attr_reader :amount
+
+      # The transaction data payload.
+      attr_reader :payload
+
+      # An optional EIP-2930 access list.
+      # Ref: https://eips.ethereum.org/EIPS/eip-2930
+      attr_reader :access_list
+
+      # The transaction max fee per blob gas in Wei.
+      attr_reader :max_fee_per_blob_gas
+
+      # The list of KZG commitment versioned hashes.
+      attr_reader :blob_versioned_hashes
+
+      # The signature's y-parity byte (not v).
+      attr_reader :signature_y_parity
+
+      # The signature `r` value.
+      attr_reader :signature_r
+
+      # The signature `s` value.
+      attr_reader :signature_s
+
+      # The sender address.
+      attr_reader :sender
+
+      # The transaction type.
+      attr_reader :type
+
+      # Create a type-3 (EIP-4844) transaction payload object that
+      # can be prepared for envelope, signature and broadcast.
+      # Ref: https://eips.ethereum.org/EIPS/eip-4844
+      #
+      # @param params [Hash] all necessary transaction fields.
+      # @option params [Integer] :chain_id the chain ID.
+      # @option params [Integer] :nonce the signer nonce.
+      # @option params [Integer] :priority_fee the max priority fee per gas.
+      # @option params [Integer] :max_gas_fee the max transaction fee per gas.
+      # @option params [Integer] :gas_limit the gas limit.
+      # @option params [Eth::Address] :from the sender address.
+      # @option params [Eth::Address] :to the receiver address.
+      # @option params [Integer] :value the transaction value.
+      # @option params [String] :data the transaction data payload.
+      # @option params [Array] :access_list an optional access list.
+      # @option params [Integer] :max_fee_per_blob_gas the max blob fee per gas.
+      # @option params [Array] :blob_versioned_hashes the blob versioned hashes (max 9).
+      # @raise [ParameterError] if gas limit is too low.
+      def initialize(params)
+        fields = { recovery_id: nil, r: 0, s: 0 }.merge params
+
+        # populate optional fields with serializable empty values
+        fields[:chain_id] = Tx.sanitize_chain fields[:chain_id]
+        fields[:from] = Tx.sanitize_address fields[:from]
+        fields[:to] = Tx.sanitize_address fields[:to]
+        fields[:value] = Tx.sanitize_amount fields[:value]
+        fields[:data] = Tx.sanitize_data fields[:data]
+
+        # ensure sane values for all mandatory fields
+        fields = Tx.validate_params fields
+        fields = Tx.validate_eip1559_params fields
+        fields = Tx.validate_eip4844_params fields
+        fields[:access_list] = Tx.sanitize_list fields[:access_list]
+        fields[:blob_versioned_hashes] = Tx.sanitize_hashes fields[:blob_versioned_hashes]
+
+        # ensure gas limit is not too low
+        minimum_cost = Tx.estimate_intrinsic_gas fields[:data], fields[:access_list]
+        raise ParameterError, "Transaction gas limit is too low, try #{minimum_cost}!" if fields[:gas_limit].to_i < minimum_cost
+
+        # populate class attributes
+        @signer_nonce = fields[:nonce].to_i
+        @max_priority_fee_per_gas = fields[:priority_fee].to_i
+        @max_fee_per_gas = fields[:max_gas_fee].to_i
+        @gas_limit = fields[:gas_limit].to_i
+        @sender = fields[:from].to_s
+        @destination = fields[:to].to_s
+        @amount = fields[:value].to_i
+        @payload = fields[:data]
+        @access_list = fields[:access_list]
+        @max_fee_per_blob_gas = fields[:max_fee_per_blob_gas].to_i
+        @blob_versioned_hashes = fields[:blob_versioned_hashes]
+
+        # the signature v is set to the chain id for unsigned transactions
+        @signature_y_parity = fields[:recovery_id]
+        @chain_id = fields[:chain_id]
+
+        # the signature fields are empty for unsigned transactions.
+        @signature_r = fields[:r]
+        @signature_s = fields[:s]
+
+        # last but not least, set the type.
+        @type = TYPE_4844
+      end
+
+      # Overloads the constructor for decoding raw transactions and creating unsigned copies.
+      konstructor :decode, :unsigned_copy
+
+      # Decodes a raw transaction hex into an {Eth::Tx::Eip4844}
+      # transaction object.
+      #
+      # @param hex [String] the raw transaction hex-string.
+      # @return [Eth::Tx::Eip4844] transaction payload.
+      # @raise [TransactionTypeError] if transaction type is invalid.
+      # @raise [ParameterError] if transaction is missing fields.
+      # @raise [DecoderError] if transaction decoding fails.
+      def decode(hex)
+        hex = Util.remove_hex_prefix hex
+        type = hex[0, 2]
+        raise TransactionTypeError, "Invalid transaction type #{type}!" if type.to_i(16) != TYPE_4844
+
+        bin = Util.hex_to_bin hex[2..]
+        tx = Rlp.decode bin
+
+        # decoded transactions always have 11 + 3 fields, even if they are empty or zero
+        raise ParameterError, "Transaction missing fields!" if tx.size < 11
+
+        # populate the 11 payload fields
+        chain_id = Util.deserialize_rlp_int tx[0]
+        nonce = Util.deserialize_rlp_int tx[1]
+        priority_fee = Util.deserialize_rlp_int tx[2]
+        max_gas_fee = Util.deserialize_rlp_int tx[3]
+        gas_limit = Util.deserialize_rlp_int tx[4]
+        to = Util.bin_to_hex tx[5]
+        value = Util.deserialize_rlp_int tx[6]
+        data = tx[7]
+        access_list = tx[8]
+        max_fee_per_blob_gas = Util.deserialize_rlp_int tx[9]
+        blob_versioned_hashes = tx[10]
+
+        # populate class attributes
+        @chain_id = chain_id.to_i
+        @signer_nonce = nonce.to_i
+        @max_priority_fee_per_gas = priority_fee.to_i
+        @max_fee_per_gas = max_gas_fee.to_i
+        @gas_limit = gas_limit.to_i
+        @destination = to.to_s
+        @amount = value.to_i
+        @payload = data
+        @access_list = access_list
+        @max_fee_per_blob_gas = max_fee_per_blob_gas.to_i
+        @blob_versioned_hashes = blob_versioned_hashes
+
+        # populate the 3 signature fields
+        if tx.size == 11
+          _set_signature(nil, 0, 0)
+        elsif tx.size == 14
+          recovery_id = Util.bin_to_hex(tx[11]).to_i(16)
+          r = Util.bin_to_hex tx[12]
+          s = Util.bin_to_hex tx[13]
+
+          # allows us to force-setting a signature if the transaction is signed already
+          _set_signature(recovery_id, r, s)
+        else
+          raise DecoderError, "Cannot decode EIP-4844 payload!"
+        end
+
+        # last but not least, set the type.
+        @type = TYPE_4844
+
+        unless recovery_id.nil?
+          # recover sender address
+          v = Chain.to_v recovery_id, chain_id
+          public_key = Signature.recover(unsigned_hash, "#{r.rjust(64, "0")}#{s.rjust(64, "0")}#{v.to_s(16)}", chain_id)
+          address = Util.public_key_to_address(public_key).to_s
+          @sender = Tx.sanitize_address address
+        else
+          # keep the 'from' field blank
+          @sender = Tx.sanitize_address nil
+        end
+      end
+
+      # Creates an unsigned copy of a transaction payload.
+      #
+      # @param tx [Eth::Tx::Eip4844] an EIP-4844 transaction payload.
+      # @return [Eth::Tx::Eip4844] an unsigned EIP-4844 transaction payload.
+      # @raise [TransactionTypeError] if transaction type does not match.
+      def unsigned_copy(tx)
+
+        # not checking transaction validity unless it's of a different class
+        raise TransactionTypeError, "Cannot copy transaction of different payload type!" unless tx.instance_of? Tx::Eip4844
+
+        # populate class attributes
+        @signer_nonce = tx.signer_nonce
+        @max_priority_fee_per_gas = tx.max_priority_fee_per_gas
+        @max_fee_per_gas = tx.max_fee_per_gas
+        @gas_limit = tx.gas_limit
+        @destination = tx.destination
+        @amount = tx.amount
+        @payload = tx.payload
+        @access_list = tx.access_list
+        @max_fee_per_blob_gas = tx.max_fee_per_blob_gas
+        @blob_versioned_hashes = tx.blob_versioned_hashes
+        @chain_id = tx.chain_id
+
+        # force-set signature to unsigned
+        _set_signature(nil, 0, 0)
+
+        # keep the 'from' field blank
+        @sender = Tx.sanitize_address nil
+
+        # last but not least, set the type.
+        @type = TYPE_4844
+      end
+
+      # Sign the transaction with a given key.
+      #
+      # @param key [Eth::Key] the key-pair to use for signing.
+      # @return [String] a transaction hash.
+      # @raise [Signature::SignatureError] if transaction is already signed.
+      # @raise [Signature::SignatureError] if sender address does not match signing key.
+      def sign(key)
+        if Tx.signed? self
+          raise Signature::SignatureError, "Transaction is already signed!"
+        end
+
+        # ensure the sender address matches the given key
+        unless @sender.nil? or sender.empty?
+          signer_address = Tx.sanitize_address key.address.to_s
+          from_address = Tx.sanitize_address @sender
+          raise Signature::SignatureError, "Signer does not match sender" unless signer_address == from_address
+        end
+
+        # sign a keccak hash of the unsigned, encoded transaction
+        signature = key.sign(unsigned_hash, @chain_id)
+        r, s, v = Signature.dissect signature
+        recovery_id = Chain.to_recovery_id v.to_i(16), @chain_id
+        @signature_y_parity = recovery_id
+        @signature_r = r
+        @signature_s = s
+        return hash
+      end
+
+      # Signs the transaction with a provided signature blob.
+      #
+      # @param signature [String] the concatenated `r`, `s`, and `v` values.
+      # @return [String] a transaction hash.
+      # @raise [Signature::SignatureError] if transaction is already signed.
+      # @raise [Signature::SignatureError] if sender address does not match signer.
+      def sign_with(signature)
+        if Tx.signed? self
+          raise Signature::SignatureError, "Transaction is already signed!"
+        end
+
+        # ensure the sender address matches the signature
+        unless @sender.nil? or sender.empty?
+          public_key = Signature.recover(unsigned_hash, signature, @chain_id)
+          signer_address = Tx.sanitize_address Util.public_key_to_address(public_key).to_s
+          from_address = Tx.sanitize_address @sender
+          raise Signature::SignatureError, "Signer does not match sender" unless signer_address == from_address
+        end
+
+        r, s, v = Signature.dissect signature
+        recovery_id = Chain.to_recovery_id v.to_i(16), @chain_id
+        send :_set_signature, recovery_id, r, s
+        return hash
+      end
+
+      # Encodes a raw transaction object, wraps it in an EIP-2718 envelope
+      # with an EIP-4844 type prefix.
+      #
+      # @return [String] a raw, RLP-encoded EIP-4844 type transaction object.
+      # @raise [Signature::SignatureError] if the transaction is not yet signed.
+      def encoded
+        unless Tx.signed? self
+          raise Signature::SignatureError, "Transaction is not signed!"
+        end
+        tx_data = []
+        tx_data.push Util.serialize_int_to_big_endian @chain_id
+        tx_data.push Util.serialize_int_to_big_endian @signer_nonce
+        tx_data.push Util.serialize_int_to_big_endian @max_priority_fee_per_gas
+        tx_data.push Util.serialize_int_to_big_endian @max_fee_per_gas
+        tx_data.push Util.serialize_int_to_big_endian @gas_limit
+        tx_data.push Util.hex_to_bin @destination
+        tx_data.push Util.serialize_int_to_big_endian @amount
+        tx_data.push Rlp::Sedes.binary.serialize @payload
+        tx_data.push Rlp::Sedes.infer(@access_list).serialize @access_list
+        tx_data.push Util.serialize_int_to_big_endian @max_fee_per_blob_gas
+        tx_data.push Rlp::Sedes.infer(@blob_versioned_hashes).serialize @blob_versioned_hashes
+        tx_data.push Util.serialize_int_to_big_endian @signature_y_parity
+        tx_data.push Util.serialize_int_to_big_endian @signature_r
+        tx_data.push Util.serialize_int_to_big_endian @signature_s
+        tx_encoded = Rlp.encode tx_data
+
+        # create an EIP-2718 envelope with EIP-4844 type payload
+        tx_type = Util.serialize_int_to_big_endian @type
+        return "#{tx_type}#{tx_encoded}"
+      end
+
+      # Gets the encoded, enveloped, raw transaction hex.
+      #
+      # @return [String] the raw transaction hex.
+      def hex
+        Util.bin_to_hex encoded
+      end
+
+      # Gets the transaction hash.
+      #
+      # @return [String] the transaction hash.
+      def hash
+        Util.bin_to_hex Util.keccak256 encoded
+      end
+
+      # Encodes the unsigned transaction payload in an EIP-4844 envelope,
+      # required for signing.
+      #
+      # @return [String] an RLP-encoded, unsigned, enveloped EIP-4844 transaction.
+      def unsigned_encoded
+        tx_data = []
+        tx_data.push Util.serialize_int_to_big_endian @chain_id
+        tx_data.push Util.serialize_int_to_big_endian @signer_nonce
+        tx_data.push Util.serialize_int_to_big_endian @max_priority_fee_per_gas
+        tx_data.push Util.serialize_int_to_big_endian @max_fee_per_gas
+        tx_data.push Util.serialize_int_to_big_endian @gas_limit
+        tx_data.push Util.hex_to_bin @destination
+        tx_data.push Util.serialize_int_to_big_endian @amount
+        tx_data.push Rlp::Sedes.binary.serialize @payload
+        tx_data.push Rlp::Sedes.infer(@access_list).serialize @access_list
+        tx_data.push Util.serialize_int_to_big_endian @max_fee_per_blob_gas
+        tx_data.push Rlp::Sedes.infer(@blob_versioned_hashes).serialize @blob_versioned_hashes
+        tx_encoded = Rlp.encode tx_data
+
+        # create an EIP-2718 envelope with EIP-4844 type payload (unsigned)
+        tx_type = Util.serialize_int_to_big_endian @type
+        return "#{tx_type}#{tx_encoded}"
+      end
+
+      # Gets the sign-hash required to sign a raw transaction.
+      #
+      # @return [String] a Keccak-256 hash of an unsigned transaction.
+      def unsigned_hash
+        Util.keccak256 unsigned_encoded
+      end
+
+      private
+
+      # Force-sets an existing signature of a decoded transaction.
+      def _set_signature(recovery_id, r, s)
+        @signature_y_parity = recovery_id
+        @signature_r = r
+        @signature_s = s
+      end
+    end
+  end
+end

data/lib/eth/tx/eip7702.rb

@@ -196,7 +196,7 @@ module Eth
       # @option params [Integer] :max_gas_fee the max transaction fee per gas.
       # @option params [Integer] :gas_limit the gas limit.
       # @option params [Eth::Address] :from the sender address.
-      # @option params [Eth::Address] :to the reciever address.
+      # @option params [Eth::Address] :to the receiver address.
       # @option params [Integer] :value the transaction value.
       # @option params [String] :data the transaction data payload.
       # @option params [Array] :access_list an optional access list.
@@ -269,13 +269,13 @@ module Eth
         raise ParameterError, "Transaction missing fields!" if tx.size < 10
 
         # populate the 10 payload fields
-        chain_id = Util.deserialize_big_endian_to_int tx[0]
-        nonce = Util.deserialize_big_endian_to_int tx[1]
-        priority_fee = Util.deserialize_big_endian_to_int tx[2]
-        max_gas_fee = Util.deserialize_big_endian_to_int tx[3]
-        gas_limit = Util.deserialize_big_endian_to_int tx[4]
+        chain_id = Util.deserialize_rlp_int tx[0]
+        nonce = Util.deserialize_rlp_int tx[1]
+        priority_fee = Util.deserialize_rlp_int tx[2]
+        max_gas_fee = Util.deserialize_rlp_int tx[3]
+        gas_limit = Util.deserialize_rlp_int tx[4]
         to = Util.bin_to_hex tx[5]
-        value = Util.deserialize_big_endian_to_int tx[6]
+        value = Util.deserialize_rlp_int tx[6]
         data = tx[7]
         access_list = tx[8]
         authorization_list = tx[9]
@@ -389,6 +389,31 @@ module Eth
         return hash
       end
 
+      # Signs the transaction with a provided signature blob.
+      #
+      # @param signature [String] the concatenated `r`, `s`, and `v` values.
+      # @return [String] a transaction hash.
+      # @raise [Signature::SignatureError] if transaction is already signed.
+      # @raise [Signature::SignatureError] if sender address does not match signer.
+      def sign_with(signature)
+        if Tx.signed? self
+          raise Signature::SignatureError, "Transaction is already signed!"
+        end
+
+        # ensure the sender address matches the signature
+        unless @sender.nil? or sender.empty?
+          public_key = Signature.recover(unsigned_hash, signature, @chain_id)
+          signer_address = Tx.sanitize_address Util.public_key_to_address(public_key).to_s
+          from_address = Tx.sanitize_address @sender
+          raise Signature::SignatureError, "Signer does not match sender" unless signer_address == from_address
+        end
+
+        r, s, v = Signature.dissect signature
+        recovery_id = Chain.to_recovery_id v.to_i(16), @chain_id
+        send :_set_signature, recovery_id, r, s
+        return hash
+      end
+
       # Encodes a raw transaction object, wraps it in an EIP-2718 envelope
       # with an EIP-7702 type prefix.
       #
@@ -474,9 +499,9 @@ module Eth
 
       def deserialize_authorizations(authorization_list)
         authorization_list.map do |authorization_tuple|
-          chain_id = Util.deserialize_big_endian_to_int authorization_tuple[0]
+          chain_id = Util.deserialize_rlp_int authorization_tuple[0]
           address = Util.bin_to_hex authorization_tuple[1]
-          nonce = Util.deserialize_big_endian_to_int authorization_tuple[2]
+          nonce = Util.deserialize_rlp_int authorization_tuple[2]
           recovery_id = Util.bin_to_hex(authorization_tuple[3]).to_i(16)
           r = Util.bin_to_hex authorization_tuple[4]
           s = Util.bin_to_hex authorization_tuple[5]