eth-custom 0.5.7

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 binary 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 binary 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

@@ -0,0 +1,163 @@
+# 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 "rbsecp256k1"
+
+# Provides the {Eth} module.
+module Eth
+
+  # Defines handy tools for verifying and recovering signatures.
+  module Signature
+    extend self
+
+    # Provides a special signature error if signature is invalid.
+    class SignatureError < StandardError; end
+
+    # EIP-191 prefix byte 0x19
+    EIP191_PREFIX_BYTE = "\x19".freeze
+
+    # EIP-712 version byte 0x01
+    EIP712_VERSION_BYTE = "\x01".freeze
+
+    # 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
+    #
+    # @param message [String] the message string to be prefixed.
+    # @return [String] an EIP-191 prefixed string.
+    def prefix_message(message)
+      "#{EIP191_PREFIX_BYTE}Ethereum Signed Message:\n#{message.bytesize}#{message}"
+    end
+
+    # Dissects a signature blob of 65+ bytes into its `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
+      signature = Util.remove_hex_prefix signature
+      if signature.size < 130
+        raise SignatureError, "Unknown signature length #{signature.size}!"
+      end
+      r = signature[0, 64]
+      s = signature[64, 64]
+      v = signature[128..]
+      return r, s, v
+    end
+
+    # Recovers a signature from arbitrary data without validation on a given chain.
+    #
+    # @param blob [String] that arbitrary data to be recovered.
+    # @param signature [String] the hex string containing the signature.
+    # @param chain_id [Integer] the chain ID the signature should be recovered from.
+    # @return [String] a hexa-decimal, uncompressed public key.
+    # @raise [SignatureError] if signature is of invalid size or invalid v.
+    def recover(blob, signature, chain_id = Chain::ETHEREUM)
+      context = Secp256k1::Context.new
+      r, s, v = dissect signature
+      v = v.to_i(16)
+      raise SignatureError, "Invalid signature v byte #{v} for chain ID #{chain_id}!" if v < chain_id
+      recovery_id = Chain.to_recovery_id v, chain_id
+      signature_rs = Util.hex_to_bin "#{r}#{s}"
+      recoverable_signature = context.recoverable_signature_from_compact signature_rs, recovery_id
+      public_key = recoverable_signature.recover_public_key blob
+      Util.bin_to_hex public_key.uncompressed
+    end
+
+    # 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.
+    # @param chain_id [Integer] the chain ID the signature should be recovered from.
+    # @return [String] a hexa-decimal, uncompressed public key.
+    def personal_recover(message, signature, chain_id = Chain::ETHEREUM)
+      prefixed_message = prefix_message message
+      hashed_message = Util.keccak256 prefixed_message
+      recover hashed_message, signature, chain_id
+    end
+
+    # 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.
+    # @param chain_id [Integer] the chain ID the signature should be recovered from.
+    # @return [String] a hexa-decimal, uncompressed public key.
+    def recover_typed_data(typed_data, signature, chain_id = Chain::ETHEREUM)
+      hash_to_sign = Eip712.hash typed_data
+      recover hash_to_sign, signature, chain_id
+    end
+
+    # Verifies a signature for a given public key or address.
+    #
+    # @param blob [String] that arbitrary data to be verified.
+    # @param signature [String] the hex string containing the signature.
+    # @param public_key [String] either a public key or an Ethereum address.
+    # @param chain_id [Integer] the chain ID used to sign.
+    # @return [Boolean] true if signature matches provided public key.
+    # @raise [SignatureError] if it cannot determine the type of data or public key.
+    def verify(blob, signature, public_key, chain_id = Chain::ETHEREUM)
+      recovered_key = nil
+      if blob.instance_of? Array or blob.instance_of? Hash
+
+        # recover Array from sign_typed_data
+        recovered_key = recover_typed_data blob, signature, chain_id
+      elsif blob.instance_of? String and blob.encoding != Encoding::ASCII_8BIT
+
+        # recover message from personal_sign
+        recovered_key = personal_recover blob, signature, chain_id
+      elsif blob.instance_of? String and (Util.is_hex? blob or blob.encoding == Encoding::ASCII_8BIT)
+
+        # if nothing else, recover from arbitrary signature
+        recovered_key = recover blob, signature, chain_id
+      end
+
+      # raise if we cannot determine the data format
+      raise SignatureError, "Unknown data format to verify: #{blob}" if recovered_key.nil?
+
+      if public_key.instance_of? Address
+
+        # recovering using an Eth::Address
+        address = public_key.to_s
+        recovered_address = Util.public_key_to_address(recovered_key).to_s
+        return address == recovered_address
+      elsif public_key.instance_of? Secp256k1::PublicKey
+
+        # recovering using an Secp256k1::PublicKey
+        public_hex = Util.bin_to_hex public_key.uncompressed
+        return public_hex == recovered_key
+      elsif public_key.size == 42
+
+        # recovering using an address String
+        address = Address.new(public_key).to_s
+        recovered_address = Util.public_key_to_address(recovered_key).to_s
+        return address == recovered_address
+      elsif public_key.size == 130
+
+        # recovering using an uncompressed public key String
+        return public_key == recovered_key
+      else
+
+        # raise if we cannot determine the public key format used
+        raise SignatureError, "Invalid public key or address supplied #{public_key}!"
+      end
+    end
+  end
+end

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