klay 0.0.1

data/lib/klay/client.rb

@@ -0,0 +1,232 @@
+# 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 Klay
+
+  # Provides the {Eth::Client} super-class to connect to Ethereum
+  # network's RPC-API endpoints (IPC or HTTP).
+  class Client
+
+    # The client's RPC-request ID starting at 0.
+    attr_reader :id
+
+    # The connected network's chain ID.
+    attr_reader :chain_id
+
+    # The connected network's client coinbase.
+    attr_accessor :default_account
+
+    # The default transaction max priority fee per gas in Wei.
+    attr_accessor :max_priority_fee_per_gas
+
+    # The default transaction max fee per gas in Wei.
+    attr_accessor :max_fee_per_gas
+
+    # The default gas limit for the transaction.
+    attr_accessor :gas_limit
+
+    # Creates a new RPC-Client, either by providing an HTTP/S host or
+    # an IPC path.
+    #
+    # @param host [String] either an HTTP/S host or an IPC path.
+    # @return [Eth::Client::Ipc] an IPC client.
+    # @return [Eth::Client::Http] an HTTP client.
+    # @raise [ArgumentError] in case it cannot determine the client type.
+    def self.create(host)
+      return Client::Ipc.new host if host.end_with? ".ipc"
+      return Client::Http.new host if host.start_with? "http"
+      raise ArgumentError, "Unable to detect client type!"
+    end
+
+    # Constructor for the {Eth::Client} super-class. Should not be used;
+    # use {Client.create} intead.
+    def initialize(_)
+      @id = 0
+      @max_priority_fee_per_gas = 0
+      @max_fee_per_gas = Tx::DEFAULT_GAS_PRICE
+      @gas_limit = Tx::DEFAULT_GAS_LIMIT
+    end
+
+    # Gets the default account (coinbase) of the connected client.
+    #
+    # @return [Eth::Address] the coinbase account address.
+    def default_account
+      @default_account ||= Address.new eth_coinbase["result"]
+    end
+
+    # Gets the chain ID of the connected network.
+    #
+    # @return [Integer] the chain ID.
+    def chain_id
+      @chain_id ||= eth_chain_id["result"].to_i 16
+    end
+
+    # Gets the balance for an address.
+    #
+    # @param address [Eth::Address] the address to get the balance for.
+    # @return [Integer] the balance in Wei.
+    def get_balance(address)
+      eth_get_balance(address)["result"].to_i 16
+    end
+
+    # Gets the next nonce for an address used to draft new transactions.
+    #
+    # @param address [Eth::Address] the address to get the nonce for.
+    # @return [Integer] the next nonce to be used.
+    def get_nonce(address)
+      eth_get_transaction_count(address, "pending")["result"].to_i 16
+    end
+
+    # Simply transfer Ether to an account and waits for it to be mined.
+    # Uses `eth_coinbase` and external signer if no  sender key is
+    # provided.
+    #
+    # @param destination [Eth::Address] the destination address.
+    # @param amount [Integer] the transfer amount in Wei.
+    # @param sender_key [Eth::Key] the sender private key.
+    # @param legacy [Boolean] enables legacy transactions (pre-EIP-1559).
+    # @return [String] the transaction hash.
+    def transfer_and_wait(destination, amount, sender_key = nil, legacy = false)
+      wait_for_tx(transfer(destination, amount, sender_key, legacy))
+    end
+
+    # Simply transfer Ether to an account without any call data or
+    # access lists attached. Uses `eth_coinbase` and external signer
+    # if no sender key is provided.
+    #
+    # @param destination [Eth::Address] the destination address.
+    # @param amount [Integer] the transfer amount in Wei.
+    # @param sender_key [Eth::Key] the sender private key.
+    # @param legacy [Boolean] enables legacy transactions (pre-EIP-1559).
+    # @return [String] the transaction hash.
+    def transfer(destination, amount, sender_key = nil, legacy = false)
+      params = {
+        value: amount,
+        to: destination,
+        gas_limit: gas_limit,
+        chain_id: chain_id,
+      }
+      if legacy
+        params.merge!({
+          gas_price: max_fee_per_gas,
+        })
+      else
+        params.merge!({
+          priority_fee: max_priority_fee_per_gas,
+          max_gas_fee: max_fee_per_gas,
+        })
+      end
+      unless sender_key.nil?
+
+        # use the provided key as sender and signer
+        params.merge!({
+          from: sender_key.address,
+          nonce: get_nonce(sender_key.address),
+        })
+        tx = Eth::Tx.new(params)
+        tx.sign sender_key
+        return eth_send_raw_transaction(tx.hex)["result"]
+      else
+
+        # use the default account as sender and external signer
+        params.merge!({
+          from: default_account,
+          nonce: get_nonce(default_account),
+        })
+        return eth_send_transaction(params)["result"]
+      end
+    end
+
+    # Gives control over resetting the RPC request ID back to zero.
+    # Usually not needed.
+    #
+    # @return [Integer] 0
+    def reset_id
+      @id = 0
+    end
+
+    # Checkes wether a transaction is mined or not.
+    #
+    # @param hash [String] the transaction hash.
+    # @return [Boolean] true if included in a block.
+    def is_mined_tx?(hash)
+      mined_tx = eth_get_transaction_by_hash hash
+      !mined_tx.nil? && !mined_tx["result"].nil? && !mined_tx["result"]["blockNumber"].nil?
+    end
+
+    # Waits for an transaction to be mined by the connected chain.
+    #
+    # @param hash [String] the transaction hash.
+    # @return [String] the transactin hash once the transaction is mined.
+    # @raise [Timeout::Error] if it's not mined within 5 minutes.
+    def wait_for_tx(hash)
+      start_time = Time.now
+      timeout = 300
+      retry_rate = 0.1
+      loop do
+        raise Timeout::Error if ((Time.now - start_time) > timeout)
+        return hash if is_mined_tx? hash
+        sleep retry_rate
+      end
+    end
+
+    # Metafunction to provide all known RPC commands defined in
+    # Eth::Api as snake_case methods to the Eth::Client classes.
+    Api::COMMANDS.each do |cmd|
+      method_name = cmd.gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
+      define_method method_name do |*args|
+        send_command cmd, args
+      end
+    end
+
+    private
+
+    # Prepares parameters and sends the command to the client.
+    def send_command(command, args)
+      args << "latest" if ["eth_getBalance", "eth_call"].include? command
+      payload = {
+        jsonrpc: "2.0",
+        method: command,
+        params: marshal(args),
+        id: next_id,
+      }
+      output = JSON.parse(send(payload.to_json))
+      raise IOError, output["error"]["message"] unless output["error"].nil?
+      return output
+    end
+
+    # Increments the request id.
+    def next_id
+      @id += 1
+    end
+
+    # Recursively marshals all request parameters.
+    def marshal(params)
+      if params.is_a? Array
+        return params.map! { |param| marshal(param) }
+      elsif params.is_a? Hash
+        return params.transform_values! { |param| marshal(param) }
+      elsif params.is_a? Numeric
+        return Util.prefix_hex "#{params.to_i.to_s(16)}"
+      elsif params.is_a? Address
+        return params.to_s
+      elsif Util.is_hex? params
+        return Util.prefix_hex params
+      else
+        return params
+      end
+    end
+  end
+end

data/lib/klay/constant.rb

@@ -0,0 +1,71 @@
+# 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 Klay
+
+  # Provides commonly used constants, such as zero bytes or zero keys.
+  module Constant
+
+    # The empty byte is defined as "".
+    BYTE_EMPTY = "".freeze
+
+    # The zero byte is 0x00.
+    BYTE_ZERO = "\x00".freeze
+
+    # The byte one is 0x01.
+    BYTE_ONE = "\x01".freeze
+
+    # The size of a 32-bit number.
+    TT32 = (2 ** 32).freeze
+
+    # The size of a 256-bit number.
+    TT256 = (2 ** 256).freeze
+
+    # The maximum possible value of an UInt256.
+    UINT_MAX = (2 ** 256 - 1).freeze
+
+    # The minimum possible value of an UInt256.
+    UINT_MIN = 0.freeze
+
+    # The maximum possible value of an Int256.
+    INT_MAX = (2 ** 255 - 1).freeze
+
+    # The minimum possible value of an Int256.
+    INT_MIN = (-2 ** 255).freeze
+
+    # A hash containing only zeros.
+    HASH_ZERO = ("\x00" * 32).freeze
+
+    # The RLP short length limit.
+    SHORT_LENGTH_LIMIT = 56.freeze
+
+    # The RLP long length limit.
+    LONG_LENGTH_LIMIT = (256 ** 8).freeze
+
+    # The RLP primitive type offset.
+    PRIMITIVE_PREFIX_OFFSET = 0x80.freeze
+
+    # The RLP array type offset.
+    LIST_PREFIX_OFFSET = 0xc0.freeze
+
+    # The binary encoding is ASCII (8-bit).
+    BINARY_ENCODING = "ASCII-8BIT".freeze
+
+    # Infinity as constant for convenience.
+    INFINITY = (1.0 / 0.0).freeze
+  end
+end

data/lib/klay/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 Klay
+
+  # 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/klay/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 Klay
+
+  # 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