eth 0.5.1 → 0.5.4

data/lib/eth/client.rb

@@ -149,6 +149,203 @@ module Eth
       end
     end
 
+    # Deploys a contract and waits for it to be mined. Uses
+    # `eth_coinbase` or external signer if no sender key is provided.
+    #
+    # @overload deploy(contract)
+    #   @param contract [Eth::Contract] contracts to deploy.
+    # @overload deploy(contract, sender_key)
+    #   @param contract [Eth::Contract] contracts to deploy.
+    #   @param sender_key [Eth::Key] the sender private key.
+    # @overload deploy(contract, sender_key, legacy)
+    #   @param contract [Eth::Contract] contracts to deploy.
+    #   @param sender_key [Eth::Key] the sender private key.
+    #   @param legacy [Boolean] enables legacy transactions (pre-EIP-1559).
+    # @return [String] the contract address.
+    def deploy_and_wait(contract, sender_key: nil, legacy: false)
+      hash = wait_for_tx(deploy(contract, sender_key: sender_key, legacy: legacy))
+      addr = eth_get_transaction_receipt(hash)["result"]["contractAddress"]
+      contract.address = Address.new(addr).to_s
+    end
+
+    # Deploys a contract. Uses `eth_coinbase` or external signer
+    # if no sender key is provided.
+    #
+    # @overload deploy(contract)
+    #   @param contract [Eth::Contract] contracts to deploy.
+    # @overload deploy(contract, sender_key)
+    #   @param contract [Eth::Contract] contracts to deploy.
+    #   @param sender_key [Eth::Key] the sender private key.
+    # @overload deploy(contract, sender_key, legacy)
+    #   @param contract [Eth::Contract] contracts to deploy.
+    #   @param sender_key [Eth::Key] the sender private key.
+    #   @param legacy [Boolean] enables legacy transactions (pre-EIP-1559).
+    # @return [String] the transaction hash.
+    # @raise [ArgumentError] in case the contract does not have any source.
+    def deploy(contract, sender_key: nil, legacy: false)
+      raise ArgumentError, "Cannot deploy contract without source or binary!" if contract.bin.nil?
+      gas_limit = Tx.estimate_intrinsic_gas(contract.bin) + Tx::CREATE_GAS
+      params = {
+        value: 0,
+        gas_limit: gas_limit,
+        chain_id: chain_id,
+        data: contract.bin,
+      }
+      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
+
+    # Calls a contract function without executing it
+    # (non-transactional contract read).
+    #
+    # @overload call(contract, function_name)
+    #   @param contract [Eth::Contract] subject contract to call.
+    #   @param function_name [String] method name to be called.
+    # @overload call(contract, function_name, value)
+    #   @param contract [Eth::Contract] subject contract to call.
+    #   @param function_name [String] method name to be called.
+    #   @param value [Integer|String] function arguments.
+    # @overload call(contract, function_name, value, sender_key, legacy)
+    #   @param contract [Eth::Contract] subject contract to call.
+    #   @param function_name [String] method name to be called.
+    #   @param value [Integer|String] function arguments.
+    #   @param sender_key [Eth::Key] the sender private key.
+    #   @param legacy [Boolean] enables legacy transactions (pre-EIP-1559).
+    # @return [Object] returns the result of the call.
+    def call(contract, function_name, *args, **kwargs)
+      func = contract.functions.select { |func| func.name == function_name }[0]
+      raise ArgumentError, "function_name does not exist!" if func.nil?
+      output = call_raw(contract, func, *args, **kwargs)
+      if output.length == 1
+        return output[0]
+      else
+        return output
+      end
+    end
+
+    # Executes a contract function with a transaction (transactional
+    # contract read/write).
+    #
+    # @overload transact(contract, function_name)
+    #   @param contract [Eth::Contract] subject contract to call.
+    #   @param function_name [String] method name to be called.
+    # @overload transact(contract, function_name, value)
+    #   @param contract [Eth::Contract] subject contract to call.
+    #   @param function_name [String] method name to be called.
+    #   @param value [Integer|String] function arguments.
+    # @overload transact(contract, function_name, value, sender_key, legacy, address)
+    #   @param contract [Eth::Contract] subject contract to call.
+    #   @param function_name [String] method name to be called.
+    #   @param value [Integer|String] function arguments.
+    #   @param sender_key [Eth::Key] the sender private key.
+    #   @param legacy [Boolean] enables legacy transactions (pre-EIP-1559).
+    #   @param address [String] contract address.
+    # @return [Object] returns the result of the call.
+    def transact(contract, function_name, *args, **kwargs)
+      gas_limit = Tx.estimate_intrinsic_gas(contract.bin) + Tx::CREATE_GAS
+      fun = contract.functions.select { |func| func.name == function_name }[0]
+      params = {
+        value: 0,
+        gas_limit: gas_limit,
+        chain_id: chain_id,
+        to: kwargs[:address] || contract.address,
+        data: call_payload(fun, args),
+      }
+      if kwargs[: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 kwargs[:sender_key].nil?
+        # use the provided key as sender and signer
+        params.merge!({
+          from: kwargs[:sender_key].address,
+          nonce: get_nonce(kwargs[:sender_key].address),
+        })
+        tx = Eth::Tx.new(params)
+        tx.sign kwargs[: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
+
+    # Executes a contract function with a transaction and waits for it
+    # to be mined (transactional contract read/write).
+    #
+    # @overload transact_and_wait(contract, function_name)
+    #   @param contract [Eth::Contract] subject contract to call.
+    #   @param function_name [String] method name to be called.
+    # @overload transact_and_wait(contract, function_name, value)
+    #   @param contract [Eth::Contract] subject contract to call.
+    #   @param function_name [String] method name to be called.
+    #   @param value [Integer|String] function arguments.
+    # @overload transact_and_wait(contract, function_name, value, sender_key, legacy, address)
+    #   @param contract [Eth::Contract] subject contract to call.
+    #   @param function_name [String] method name to be called.
+    #   @param value [Integer|String] function arguments.
+    #   @param sender_key [Eth::Key] the sender private key.
+    #   @param legacy [Boolean] enables legacy transactions (pre-EIP-1559).
+    #   @param address [String] contract address.
+    # @return [Object] returns the result of the call.
+    def transact_and_wait(contract, function_name, *args, **kwargs)
+      wait_for_tx(transact(contract, function_name, *args, **kwargs))
+    end
+
+    # Provides an interface to call `isValidSignature` as per EIP-1271 on a given
+    # smart contract to verify the given hash and signature matching the magic
+    # value.
+    #
+    # @param contract [Eth::Contract] a deployed contract implementing EIP-1271.
+    # @param hash [String] the message hash to be checked against the signature.
+    # @param signature [String] the signature to be recovered by the contract.
+    # @param magic [String] the expected magic value (defaults to `1626ba7e`).
+    # @return [Boolean] true if magic matches and signature is valid.
+    # @raise [ArgumentError] in case the contract cannot be called yet.
+    def is_valid_signature(contract, hash, signature, magic = "1626ba7e")
+      raise ArgumentError, "Contract not deployed yet." if contract.address.nil?
+      hash = Util.hex_to_bin hash if Util.is_hex? hash
+      signature = Util.hex_to_bin signature if Util.is_hex? signature
+      magic = Util.hex_to_bin magic if Util.is_hex? magic
+      result = call(contract, "isValidSignature", hash, signature)
+      return result === magic
+    end
+
     # Gives control over resetting the RPC request ID back to zero.
     # Usually not needed.
     #
@@ -169,7 +366,7 @@ module Eth
     # 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.
+    # @return [String] the transaction 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
@@ -193,6 +390,48 @@ module Eth
 
     private
 
+    # Non-transactional function call called from call().
+    def call_raw(contract, func, *args, **kwargs)
+      gas_limit = Tx.estimate_intrinsic_gas(contract.bin) + Tx::CREATE_GAS
+      params = {
+        gas_limit: gas_limit,
+        chain_id: chain_id,
+        data: call_payload(func, args),
+      }
+      if kwargs[:address] || contract.address
+        params.merge!({ to: kwargs[:address] || contract.address })
+      end
+      if kwargs[: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 kwargs[:sender_key].nil?
+        # use the provided key as sender and signer
+        params.merge!({
+          from: kwargs[:sender_key].address,
+          nonce: get_nonce(kwargs[:sender_key].address),
+        })
+        tx = Eth::Tx.new(params)
+        tx.sign kwargs[:sender_key]
+      end
+      raw_result = eth_call(params)["result"]
+      types = func.outputs.map { |i| i.type }
+      Eth::Abi.decode(types, raw_result)
+    end
+
+    # Encodes function call payloads.
+    def call_payload(fun, args)
+      types = fun.inputs.map { |i| i.type }
+      encoded_str = Util.bin_to_hex(Eth::Abi.encode(types, args))
+      "0x" + fun.signature + (encoded_str.empty? ? "0" * 64 : encoded_str)
+    end
+
     # Prepares parameters and sends the command to the client.
     def send_command(command, args)
       args << "latest" if ["eth_getBalance", "eth_call"].include? command

data/lib/eth/contract/event.rb

@@ -0,0 +1,41 @@
+# 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 event.
+  class Contract::Event
+    attr_accessor :name, :signature, :input_types, :inputs, :event_string, :address
+
+    # Constructor of the {Eth::Contract::Event} class.
+    #
+    # @param data [Hash] contract event data.
+    def initialize(data)
+      @name = data["name"]
+      @input_types = data["inputs"].collect { |x| x["type"] }
+      @inputs = data["inputs"].collect { |x| x["name"] }
+      @event_string = "#{@name}(#{@input_types.join(",")})"
+      @signature = Digest::Keccak.hexdigest(@event_string, 256)
+    end
+
+    # Set the address of the smart contract
+    #
+    # @param address [String] contract address.
+    def set_address(address)
+      @address = address.nil? ? nil : Eth::Address.new(address).address
+    end
+  end
+end

data/lib/eth/contract/function.rb

@@ -0,0 +1,56 @@
+# 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 the methods for smart contract function.
+  class Contract::Function
+    attr_accessor :name, :inputs, :outputs, :signature, :constant, :function_string
+
+    # Constructor of the {Eth::Function} class.
+    #
+    # @param data [Hash] function input and output data.
+    def initialize(data)
+      @name = data["name"]
+      @constant = data["constant"]
+      @inputs = data["inputs"].map do |input|
+        Eth::Contract::FunctionInput.new(input)
+      end
+      @outputs = data["outputs"].collect do |output|
+        Eth::Contract::FunctionOutput.new(output)
+      end
+      @function_string = self.class.calc_signature(@name, @inputs)
+      @signature = self.class.encoded_function_signature(@function_string)
+    end
+
+    # Create function strings.
+    #
+    # @param name [String] function name.
+    # @param inputs [Array<Eth::Contract::FunctionInput>] function input class list.
+    # @return [String] function string.
+    def self.calc_signature(name, inputs)
+      "#{name}(#{inputs.collect { |x| x.type }.join(",")})"
+    end
+
+    # encode function signature.
+    #
+    # @param signature [String] function signature.
+    # @return [String] encoded function signature string.
+    def self.encoded_function_signature(signature)
+      Digest::Keccak.hexdigest(signature, 256)[0..7]
+    end
+  end
+end

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,135 @@
+# 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
+        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/rlp/decoder.rb

@@ -63,7 +63,7 @@ module Eth
           # short string
           [:str, b0 - Constant::PRIMITIVE_PREFIX_OFFSET, start + 1]
         elsif b0 < Constant::LIST_PREFIX_OFFSET
-          raise DecodingError, "Length starts with zero bytes" if rlp.slice(start + 1) == Constant::BYTE_ZERO
+          enforce_no_zero_bytes rlp, start
 
           # long string
           ll = b0 - Constant::PRIMITIVE_PREFIX_OFFSET - Constant::SHORT_LENGTH_LIMIT + 1
@@ -75,7 +75,7 @@ module Eth
           # short list
           [:list, b0 - Constant::LIST_PREFIX_OFFSET, start + 1]
         else
-          raise DecodingError, "Length starts with zero bytes" if rlp.slice(start + 1) == Constant::BYTE_ZERO
+          enforce_no_zero_bytes rlp, start
 
           # long list
           ll = b0 - Constant::LIST_PREFIX_OFFSET - Constant::SHORT_LENGTH_LIMIT + 1
@@ -85,6 +85,11 @@ module Eth
         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

data/lib/eth/rlp/sedes/binary.rb

@@ -29,7 +29,7 @@ module Eth
         # A singleton class for binary values of fixed length.
         class << self
 
-          # Create a serializable bianry of fixed size.
+          # 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.
@@ -47,7 +47,7 @@ module Eth
           end
         end
 
-        # Create a serializable bianry of variable size.
+        # 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.