eth 0.5.0 → 0.5.3

data/lib/eth/contract/function_input.rb

@@ -0,0 +1,36 @@
+# 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, :name
+
+    # Constructor of the {Eth::Contract::FunctionInput} class.
+    #
+    # @param data [Hash] contract abi data.
+    def initialize(data)
+      @type = Eth::Abi::Type.parse(data["type"])
+      @name = data["name"]
+    end
+
+    # Returns types like uint256
+    def type
+      @type.base_type + @type.sub_type
+    end
+  end
+end

data/lib/eth/contract/function_output.rb

@@ -0,0 +1,32 @@
+# 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
+
+    def initialize(data)
+      @type = Eth::Abi::Type.parse(data["type"])
+      @name = data["name"]
+    end
+
+    def type
+      @type.base_type + @type.sub_type
+    end
+  end
+end

data/lib/eth/contract/initializer.rb

@@ -0,0 +1,46 @@
+# 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
+
+    # Build and return all contracts.
+    def build_all
+      @contracts.each do |contract|
+        contract.build
+      end
+    end
+  end
+end

data/lib/eth/contract.rb

@@ -0,0 +1,120 @@
+# 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.
+    #
+    # @param file [String] solidity file path.
+    # @param bin [String] contract bin string.
+    # @param abi [String] contract abi string.
+    # @param address [String] contract address.
+    # @param name [String] name of contract.
+    # @param contract_index [Number] specify contract.
+    # @return [Eth::Contract::Object] Returns the class of the smart contract.
+    # @raise [JSON::ParserError] if the json format is wrong.
+    # @raise [ArgumentError] if argument is incorrect.
+    def self.create(file: nil, bin: nil, abi: nil, address: nil, name: nil, contract_index: nil)
+      if File.exist?(file.to_s)
+        contracts = Eth::Contract::Initializer.new(file).build_all
+        raise "No contracts compiled" if contracts.empty?
+        if contract_index
+          contract = contracts[contract_index].class_object.new
+        else
+          contract = contracts.first.class_object.new
+        end
+      elsif ![name, bin, abi].include? nil
+        begin
+          abi = abi.is_a?(Array) ? abi : JSON.parse(abi)
+        rescue JSON::ParserError => e
+          raise e
+        end
+        contract = Eth::Contract.new(name, bin, abi)
+        contract.build
+        contract = contract.class_object.new
+      else
+        raise ArgumentError, "The argument is incorrect."
+      end
+      contract.address = address
+      contract
+    end
+
+    # Set the address of the smart contract
+    def address=(addr)
+      @address = addr.nil? ? nil : Eth::Address.new(addr).address
+      @events.each do |event|
+        event.set_address(@address)
+      end
+    end
+
+    # Create 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
+        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

data/lib/eth/eip712.rb

@@ -12,11 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# Provides the `Eth` module.
+# 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
+  # Ref: https://eips.ethereum.org/EIPS/eip-712
   module Eip712
     extend self
 

data/lib/eth/key/decrypter.rb

@@ -12,37 +12,40 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# Provides the `Eth` module.
+# Provides the {Eth} module.
 module Eth
 
-  # The Eth::Key::Decrypter class to handle PBKDF2-SHA-256 decryption.
+  # 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`
+    # 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
+    # @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
-    # encryption.
+    # 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
+    # @param data [JSON] encryption data including cypherkey.
+    # @param password [String] password to decrypt the key.
     def initialize(data, password)
-      @data = JSON.parse(data)
+      data = JSON.parse(data) if data.is_a? String
+      @data = data
       @password = password
     end
 
-    # Method to decrypt key using password
+    # Method to decrypt key using password.
     #
-    # @return [String] decrypted key
+    # @return [Eth::Key] decrypted key.
     def perform
       derive_key password
       check_macs

data/lib/eth/key/encrypter.rb

@@ -12,45 +12,47 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# Provides the `Eth` module.
+# Provides the {Eth} module.
 module Eth
 
-  # The Eth::Key::Encrypter class to handle PBKDF2-SHA-256 encryption.
+  # The {Eth::Key::Encrypter} class to handle PBKDF2-SHA-256 encryption.
   class Key::Encrypter
 
     # Provides a specific encrypter error if decryption fails.
     class EncrypterError < StandardError; end
 
-    # Class method `Eth::Key::Encrypter.perform` to performa an key-store
+    # Class method {Eth::Key::Encrypter.perform} to performa an key-store
     # encryption.
     #
-    # @param key [Eth::Key] representing a secret key-pair used for encryption
-    # @param options [Hash] the options to encrypt with
-    # @option options [String] :kdf key derivation function defaults to pbkdf2
-    # @option options [String] :id uuid given to the secret key
-    # @option options [String] :iterations number of iterations for the hash function
-    # @option options [String] :salt passed to PBKDF
-    # @option options [String] :iv 128-bit initialisation vector for the cipher
-    # @option options [Integer] :parallelization parallelization factor for scrypt, defaults to 8
-    # @option options [Integer] :block_size for scrypt, defaults to 1
-    # @return [JSON] formatted with encrypted key (cyphertext) and [other identifying data](https://github.com/ethereum/wiki/wiki/Web3-Secret-Storage-Definition#pbkdf2-sha-256)
+    # @param key [Eth::Key] representing a secret key-pair used for encryption.
+    # @param options [Hash] the options to encrypt with.
+    # @option options [String] :kdf key derivation function defaults to pbkdf2.
+    # @option options [String] :id uuid given to the secret key.
+    # @option options [String] :iterations number of iterations for the hash function.
+    # @option options [String] :salt passed to PBKDF.
+    # @option options [String] :iv 128-bit initialisation vector for the cipher.
+    # @option options [Integer] :parallelization parallelization factor for scrypt, defaults to 8.
+    # @option options [Integer] :block_size for scrypt, defaults to 1.
+    # @return [JSON] formatted with encrypted key (cyphertext) and [other identifying data](https://github.com/ethereum/wiki/wiki/Web3-Secret-Storage-Definition#pbkdf2-sha-256).
     def self.perform(key, password, options = {})
       new(key, options).perform(password)
     end
 
-    # Constructor of the `Eth::Key::Encrypter` class for secret key
-    # encryption.
+    # Constructor of the {Eth::Key::Encrypter} class for secret key
+    # encryption. Should not be used; use {Eth::Key::Encrypter.perform}
+    # instead.
     #
-    # @param key [Eth::Key] representing a secret key-pair used for encryption
-    # @param options [Hash] the options to encrypt with
-    # @option options [String] :kdf key derivation function defaults to pbkdf2
-    # @option options [String] :id uuid given to the secret key
-    # @option options [String] :iterations number of iterations for the hash function
-    # @option options [String] :salt passed to PBKDF
-    # @option options [String] :iv 128-bit initialisation vector for the cipher
-    # @option options [Integer] :parallelization parallelization factor for scrypt, defaults to 8
-    # @option options [Integer] :block_size for scrypt, defaults to 1
+    # @param key [Eth::Key] representing a secret key-pair used for encryption.
+    # @param options [Hash] the options to encrypt with.
+    # @option options [String] :kdf key derivation function defaults to pbkdf2.
+    # @option options [String] :id uuid given to the secret key.
+    # @option options [String] :iterations number of iterations for the hash function.
+    # @option options [String] :salt passed to PBKDF.
+    # @option options [String] :iv 128-bit initialisation vector for the cipher.
+    # @option options [Integer] :parallelization parallelization factor for scrypt, defaults to 8.
+    # @option options [Integer] :block_size for scrypt, defaults to 1.
     def initialize(key, options = {})
+      key = Key.new(priv: key) if key.is_a? String
       @key = key
       @options = options
 
@@ -64,7 +66,7 @@ module Eth
     # Encrypt the key with a given password.
     #
     # @param password [String] a secret key used for encryption
-    # @return [String] a json-formatted keystore string.
+    # @return [String] a JSON-formatted keystore string.
     def perform(password)
       derive_key password
       encrypt

data/lib/eth/key.rb

@@ -18,28 +18,28 @@ require "rbsecp256k1"
 require "scrypt"
 require "securerandom"
 
-# Provides the `Eth` module.
+# Provides the {Eth} module.
 module Eth
 
-  # The `Eth::Key` class to handle Secp256k1 private/public key-pairs.
+  # The {Eth::Key} class to handle Secp256k1 private/public key-pairs.
   class Key
 
-    # The Eth::Key::Decrypter class to handle PBKDF2-SHA-256 decryption.
+    # 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.
+    # The {Eth::Key::Encrypter} class to handle PBKDF2-SHA-256 encryption.
     autoload :Encrypter, "eth/key/encrypter"
 
-    # The `Secp256k1::PrivateKey` of the `Eth::Key` pair.
+    # The `Secp256k1::PrivateKey` of the {Eth::Key} pair.
     attr_reader :private_key
 
-    # The `Secp256k1::PublicKey` of the `Eth::Key` pair.
+    # The `Secp256k1::PublicKey` of the {Eth::Key} pair.
     attr_reader :public_key
 
-    # Constructor of the `Eth::Key` class. Creates a new random key-pair
+    # 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 (optional).
+    # @param priv [String] binary string of private key data.
     def initialize(priv: nil)
 
       # Creates a new, randomized libsecp256k1 context.
@@ -63,9 +63,10 @@ module Eth
     end
 
     # Signs arbitrary data without validation. Should not be used unless really
-    # desired. See also: personal_sign, sign_typed_data.
+    # desired. See also: {Key.personal_sign}, {Key.sign_typed_data}, and
+    # {Signature.recover}.
     #
-    # @param blob [String] that arbitrary data to be signed.
+    # @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)
@@ -81,9 +82,11 @@ module Eth
       Util.bin_to_hex signature.pack "c*"
     end
 
-    # Prefixes a message with "\x19Ethereum Signed Message:" and signs
+    # 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).
+    # 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.
@@ -95,8 +98,10 @@ module Eth
     end
 
     # 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`.
+    # 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.
@@ -114,7 +119,7 @@ module Eth
     end
 
     # Exports the private key bytes in a wrapper function to maintain
-    # backward-compatibility with older versions of `Eth::Key`.
+    # backward-compatibility with older versions of {Eth::Key}.
     #
     # @return [String] private key as packed byte-string.
     def private_bytes
@@ -138,7 +143,7 @@ module Eth
     end
 
     # Exports the uncompressed public key bytes in a wrapper function to
-    # maintain backward-compatibility with older versions of `Eth::Key`.
+    # maintain backward-compatibility with older versions of {Eth::Key}.
     #
     # @return [String] uncompressed public key as packed byte-string.
     def public_bytes

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