eth 0.5.0 → 0.5.3

data/lib/eth/rlp/sedes/big_endian_int.rb

@@ -0,0 +1,66 @@
+# Copyright (c) 2016-2022 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.
+
+# -*- encoding : ascii-8bit -*-
+
+# Provides the {Eth} module.
+module Eth
+
+  # Provides an recursive-length prefix (RLP) encoder and decoder.
+  module Rlp
+
+    # Provides serializable and deserializable types (SeDes).
+    module Sedes
+
+      # A serializable, big-endian, unsigned integer type.
+      class BigEndianInt
+
+        # Create a serializable, big-endian, unsigned integer.
+        #
+        # @param size [Integer] the size of the big endian.
+        def initialize(size = nil)
+          @size = size
+        end
+
+        # Serialize a big-endian integer.
+        #
+        # @param obj [Integer] the integer to be serialized.
+        # @return [String] a serialized big-endian integer.
+        # @raise [SerializationError] if provided object is not an integer.
+        # @raise [SerializationError] if provided integer is negative.
+        # @raise [SerializationError] if provided integer is too big for @size.
+        def serialize(obj)
+          raise SerializationError, "Can only serialize integers" unless obj.is_a?(Integer)
+          raise SerializationError, "Cannot serialize negative integers" if obj < 0
+          raise SerializationError, "Integer too large (does not fit in #{@size} bytes)" if @size && obj >= 256 ** @size
+          s = obj == 0 ? Constant::BYTE_EMPTY : Util.int_to_big_endian(obj)
+          @size ? "#{Constant::BYTE_ZERO * [0, @size - s.size].max}#{s}" : s
+        end
+
+        # Deserializes an unsigned integer.
+        #
+        # @param serial [String] the serialized integer.
+        # @return [Integer] a number.
+        # @raise [DeserializationError] if provided serial is of wrong size.
+        # @raise [DeserializationError] if provided serial is not of minimal length.
+        def deserialize(serial)
+          raise DeserializationError, "Invalid serialization (wrong size)" if @size && serial.size != @size
+          raise DeserializationError, "Invalid serialization (not minimal length)" if !@size && serial.size > 0 && serial[0] == Constant::BYTE_ZERO
+          serial = serial || Constant::BYTE_ZERO
+          Util.big_endian_to_int(serial)
+        end
+      end
+    end
+  end
+end

data/lib/eth/rlp/sedes/binary.rb

@@ -0,0 +1,97 @@
+# Copyright (c) 2016-2022 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.
+
+# -*- encoding : ascii-8bit -*-
+
+# Provides the {Eth} module.
+module Eth
+
+  # Provides an recursive-length prefix (RLP) encoder and decoder.
+  module Rlp
+
+    # Provides serializable and deserializable types (SeDes).
+    module Sedes
+
+      # A sedes type for binary values.
+      class Binary
+
+        # A singleton class for binary values of fixed length.
+        class << self
+
+          # Create a serializable bianry of fixed size.
+          #
+          # @param l [Integer] the fixed size of the binary.
+          # @param allow_empty [Boolean] indicator wether empty binaries should be allowed.
+          # @return [Eth::Rlp::Sedes::Binary] a serializable binary of fixed size.
+          def fixed_length(l, allow_empty: false)
+            new(min_length: l, max_length: l, allow_empty: allow_empty)
+          end
+
+          # Checks wether the given object is of a valid binary type.
+          #
+          # @param obj [Object] the supposed binary item to check.
+          # @return [Boolean] true if valid.
+          def valid_type?(obj)
+            obj.instance_of? String
+          end
+        end
+
+        # Create a serializable bianry of variable size.
+        #
+        # @param min_length [Integer] the minimum size of the binary.
+        # @param max_length [Integer] the maximum size of the binary.
+        # @param allow_empty [Boolean] indicator wether empty binaries should be allowed.
+        def initialize(min_length: 0, max_length: Constant::INFINITY, allow_empty: false)
+          @min_length = min_length
+          @max_length = max_length
+          @allow_empty = allow_empty
+        end
+
+        # Serializes a binary.
+        #
+        # @param obj [String] the binary to serialize.
+        # @return [Object] a serialized binary.
+        # @raise [SerializationError] if provided object is of invalid type.
+        # @raise [SerializationError] if provided binary is of invalid length.
+        def serialize(obj)
+          raise SerializationError, "Object is not a serializable (#{obj.class})" unless self.class.valid_type? obj
+          serial = Util.str_to_bytes obj
+          raise SerializationError, "Object has invalid length" unless valid_length? serial.size
+          serial
+        end
+
+        # Deserializes a binary.
+        #
+        # @param serial [Object] the serialized binary.
+        # @return [String] a deserialized binary.
+        # @raise [DeserializationError] if provided serial is of wrong type.
+        # @raise [DeserializationError] if provided serial is of wrong length.
+        def deserialize(serial)
+          raise DeserializationError, "Objects of type #{serial.class} cannot be deserialized" unless Util.is_primitive? serial
+          raise DeserializationError, "#{serial.class} has invalid length" unless valid_length? serial.size
+          serial
+        end
+
+        # Checks wether the given length fits the defined size boundaries of the
+        # binary type.
+        #
+        # @param length [Integer] the supposed length of the binary item.
+        # @return [Boolean] true if valid.
+        def valid_length?(length)
+          (@min_length <= length && length <= @max_length) || (@allow_empty && length == 0)
+        end
+      end
+    end
+  end
+end

data/lib/eth/rlp/sedes/list.rb

@@ -0,0 +1,84 @@
+# Copyright (c) 2016-2022 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.
+
+# -*- encoding : ascii-8bit -*-
+
+# Provides the {Eth} module.
+module Eth
+
+  # Provides an recursive-length prefix (RLP) encoder and decoder.
+  module Rlp
+
+    # Provides serializable and deserializable types (SeDes).
+    module Sedes
+
+      # A sedes type for lists of fixed length.
+      class List < Array
+
+        # Create a serializable list of fixed size.
+        #
+        # @param elements [Array] an array indicating the structure of the list.
+        # @param strict [Boolean] an option to enforce the given structure.
+        def initialize(elements: [], strict: true)
+          super()
+          @strict = strict
+          elements.each do |e|
+            if Sedes.is_sedes?(e)
+              push e
+            elsif Util.is_list?(e)
+              push List.new(elements: e)
+            else
+              raise TypeError, "Instances of List must only contain sedes objects or nested sequences thereof."
+            end
+          end
+        end
+
+        # Serialize an array.
+        #
+        # @param obj [Array] the array to be serialized.
+        # @return [Array] a serialized list.
+        # @raise [SerializationError] if provided array is not a sequence.
+        # @raise [SerializationError] if provided array is of wrong length.
+        def serialize(obj)
+          raise SerializationError, "Can only serialize sequences" unless Util.is_list?(obj)
+          raise SerializationError, "List has wrong length" if (@strict && self.size != obj.size) || self.size < obj.size
+          result = []
+          obj.zip(self).each_with_index do |(element, sedes), i|
+            result.push sedes.serialize(element)
+          end
+          result
+        end
+
+        # Deserializes a list.
+        #
+        # @param serial [Array] the serialized list.
+        # @return [Array] a deserialized list.
+        # @raise [DeserializationError] if provided serial is not a sequence.
+        # @raise [DeserializationError] if provided serial is of wrong length.
+        def deserialize(serial)
+          raise DeserializationError, "Can only deserialize sequences" unless Util.is_list?(serial)
+          raise DeserializationError, "List has wrong length" if @strict && serial.size != self.size
+          result = []
+          len = [serial.size, self.size].min
+          len.times do |i|
+            sedes = self[i]
+            element = serial[i]
+            result.push sedes.deserialize(element)
+          end
+          result.freeze
+        end
+      end
+    end
+  end
+end

data/lib/eth/rlp/sedes.rb

@@ -0,0 +1,74 @@
+# Copyright (c) 2016-2022 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.
+
+# -*- encoding : ascii-8bit -*-
+
+require "eth/rlp/sedes/big_endian_int"
+require "eth/rlp/sedes/binary"
+require "eth/rlp/sedes/list"
+
+# Provides the {Eth} module.
+module Eth
+
+  # Provides an recursive-length prefix (RLP) encoder and decoder.
+  module Rlp
+
+    # Provides serializable and deserializable types (SeDes).
+    module Sedes
+
+      # Provides a singleton {Eth::Rlp::Sedes} class to infer objects and types.
+      class << self
+
+        # Tries to find a sedes objects suitable for a given Ruby object.
+        #
+        # The sedes objects considered are `obj`'s class, {big_endian_int} and
+        # {binary}. If `obj` is a list, an {Eth::Rlp::Sedes::List} will be
+        # constructed recursively.
+        #
+        # @param obj [Object] the Ruby object for which to find a sedes object.
+        # @raise [TypeError] if no appropriate sedes could be found.
+        def infer(obj)
+          return obj.class if is_sedes? obj.class
+          return big_endian_int if obj.is_a?(Integer) && obj >= 0
+          return binary if Binary.valid_type? obj
+          return List.new(elements: obj.map { |item| infer item }) if Util.is_list? obj
+          raise TypeError, "Did not find sedes handling type #{obj.class.name}"
+        end
+
+        # Determines if an object is a sedes object.
+        #
+        # @param obj [Object] the object to check.
+        # @return [Boolean] true if it's serializable and deserializable.
+        def is_sedes?(obj)
+          obj.respond_to?(:serialize) && obj.respond_to?(:deserialize)
+        end
+
+        # A utility to use a big-endian, unsigned integer sedes type with
+        # unspecified length.
+        #
+        # @return [Eth::Rlp::Sedes::BigEndianInt] a big-endian, unsigned integer sedes.
+        def big_endian_int
+          @big_endian_int ||= BigEndianInt.new
+        end
+
+        # A utility to use a binary sedes type.
+        #
+        # @return [Eth::Rlp::Sedes::Binary] a binary sedes.
+        def binary
+          @binary ||= Binary.new
+        end
+      end
+    end
+  end
+end

data/lib/eth/rlp.rb

@@ -0,0 +1,63 @@
+# Copyright (c) 2016-2022 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.
+
+# -*- encoding : ascii-8bit -*-
+
+require "eth/rlp/decoder"
+require "eth/rlp/encoder"
+require "eth/rlp/sedes"
+require "eth/util"
+
+# Provides the {Eth} module.
+module Eth
+
+  # Provides an recursive-length prefix (RLP) encoder and decoder.
+  module Rlp
+    extend self
+
+    # The Rlp module exposes a variety of exceptions grouped as {RlpException}.
+    class RlpException < StandardError; end
+
+    # An error-type to point out RLP-encoding errors.
+    class EncodingError < RlpException; end
+
+    # An error-type to point out RLP-decoding errors.
+    class DecodingError < RlpException; end
+
+    # An error-type to point out RLP-type serialization errors.
+    class SerializationError < RlpException; end
+
+    # An error-type to point out RLP-type serialization errors.
+    class DeserializationError < RlpException; end
+
+    # A wrapper to represent already RLP-encoded data.
+    class Data < String; end
+
+    # Performes an {Eth::Rlp::Encoder} on any ruby object.
+    #
+    # @param obj [Object] any ruby object.
+    # @return [String] a packed, RLP-encoded item.
+    def encode(obj)
+      Rlp::Encoder.perform obj
+    end
+
+    # Performes an {Eth::Rlp::Decoder} on any RLP-encoded item.
+    #
+    # @param rlp [String] a packed, RLP-encoded item.
+    # @return [Object] a decoded ruby object.
+    def decode(rlp)
+      Rlp::Decoder.perform rlp
+    end
+  end
+end

data/lib/eth/signature.rb

@@ -14,7 +14,7 @@
 
 require "rbsecp256k1"
 
-# Provides the `Eth` module.
+# Provides the {Eth} module.
 module Eth
 
   # Defines handy tools for verifying and recovering signatures.
@@ -30,21 +30,22 @@ module Eth
     # EIP-712 version byte 0x01
     EIP712_VERSION_BYTE = "\x01".freeze
 
-    # Prefix message as per EIP-191 with 0x19 to ensure the data is not
+    # Prefix message as per EIP-191 with `0x19` to ensure the data is not
     # valid RLP and thus not mistaken for a transaction.
-    # EIP-191 Version byte: 0x45 (E)
-    # ref: https://eips.ethereum.org/EIPS/eip-191
+    # EIP-191 Version byte: `0x45` (`E`)
+    # Ref: https://eips.ethereum.org/EIPS/eip-191
     #
     # @param message [String] the message string to be prefixed.
-    # @return [String] an EIP-191 prefixed string
+    # @return [String] an EIP-191 prefixed string.
     def prefix_message(message)
       "#{EIP191_PREFIX_BYTE}Ethereum Signed Message:\n#{message.size}#{message}"
     end
 
-    # Dissects a signature blob of 65 bytes into its r, s, and v values.
+    # Dissects a signature blob of 65+ bytes into its `r`, `s`, and `v`
+    # values.
     #
-    # @param signature [String] a Secp256k1 signature.
-    # @return [String, String, String] the r, s, and v values.
+    # @param signature [String] a concatenated Secp256k1 signature string.
+    # @return [String, String, String] the `r`, `s`, and `v` values.
     # @raise [SignatureError] if signature is of unknown size.
     def dissect(signature)
       signature = Util.bin_to_hex signature unless Util.is_hex? signature
@@ -79,6 +80,7 @@ module Eth
 
     # Recovers a public key from a prefixed, personal message and
     # a signature on a given chain. (EIP-191)
+    # Ref: https://eips.ethereum.org/EIPS/eip-191
     #
     # @param message [String] the message string.
     # @param signature [String] the hex string containing the signature.
@@ -92,6 +94,7 @@ module Eth
 
     # Recovers a public key from a typed data structure and a signature
     # on a given chain. (EIP-712)
+    # Ref: https://eips.ethereum.org/EIPS/eip-712
     #
     # @param typed_data [Array] all the data in the typed data structure to be recovered.
     # @param signature [String] the hex string containing the signature.

data/lib/eth/solidity.rb

@@ -0,0 +1,75 @@
+# Copyright (c) 2016-2022 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.
+
+require "open3"
+
+# Provides the {Eth} module.
+module Eth
+
+  # Class to create {Solidity} compiler bingings for Ruby.
+  class Solidity
+
+    # Provides a Compiler Error in case the contract does not compile.
+    class CompilerError < StandardError; end
+
+    # Solidity compiler binary path.
+    attr_reader :compiler
+
+    # Instantiates a Solidity `solc` system compiler binding that can be
+    # used to compile Solidity contracts.
+    def initialize
+
+      # Currently only supports `solc`.
+      solc = get_compiler_path
+      raise SystemCallError, "Unable to find the solc compiler path!" if solc.nil?
+      @compiler = solc
+    end
+
+    # Use the bound Solidity executable to compile the given contract.
+    #
+    # @param contract [String] path of the contract to compile.
+    # @return [Array] JSON containing the compiled contract and ABI for all contracts.
+    def compile(contract)
+      raise Errno::ENOENT, "Contract file not found: #{contract}" unless File.exist? contract
+      command = "#{@compiler} --optimize --combined-json bin,abi #{contract}"
+      output, error, status = Open3.capture3 command
+      raise SystemCallError, "Unable to run solc compiler!" if status.exitstatus === 127
+      raise CompilerError, error unless status.success?
+      json = JSON.parse output
+      result = {}
+      json["contracts"].each do |key, value|
+        _file, name = key.split ":"
+        result[name] = {}
+        result[name]["abi"] = value["abi"]
+        result[name]["bin"] = value["bin"]
+      end
+      return result
+    end
+
+    private
+
+    # Tries to find a system executable path for the given compiler binary name.
+    def get_compiler_path(name = "solc")
+      extensions = [""]
+      extensions = ENV["PATHEXT"].split(";") unless ENV["PATHEXT"].nil?
+      ENV["PATH"].split(File::PATH_SEPARATOR).each do |path|
+        extensions.each do |ext|
+          executable = File.join path, "#{name}#{ext}"
+          return executable if File.executable? executable and !File.directory? executable
+        end
+      end
+      return nil
+    end
+  end
+end

data/lib/eth/tx/eip1559.rb

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# Provides the `Eth` module.
+# Provides the {Eth} module.
 module Eth
 
   # Provides the `Tx` module supporting various transaction types.
@@ -20,9 +20,11 @@ module Eth
 
     # Provides support for EIP-1559 transactions utilizing EIP-2718
     # types and envelopes.
+    # Ref: https://eips.ethereum.org/EIPS/eip-1559
     class Eip1559
 
       # The EIP-155 Chain ID.
+      # Ref: https://eips.ethereum.org/EIPS/eip-155
       attr_reader :chain_id
 
       # The transaction nonce provided by the signer.
@@ -47,6 +49,7 @@ module Eth
       attr_reader :payload
 
       # An optional EIP-2930 access list.
+      # Ref: https://eips.ethereum.org/EIPS/eip-2930
       attr_reader :access_list
 
       # The signature's y-parity byte (not v).
@@ -66,8 +69,10 @@ module Eth
 
       # Create a type-2 (EIP-1559) transaction payload object that
       # can be prepared for envelope, signature and broadcast.
+      # Ref: https://eips.ethereum.org/EIPS/eip-1559
       #
       # @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.
@@ -77,6 +82,7 @@ module Eth
       # @option params [Integer] :value the transaction value.
       # @option params [String] :data the transaction data payload.
       # @option params [Array] :access_list an optional access list.
+      # @raise [ParameterError] if gas limit is too low.
       def initialize(params)
         fields = { recovery_id: nil, r: 0, s: 0 }.merge params
 
@@ -89,6 +95,7 @@ module Eth
 
         # ensure sane values for all mandatory fields
         fields = Tx.validate_params fields
+        fields = Tx.validate_eip1559_params fields
         fields[:access_list] = Tx.sanitize_list fields[:access_list]
 
         # ensure gas limit is not too low
@@ -121,7 +128,7 @@ module Eth
       # Overloads the constructor for decoding raw transactions and creating unsigned copies.
       konstructor :decode, :unsigned_copy
 
-      # Decodes a raw transaction hex into an Eth::Tx::Eip1559
+      # Decodes a raw transaction hex into an {Eth::Tx::Eip1559}
       # transaction object.
       #
       # @param hex [String] the raw transaction hex-string.
@@ -135,7 +142,7 @@ module Eth
         raise TransactionTypeError, "Invalid transaction type #{type}!" if type.to_i(16) != TYPE_1559
 
         bin = Util.hex_to_bin hex[2..]
-        tx = RLP.decode(bin)
+        tx = Rlp.decode bin
 
         # decoded transactions always have 9 + 3 fields, even if they are empty or zero
         raise ParameterError, "Transaction missing fields!" if tx.size < 9
@@ -221,8 +228,8 @@ module Eth
       #
       # @param key [Eth::Key] the key-pair to use for signing.
       # @return [String] a transaction hash.
-      # @raise [SignatureError] if transaction is already signed.
-      # @raise [SignatureError] if sender address does not match signing key.
+      # @raise [Signature::SignatureError] if transaction is already signed.
+      # @raise [Signature::SignatureError] if sender address does not match signing key.
       def sign(key)
         if Tx.is_signed? self
           raise Signature::SignatureError, "Transaction is already signed!"
@@ -249,7 +256,7 @@ module Eth
       # with an EIP-1559 type prefix.
       #
       # @return [String] a raw, RLP-encoded EIP-1559 type transaction object.
-      # @raise [SignatureError] if the transaction is not yet signed.
+      # @raise [Signature::SignatureError] if the transaction is not yet signed.
       def encoded
         unless Tx.is_signed? self
           raise Signature::SignatureError, "Transaction is not signed!"
@@ -262,12 +269,12 @@ module Eth
         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 @payload
-        tx_data.push @access_list
+        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 @signature_y_parity
-        tx_data.push Util.hex_to_bin @signature_r
-        tx_data.push Util.hex_to_bin @signature_s
-        tx_encoded = RLP.encode tx_data
+        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-1559 type payload
         tx_type = Util.serialize_int_to_big_endian @type
@@ -301,9 +308,9 @@ module Eth
         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 @payload
-        tx_data.push @access_list
-        tx_encoded = RLP.encode tx_data
+        tx_data.push Rlp::Sedes.binary.serialize @payload
+        tx_data.push Rlp::Sedes.infer(@access_list).serialize @access_list
+        tx_encoded = Rlp.encode tx_data
 
         # create an EIP-2718 envelope with EIP-1559 type payload (unsigned)
         tx_type = Util.serialize_int_to_big_endian @type
@@ -319,6 +326,7 @@ module Eth
 
       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