eth 0.4.18 → 0.5.2

data/lib/eth/key.rb

@@ -1,78 +1,167 @@
+# 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 "json"
+require "openssl"
+require "rbsecp256k1"
+require "scrypt"
+require "securerandom"
+
+# Provides the {Eth} module.
 module Eth
+
+  # The {Eth::Key} class to handle Secp256k1 private/public key-pairs.
   class Key
+
+    # The {Eth::Key::Decrypter} class to handle PBKDF2-SHA-256 decryption.
     autoload :Decrypter, "eth/key/decrypter"
+
+    # The {Eth::Key::Encrypter} class to handle PBKDF2-SHA-256 encryption.
     autoload :Encrypter, "eth/key/encrypter"
 
-    attr_reader :private_key, :public_key
+    # The `Secp256k1::PrivateKey` of the {Eth::Key} pair.
+    attr_reader :private_key
 
-    def self.encrypt(key, password)
-      key = new(priv: key) unless key.is_a?(Key)
+    # The `Secp256k1::PublicKey` of the {Eth::Key} pair.
+    attr_reader :public_key
 
-      Encrypter.perform key.private_hex, password
-    end
+    # Constructor of the {Eth::Key} class. Creates a new random key-pair
+    # if no `priv` key is provided.
+    #
+    # @param priv [String] binary string of private key data.
+    def initialize(priv: nil)
 
-    def self.decrypt(data, password)
-      priv = Decrypter.perform data, password
-      new priv: priv
-    end
+      # Creates a new, randomized libsecp256k1 context.
+      ctx = Secp256k1::Context.new context_randomization_bytes: SecureRandom.random_bytes(32)
 
-    def self.personal_recover(message, signature)
-      bin_signature = Utils.hex_to_bin(signature).bytes.rotate(-1).pack("c*")
-      OpenSsl.recover_compact(Utils.keccak256(Utils.prefix_message(message)), bin_signature)
-    end
+      # Creates a new random key pair (public, private).
+      key = ctx.generate_key_pair
 
-    def initialize(priv: nil)
-      @private_key = MoneyTree::PrivateKey.new key: priv
-      @public_key = MoneyTree::PublicKey.new private_key, compressed: false
-    end
+      unless priv.nil?
 
-    def private_hex
-      private_key.to_hex
-    end
+        # Converts hex private keys to binary strings.
+        priv = Util.hex_to_bin priv if Util.is_hex? priv
 
-    def public_bytes
-      public_key.to_bytes
+        # Creates a keypair from existing private key data.
+        key = ctx.key_pair_from_private_key priv
+      end
+
+      # Sets the attributes.
+      @private_key = key.private_key
+      @public_key = key.public_key
     end
 
-    def public_hex
-      public_key.to_hex
+    # Signs arbitrary data without validation. Should not be used unless really
+    # desired. See also: {Key.personal_sign}, {Key.sign_typed_data}, and
+    # {Signature.recover}.
+    #
+    # @param blob [Object] that arbitrary data to be signed.
+    # @param chain_id [Integer] the chain id the signature should be generated on.
+    # @return [String] a hexa-decimal signature.
+    def sign(blob, chain_id = nil)
+      context = Secp256k1::Context.new
+      compact, recovery_id = context.sign_recoverable(@private_key, blob).compact
+      signature = compact.bytes
+      v = Chain.to_v recovery_id, chain_id
+      is_leading_zero = true
+      [v].pack("N").unpack("C*").each do |byte|
+        is_leading_zero = false if byte > 0 and is_leading_zero
+        signature.append byte unless is_leading_zero and byte === 0
+      end
+      Util.bin_to_hex signature.pack "c*"
     end
 
-    def address
-      Utils.public_key_to_address public_hex
+    # Prefixes a message with `\x19Ethereum Signed Message:` and signs
+    # it in the common way used by many web3 wallets. Complies with
+    # EIP-191 prefix `0x19` and version byte `0x45` (`E`). See also
+    # {Signature.personal_recover}.
+    # Ref: https://eips.ethereum.org/EIPS/eip-191
+    #
+    # @param message [String] the message string to be prefixed and signed.
+    # @param chain_id [Integer] the chain id the signature should be generated on.
+    # @return [String] an EIP-191 conform, hexa-decimal signature.
+    def personal_sign(message, chain_id = nil)
+      prefixed_message = Signature.prefix_message message
+      hashed_message = Util.keccak256 prefixed_message
+      sign hashed_message, chain_id
     end
 
-    alias_method :to_address, :address
+    # Prefixes, hashes, and signes a typed data structure in the common
+    # way used by many web3 wallets. Complies with EIP-191 prefix `0x19`
+    # and EIP-712 version byte `0x01`. Supports `V3`, `V4`. See also
+    # {Signature.recover_typed_data}.
+    # Ref: https://eips.ethereum.org/EIPS/eip-712
+    #
+    # @param typed_data [Array] all the data in the typed data structure to be signed.
+    # @param chain_id [Integer] the chain id the signature should be generated on.
+    # @return [String] an EIP-712 conform, hexa-decimal signature.
+    def sign_typed_data(typed_data, chain_id = nil)
+      hash_to_sign = Eip712.hash typed_data
+      sign hash_to_sign, chain_id
+    end
 
-    def sign(message)
-      sign_hash message_hash(message)
+    # Converts the private key data into a hexa-decimal string.
+    #
+    # @return [String] private key as hexa-decimal string.
+    def private_hex
+      Util.bin_to_hex @private_key.data
     end
 
-    def sign_hash(hash)
-      loop do
-        signature = OpenSsl.sign_compact hash, private_hex, public_hex
-        return signature if valid_s? signature
-      end
+    # Exports the private key bytes in a wrapper function to maintain
+    # backward-compatibility with older versions of {Eth::Key}.
+    #
+    # @return [String] private key as packed byte-string.
+    def private_bytes
+      @private_key.data
     end
 
-    def verify_signature(message, signature)
-      hash = message_hash(message)
-      public_hex == OpenSsl.recover_compact(hash, signature)
+    # Converts the public key data into an uncompressed
+    # hexa-decimal string.
+    #
+    # @return [String] public key as uncompressed hexa-decimal string.
+    def public_hex
+      Util.bin_to_hex @public_key.uncompressed
     end
 
-    def personal_sign(message)
-      Utils.bin_to_hex(sign(Utils.prefix_message(message)).bytes.rotate(1).pack("c*"))
+    # Converts the public key data into an compressed
+    # hexa-decimal string.
+    #
+    # @return [String] public key as compressed hexa-decimal string.
+    def public_hex_compressed
+      Util.bin_to_hex @public_key.compressed
     end
 
-    private
+    # Exports the uncompressed public key bytes in a wrapper function to
+    # maintain backward-compatibility with older versions of {Eth::Key}.
+    #
+    # @return [String] uncompressed public key as packed byte-string.
+    def public_bytes
+      @public_key.uncompressed
+    end
 
-    def message_hash(message)
-      Utils.keccak256 message
+    # Exports the compressed public key bytes.
+    #
+    # @return [String] compressed public key as packed byte-string.
+    def public_bytes_compressed
+      @public_key.compressed
     end
 
-    def valid_s?(signature)
-      s_value = Utils.v_r_s_for(signature).last
-      s_value <= Secp256k1::N / 2 && s_value != 0
+    # Exports the checksummed public address.
+    #
+    # @return [Eth::Address] compressed address as packed hex prefixed string.
+    def address
+      Util.public_key_to_address public_bytes
     end
   end
 end

data/lib/eth/rlp/decoder.rb

@@ -0,0 +1,114 @@
+# 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 an RLP-decoder.
+    module Decoder
+      extend self
+
+      # Decodes an RLP-encoded object.
+      #
+      # @param rlp [String] an RLP-encoded object.
+      # @return [Object] the decoded and maybe deserialized object.
+      # @raise [Eth::Rlp::DecodingError] if the input string does not end after
+      #     the root item.
+      def perform(rlp)
+        rlp = Util.hex_to_bin rlp if Util.is_hex? rlp
+        rlp = Util.str_to_bytes rlp
+        begin
+          item, next_start = consume_item rlp, 0
+        rescue Exception => e
+          raise DecodingError, "Cannot decode rlp string: #{e}"
+        end
+        raise DecodingError, "RLP string ends with #{rlp.size - next_start} superfluous bytes" if next_start != rlp.size
+        return item
+      end
+
+      private
+
+      # Consume an RLP-encoded item from the given start.
+      def consume_item(rlp, start)
+        t, l, s = consume_length_prefix rlp, start
+        consume_payload rlp, s, t, l
+      end
+
+      # Consume an RLP length prefix at the given position.
+      def consume_length_prefix(rlp, start)
+        b0 = rlp[start].ord
+        if b0 < Constant::PRIMITIVE_PREFIX_OFFSET
+
+          # single byte
+          [:str, 1, start]
+        elsif b0 < Constant::PRIMITIVE_PREFIX_OFFSET + Constant::SHORT_LENGTH_LIMIT
+          raise DecodingError, "Encoded as short string although single byte was possible" if (b0 - Constant::PRIMITIVE_PREFIX_OFFSET == 1) && rlp[start + 1].ord < Constant::PRIMITIVE_PREFIX_OFFSET
+
+          # short string
+          [:str, b0 - Constant::PRIMITIVE_PREFIX_OFFSET, start + 1]
+        elsif b0 < Constant::LIST_PREFIX_OFFSET
+          enforce_no_zero_bytes rlp, start
+
+          # long string
+          ll = b0 - Constant::PRIMITIVE_PREFIX_OFFSET - Constant::SHORT_LENGTH_LIMIT + 1
+          l = Util.big_endian_to_int rlp[(start + 1)...(start + 1 + ll)]
+          raise DecodingError, "Long string prefix used for short string" if l < Constant::SHORT_LENGTH_LIMIT
+          [:str, l, start + 1 + ll]
+        elsif b0 < Constant::LIST_PREFIX_OFFSET + Constant::SHORT_LENGTH_LIMIT
+
+          # short list
+          [:list, b0 - Constant::LIST_PREFIX_OFFSET, start + 1]
+        else
+          enforce_no_zero_bytes rlp, start
+
+          # long list
+          ll = b0 - Constant::LIST_PREFIX_OFFSET - Constant::SHORT_LENGTH_LIMIT + 1
+          l = Util.big_endian_to_int rlp[(start + 1)...(start + 1 + ll)]
+          raise DecodingError, "Long list prefix used for short list" if l < Constant::SHORT_LENGTH_LIMIT
+          [:list, l, start + 1 + ll]
+        end
+      end
+
+      # Enforce RLP slices to not start with empty bytes.
+      def enforce_no_zero_bytes(rlp, start)
+        raise DecodingError, "Length starts with zero bytes" if rlp.slice(start + 1) == Constant::BYTE_ZERO
+      end
+
+      # Consume an RLP payload at the given position of given type and size.
+      def consume_payload(rlp, start, type, length)
+        case type
+        when :str
+          [rlp[start...(start + length)], start + length]
+        when :list
+          items = []
+          next_item_start = start
+          payload_end = next_item_start + length
+          while next_item_start < payload_end
+            item, next_item_start = consume_item rlp, next_item_start
+            items.push item
+          end
+          raise DecodingError, "List length prefix announced a too small length" if next_item_start > payload_end
+          [items, next_item_start]
+        else
+          raise TypeError, "Type must be either :str or :list"
+        end
+      end
+    end
+  end
+end

data/lib/eth/rlp/encoder.rb

@@ -0,0 +1,78 @@
+# 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 an RLP-encoder.
+    module Encoder
+      extend self
+
+      # Encodes a Ruby object in RLP format.
+      #
+      # @param obj [Object] a Ruby object.
+      # @return [String] the RLP encoded item.
+      # @raise [Eth::Rlp::EncodingError] in the rather unlikely case that the item
+      #     is too big to encode (will not happen).
+      # @raise [Eth::Rlp::SerializationError] if the serialization fails.
+      def perform(obj)
+        item = Sedes.infer(obj).serialize(obj)
+        result = encode_raw item
+      end
+
+      private
+
+      # Encodes the raw item.
+      def encode_raw(item)
+        return item if item.instance_of? Rlp::Data
+        return encode_primitive item if Util.is_primitive? item
+        return encode_list item if Util.is_list? item
+        raise EncodingError "Cannot encode object of type #{item.class.name}"
+      end
+
+      # Encodes a single primitive.
+      def encode_primitive(item)
+        return Util.str_to_bytes item if item.size == 1 && item.ord < Constant::PRIMITIVE_PREFIX_OFFSET
+        payload = Util.str_to_bytes item
+        prefix = length_prefix payload.size, Constant::PRIMITIVE_PREFIX_OFFSET
+        "#{prefix}#{payload}"
+      end
+
+      # Encodes a single list.
+      def encode_list(list)
+        payload = list.map { |item| encode_raw item }.join
+        prefix = length_prefix payload.size, Constant::LIST_PREFIX_OFFSET
+        "#{prefix}#{payload}"
+      end
+
+      # Determines a length prefix.
+      def length_prefix(length, offset)
+        if length < Constant::SHORT_LENGTH_LIMIT
+          (offset + length).chr
+        elsif length < Constant::LONG_LENGTH_LIMIT
+          length_string = Util.int_to_big_endian length
+          length_len = (offset + Constant::SHORT_LENGTH_LIMIT - 1 + length_string.size).chr
+          "#{length_len}#{length_string}"
+        else
+          raise EncodingError, "Length greater than 256**8: #{length}"
+        end
+      end
+    end
+  end
+end

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