eth-custom 0.5.7

data/lib/eth/contract/function_input.rb

@@ -0,0 +1,38 @@
+# 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
+
+  # Provide classes for contract function input.
+  class Contract::FunctionInput
+    attr_accessor :type, :raw_type, :name
+
+    # Constructor of the {Eth::Contract::FunctionInput} class.
+    #
+    # @param data [Hash] contract abi data.
+    def initialize(data)
+      @raw_type = data["type"]
+      @type = Eth::Abi::Type.parse(data["type"])
+      @name = data["name"]
+    end
+
+    # Returns complete types with subtypes, e.g., `uint256`.
+    def type
+      @type.base_type + @type.sub_type + @type.dimensions.map { |dimension| "[#{dimension > 0 ? dimension : ""}]" }.join("")
+    end
+  end
+end

data/lib/eth/contract/function_output.rb

@@ -0,0 +1,37 @@
+# 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
+
+  # Provide classes for contract function output.
+  class Contract::FunctionOutput
+    attr_accessor :type, :name
+
+    # Constructor of the {Eth::Contract::FunctionOutput} class.
+    #
+    # @param data [Hash] contract abi data.
+    def initialize(data)
+      @type = Eth::Abi::Type.parse(data["type"])
+      @name = data["name"]
+    end
+
+    # Returns complete types with subtypes, e.g., `uint256`.
+    def type
+      @type.base_type + @type.sub_type + @type.dimensions.map { |dimension| "[#{dimension > 0 ? dimension : ""}]" }.join("")
+    end
+  end
+end

data/lib/eth/contract/initializer.rb

@@ -0,0 +1,47 @@
+# 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
+
+  # Provide classes for contract initializer.
+  class Contract::Initializer
+    attr_accessor :contracts, :file
+
+    # Constructor of the {Eth::Contract::Initializer} class.
+    #
+    # @param file [String] file path to solidity code.
+    def initialize(file)
+      sol_output = Eth::Solidity.new.compile(file)
+      contracts = sol_output.keys
+
+      @contracts = []
+      contracts.each do |contract|
+        abi = sol_output[contract]["abi"]
+        name = contract
+        code = sol_output[contract]["bin"]
+        @contracts << Contract.new(name, code, abi)
+      end
+    end
+
+    # Builds and returns all contracts.
+    def build_all
+      @contracts.each do |contract|
+        contract.build
+      end
+    end
+  end
+end

data/lib/eth/contract.rb

@@ -0,0 +1,143 @@
+# 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 classes to access smart contracts
+  class Contract
+    attr_reader :address
+    attr_accessor :key
+    attr_accessor :gas_limit, :gas_price, :max_fee_per_gas, :max_priority_fee_per_gas, :nonce
+    attr_accessor :bin, :name, :abi, :class_object
+    attr_accessor :events, :functions, :constructor_inputs
+
+    # Constructor of the {Eth::Contract} class.
+    #
+    # @param name [String] contract name.
+    # @param bin [String] contract bin string.
+    # @param abi [String] contract abi string.
+    def initialize(name, bin, abi)
+      @name = name
+      @bin = bin
+      @abi = abi
+      @constructor_inputs, @functions, @events = parse_abi(abi)
+    end
+
+    # Creates a contract wrapper from a Solidity file.
+    #
+    # @param file [String] solidity file path.
+    # @param contract_index [Number] specify contract.
+    # @return [Eth::Contract::Object] Returns the class of the smart contract.
+    # @raise [ArgumentError] if the file path is empty or no contracts were compiled.
+    def self.from_file(file:, contract_index: 0)
+      raise ArgumentError, "Cannot find the contract at #{file.to_s}!" if !File.exist?(file.to_s)
+      contracts = Eth::Contract::Initializer.new(file).build_all
+      raise ArgumentError, "No contracts compiled." if contracts.empty?
+      contracts[contract_index].class_object.new
+    end
+
+    # Creates a contract wrapper from ABI and address.
+    #
+    # @param abi [String] contract abi string.
+    # @param address [String] contract address.
+    # @param name [String] name of contract.
+    # @return [Eth::Contract::Object] Returns the class of the smart contract.
+    # @raise [JSON::ParserError] if the json format is wrong.
+    # @raise [ArgumentError] if ABI, address, or name is missing.
+    def self.from_abi(abi:, address:, name:)
+      abi = abi.is_a?(Array) ? abi : JSON.parse(abi)
+      contract = Eth::Contract.new(name, nil, abi)
+      contract.build
+      contract = contract.class_object.new
+      contract.address = address
+      contract
+    end
+
+    # Creates a contract wrapper from binary and ABI.
+    #
+    # @param bin [String] contract bin string.
+    # @param abi [String] contract abi string.
+    # @param name [String] name of contract.
+    # @return [Eth::Contract::Object] Returns the class of the smart contract.
+    # @raise [JSON::ParserError] if the json format is wrong.
+    # @raise [ArgumentError] if ABI, binary, or name is missing.
+    def self.from_bin(bin:, abi:, name:)
+      abi = abi.is_a?(Array) ? abi : JSON.parse(abi)
+      contract = Eth::Contract.new(name, bin, abi)
+      contract.build
+      contract.class_object.new
+    end
+
+    # Sets the address of the smart contract.
+    #
+    # @param addr [String|Eth::Address] contract address string.
+    def address=(addr)
+      if addr.is_a? Eth::Address
+        @address = addr.to_s
+      else
+        @address = Eth::Address.new(addr).to_s
+      end
+      @events.each do |event|
+        event.set_address(@address)
+      end
+    end
+
+    # Create meta classes for smart contracts.
+    def build
+      class_name = @name
+      parent = self
+      class_methods = Class.new do
+        extend Forwardable
+        def_delegators :parent, :key, :key=
+        def_delegators :parent, :name, :abi, :bin
+        def_delegators :parent, :gas_limit, :gas_price, :gas_limit=, :gas_price=, :nonce, :nonce=
+        def_delegators :parent, :max_fee_per_gas, :max_fee_per_gas=, :max_priority_fee_per_gas, :max_priority_fee_per_gas=
+        def_delegators :parent, :events
+        def_delegators :parent, :address, :address=
+        def_delegator :parent, :functions
+        def_delegator :parent, :constructor_inputs
+        define_method :parent do
+          parent
+        end
+      end
+      Eth::Contract.send(:remove_const, class_name) if Eth::Contract.const_defined?(class_name, false)
+      Eth::Contract.const_set(class_name, class_methods)
+      @class_object = class_methods
+    end
+
+    private
+
+    def parse_abi(abi)
+      constructor = abi.detect { |x| x["type"] == "constructor" }
+      if !constructor.nil?
+        constructor_inputs = constructor["inputs"].map { |input| Eth::Contract::FunctionInput.new(input) }
+      else
+        constructor_inputs = []
+      end
+      functions = abi.select { |x| x["type"] == "function" }.map { |fun| Eth::Contract::Function.new(fun) }
+      events = abi.select { |x| x["type"] == "event" }.map { |evt| Eth::Contract::Event.new(evt) }
+      [constructor_inputs, functions, events]
+    end
+  end
+end
+
+# Load the contract/* libraries
+require "eth/contract/event"
+require "eth/contract/function"
+require "eth/contract/function_input"
+require "eth/contract/function_output"
+require "eth/contract/initializer"

data/lib/eth/eip712.rb

@@ -0,0 +1,184 @@
+# 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.
+
+# Provides the {Eth} module.
+module Eth
+
+  # Defines handy tools for encoding typed structured data as per EIP-712.
+  # Ref: https://eips.ethereum.org/EIPS/eip-712
+  module Eip712
+    extend self
+
+    # Provides a special typed-data error if data structure fails basic
+    # verification.
+    class TypedDataError < StandardError; end
+
+    # Scans all dependencies of a given type recursively and returns
+    # either all dependencies or none if not found.
+    #
+    # @param primary_type [String] the primary type which we want to scan.
+    # @param types [Array] all existing types in the data structure.
+    # @param result [Array] found results from previous recursions.
+    # @return [Array] all dependent types for the given primary type.
+    def type_dependencies(primary_type, types, result = [])
+      if result.include? primary_type
+
+        # ignore if we already have the give type in results
+        return result
+      elsif types[primary_type.to_sym].nil?
+
+        # ignore if the type is not used, e.g., a string or address.
+        return result
+      else
+
+        # we found something
+        result.push primary_type
+
+        # recursively look for further nested dependencies
+        types[primary_type.to_sym].each do |t|
+          dependency = type_dependencies t[:type], types, result
+        end
+        return result
+      end
+    end
+
+    # Encode types as an EIP-712 confrom string, e.g.,
+    # `MyType(string attribute)`.
+    #
+    # @param primary_type [String] the type which we want to encode.
+    # @param types [Array] all existing types in the data structure.
+    # @return [String] an EIP-712 encoded type-string.
+    # @raise [TypedDataError] if non-primary type found.
+    def encode_type(primary_type, types)
+
+      # get all used types
+      all_dependencies = type_dependencies primary_type, types
+
+      # remove primary types and sort the rest alphabetically
+      filtered_dependencies = all_dependencies.delete_if { |type| type.to_s == primary_type }
+      sorted_dependencies = filtered_dependencies.sort
+      dependencies = [primary_type]
+      sorted_dependencies.each do |sorted|
+        dependencies.push sorted
+      end
+
+      # join them all in a string with types and field names
+      result = ""
+      dependencies.each do |type|
+
+        # dependencies should not have non-primary types (such as string, address)
+        raise TypedDataError, "Non-primary type found: #{type}!" if types[type.to_sym].nil?
+
+        result += "#{type}("
+        result += types[type.to_sym].map { |t| "#{t[:type]} #{t[:name]}" }.join(",")
+        result += ")"
+      end
+      return result
+    end
+
+    # Hashes an EIP-712 confrom type-string.
+    #
+    # @param primary_type [String] the type which we want to hash.
+    # @param types [Array] all existing types in the data structure.
+    # @return [String] a Keccak-256 hash of an EIP-712 encoded type-string.
+    def hash_type(primary_type, types)
+      encoded_type = encode_type primary_type, types
+      return Util.keccak256 encoded_type
+    end
+
+    # Recursively ABI-encodes all data and types according to EIP-712.
+    #
+    # @param primary_type [String] the primary type which we want to encode.
+    # @param data [Array] the data in the data structure we want to encode.
+    # @param types [Array] all existing types in the data structure.
+    # @return [String] an ABI-encoded representation of the data and the types.
+    def encode_data(primary_type, data, types)
+
+      # first data field is the type hash
+      encoded_types = ["bytes32"]
+      encoded_values = [hash_type(primary_type, types)]
+
+      # adds field contents
+      types[primary_type.to_sym].each do |field|
+        value = data[field[:name].to_sym]
+        type = field[:type]
+        raise NotImplementedError, "Arrays currently unimplemented for EIP-712." if type.end_with? "]"
+        if type == "string" or type == "bytes"
+          encoded_types.push "bytes32"
+          encoded_values.push Util.keccak256 value
+        elsif !types[type.to_sym].nil?
+          encoded_types.push "bytes32"
+          value = encode_data type, value, types
+          encoded_values.push Util.keccak256 value
+        else
+          encoded_types.push type
+          encoded_values.push value
+        end
+      end
+
+      # all data is abi-encoded
+      return Abi.encode encoded_types, encoded_values
+    end
+
+    # Recursively ABI-encodes and hashes all data and types.
+    #
+    # @param primary_type [String] the primary type which we want to hash.
+    # @param data [Array] the data in the data structure we want to hash.
+    # @param types [Array] all existing types in the data structure.
+    # @return [String] a Keccak-256 hash of the ABI-encoded data and types.
+    def hash_data(primary_type, data, types)
+      encoded_data = encode_data primary_type, data, types
+      return Util.keccak256 encoded_data
+    end
+
+    # Enforces basic properties to be represented in the EIP-712 typed
+    # data structure: types, domain, message, etc.
+    #
+    # @param data [Array] the data in the data structure we want to hash.
+    # @return [Array] the data in the data structure we want to hash.
+    # @raise [TypedDataError] if the data fails validation.
+    def enforce_typed_data(data)
+      data = JSON.parse data if Util.is_hex? data
+      raise TypedDataError, "Data is missing, try again with data." if data.nil? or data.empty?
+      raise TypedDataError, "Data types are missing." if data[:types].nil? or data[:types].empty?
+      raise TypedDataError, "Data primaryType is missing." if data[:primaryType].nil? or data[:primaryType].empty?
+      raise TypedDataError, "Data domain is missing." if data[:domain].nil?
+      raise TypedDataError, "Data message is missing." if data[:message].nil? or data[:message].empty?
+      raise TypedDataError, "Data EIP712Domain is missing." if data[:types][:EIP712Domain].nil?
+      return data
+    end
+
+    # Hashes a typed data structure with Keccak-256 to prepare a signed
+    # typed data operation respecting EIP-712.
+    #
+    # @param data [Array] all the data in the typed data structure.
+    # @return [String] a Keccak-256 hash of the EIP-712-encoded typed data.
+    def hash(data)
+      data = enforce_typed_data data
+
+      # EIP-191 prefix byte
+      buffer = Signature::EIP191_PREFIX_BYTE
+
+      # EIP-712 version byte
+      buffer += Signature::EIP712_VERSION_BYTE
+
+      # hashed domain data
+      buffer += hash_data "EIP712Domain", data[:domain], data[:types]
+
+      # hashed message data
+      buffer += hash_data data[:primaryType], data[:message], data[:types]
+      return Util.keccak256 buffer
+    end
+  end
+end

data/lib/eth/key/decrypter.rb

@@ -0,0 +1,146 @@
+# 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.
+
+# Provides the {Eth} module.
+module Eth
+
+  # The {Eth::Key::Decrypter} class to handle PBKDF2-SHA-256 decryption.
+  class Key::Decrypter
+
+    # Provides a specific decrypter error if decryption fails.
+    class DecrypterError < StandardError; end
+
+    # Class method {Eth::Key::Decrypter.perform} to perform an keystore
+    # decryption.
+    #
+    # @param data [JSON] encryption data including cypherkey.
+    # @param password [String] password to decrypt the key.
+    # @return [Eth::Key] decrypted key-pair.
+    def self.perform(data, password)
+      new(data, password).perform
+    end
+
+    # Constructor of the {Eth::Key::Decrypter} class for secret key
+    # decryption. Should not be used; use {Eth::Key::Decrypter.perform}
+    # instead.
+    #
+    # @param data [JSON] encryption data including cypherkey.
+    # @param password [String] password to decrypt the key.
+    def initialize(data, password)
+      data = JSON.parse(data) if data.is_a? String
+      @data = data
+      @password = password
+    end
+
+    # Method to decrypt key using password.
+    #
+    # @return [Eth::Key] decrypted key.
+    def perform
+      derive_key password
+      check_macs
+      private_key = Util.bin_to_hex decrypted_data
+      Eth::Key.new priv: private_key
+    end
+
+    private
+
+    attr_reader :data
+    attr_reader :key
+    attr_reader :password
+
+    def derive_key(password)
+      case kdf
+      when "pbkdf2"
+        @key = OpenSSL::PKCS5.pbkdf2_hmac(password, salt, iterations, key_length, digest)
+      when "scrypt"
+        @key = SCrypt::Engine.scrypt(password, salt, n, r, p, key_length)
+      else
+        raise DecrypterError, "Unsupported key derivation function: #{kdf}!"
+      end
+    end
+
+    def check_macs
+      mac1 = Util.keccak256(key[(key_length / 2), key_length] + ciphertext)
+      mac2 = Util.hex_to_bin crypto_data["mac"]
+
+      if mac1 != mac2
+        raise DecrypterError, "Message Authentications Codes do not match!"
+      end
+    end
+
+    def decrypted_data
+      @decrypted_data ||= cipher.update(ciphertext) + cipher.final
+    end
+
+    def crypto_data
+      @crypto_data ||= data["crypto"] || data["Crypto"]
+    end
+
+    def ciphertext
+      Util.hex_to_bin crypto_data["ciphertext"]
+    end
+
+    def cipher_name
+      "aes-128-ctr"
+    end
+
+    def cipher
+      @cipher ||= OpenSSL::Cipher.new(cipher_name).tap do |cipher|
+        cipher.decrypt
+        cipher.key = key[0, (key_length / 2)]
+        cipher.iv = iv
+      end
+    end
+
+    def iv
+      Util.hex_to_bin crypto_data["cipherparams"]["iv"]
+    end
+
+    def salt
+      Util.hex_to_bin crypto_data["kdfparams"]["salt"]
+    end
+
+    def iterations
+      crypto_data["kdfparams"]["c"].to_i
+    end
+
+    def kdf
+      crypto_data["kdf"]
+    end
+
+    def key_length
+      crypto_data["kdfparams"]["dklen"].to_i
+    end
+
+    def n
+      crypto_data["kdfparams"]["n"].to_i
+    end
+
+    def r
+      crypto_data["kdfparams"]["r"].to_i
+    end
+
+    def p
+      crypto_data["kdfparams"]["p"].to_i
+    end
+
+    def digest
+      OpenSSL::Digest.new digest_name
+    end
+
+    def digest_name
+      "sha256"
+    end
+  end
+end