eth 0.5.13 → 0.5.15

data/lib/eth/abi/packed/encoder.rb

@@ -0,0 +1,196 @@
+# Copyright (c) 2016-2025 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 a Ruby implementation of the Ethereum Application Binary Interface (ABI).
+  module Abi
+
+    # Encapsulates the module for non-standard packed encoding used in Solidity.
+    module Packed
+
+      # Provides a utility module to assist encoding ABIs.
+      module Encoder
+        extend self
+
+        # Encodes a specific value, either static or dynamic in non-standard
+        # packed encoding mode.
+        #
+        # @param type [Eth::Abi::Type] type to be encoded.
+        # @param arg [String|Number] value to be encoded.
+        # @return [String] the packed encoded type.
+        # @raise [EncodingError] if value does not match type.
+        # @raise [ArgumentError] if encoding fails for type.
+        def type(type, arg)
+          case type
+          when /^uint(\d+)$/
+            uint(arg, $1.to_i / 8)
+          when /^int(\d+)$/
+            int(arg, $1.to_i / 8)
+          when "bool"
+            bool(arg)
+          when /^ureal(\d+)x(\d+)$/, /^ufixed(\d+)x(\d+)$/
+            ufixed(arg, $1.to_i / 8, $2.to_i)
+          when /^real(\d+)x(\d+)$/, /^fixed(\d+)x(\d+)$/
+            fixed(arg, $1.to_i / 8, $2.to_i)
+          when "string"
+            string(arg)
+          when /^bytes(\d+)$/
+            bytes(arg, $1.to_i)
+          when "bytes"
+            string(arg)
+          when /^tuple\((.+)\)$/
+            tuple($1.split(","), arg)
+          when /^hash(\d+)$/
+            hash(arg, $1.to_i / 8)
+          when "address"
+            address(arg)
+          when /^(.+)\[\]$/
+            array($1, arg)
+          when /^(.+)\[(\d+)\]$/
+            fixed_array($1, arg, $2.to_i)
+          else
+            raise EncodingError, "Unhandled type: #{type}"
+          end
+        end
+
+        private
+
+        # Properly encodes signed integers.
+        def uint(value, byte_size)
+          raise ArgumentError, "Don't know how to handle this input." unless value.is_a? Numeric
+          raise ValueOutOfBounds, "Number out of range: #{value}" if value > Constant::UINT_MAX or value < Constant::UINT_MIN
+          i = value.to_i
+          Util.zpad_int i, byte_size
+        end
+
+        # Properly encodes signed integers.
+        def int(value, byte_size)
+          raise ArgumentError, "Don't know how to handle this input." unless value.is_a? Numeric
+          raise ValueOutOfBounds, "Number out of range: #{value}" if value > Constant::INT_MAX or value < Constant::INT_MIN
+          real_size = byte_size * 8
+          i = value.to_i % 2 ** real_size
+          Util.zpad_int i, byte_size
+        end
+
+        # Properly encodes booleans.
+        def bool(value)
+          raise EncodingError, "Argument is not bool: #{value}" unless value.instance_of? TrueClass or value.instance_of? FalseClass
+          (value ? "\x01" : "\x00").b
+        end
+
+        # Properly encodes unsigned fixed-point numbers.
+        def ufixed(value, byte_size, decimals)
+          raise ArgumentError, "Don't know how to handle this input." unless value.is_a? Numeric
+          raise ValueOutOfBounds, value unless value >= 0 and value < 2 ** decimals
+          scaled_value = (value * (10 ** decimals)).to_i
+          uint(scaled_value, byte_size)
+        end
+
+        # Properly encodes signed fixed-point numbers.
+        def fixed(value, byte_size, decimals)
+          raise ArgumentError, "Don't know how to handle this input." unless value.is_a? Numeric
+          raise ValueOutOfBounds, value unless value >= -2 ** (decimals - 1) and value < 2 ** (decimals - 1)
+          scaled_value = (value * (10 ** decimals)).to_i
+          int(scaled_value, byte_size)
+        end
+
+        # Properly encodes byte(-string)s.
+        def bytes(value, length)
+          raise EncodingError, "Expecting String: #{value}" unless value.instance_of? String
+          value = handle_hex_string value, length
+          raise ArgumentError, "Value must be a string of length #{length}" unless value.is_a?(String) && value.bytesize == length
+          value.b
+        end
+
+        # Properly encodes (byte-)strings.
+        def string(value)
+          raise ArgumentError, "Value must be a string" unless value.is_a?(String)
+          value.b
+        end
+
+        # Properly encodes tuples.
+        def tuple(types, values)
+          Abi.solidity_packed(types, values)
+        end
+
+        # Properly encodes hash-strings.
+        def hash(value, byte_size)
+          raise EncodingError, "Argument too long: #{value}" unless byte_size > 0 and byte_size <= 32
+          hash_bytes = handle_hex_string value, byte_size
+          hash_bytes.b
+        end
+
+        # Properly encodes addresses.
+        def address(value)
+          if value.is_a? Address
+
+            # from checksummed address with 0x prefix
+            Util.zpad_hex value.to_s[2..-1], 20
+          elsif value.is_a? Integer
+
+            # address from integer
+            Util.zpad_int value, 20
+          elsif value.size == 20
+
+            # address from encoded address
+            Util.zpad value, 20
+          elsif value.size == 40
+
+            # address from hexadecimal address
+            Util.zpad_hex value, 20
+          elsif value.size == 42 and value[0, 2] == "0x"
+
+            # address from hexadecimal address with 0x prefix
+            Util.zpad_hex value[2..-1], 20
+          else
+            raise EncodingError, "Could not parse address: #{value}"
+          end
+        end
+
+        # Properly encodes dynamic-sized arrays.
+        def array(type, values)
+          values.map { |value| type(type, value) }.join.b
+        end
+
+        # Properly encodes fixed-size arrays.
+        def fixed_array(type, values, size)
+          raise ArgumentError, "Array size does not match" unless values.size == size
+          array(type, values)
+        end
+
+        # The ABI encoder needs to be able to determine between a hex `"123"`
+        # and a binary `"123"` string.
+        def handle_hex_string(val, len)
+          if Util.prefixed? val or
+             (len === val.size / 2 and Util.hex? val)
+
+            # There is no way telling whether a string is hex or binary with certainty
+            # in Ruby. Therefore, we assume a `0x` prefix to indicate a hex string.
+            # Additionally, if the string size is exactly the double of the expected
+            # binary size, we can assume a hex value.
+            Util.hex_to_bin val
+          else
+
+            # Everything else will be assumed binary or raw string.
+            val.b
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eth/abi/type.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2016-2023 The Ruby-Eth Contributors
+# Copyright (c) 2016-2025 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.
@@ -80,10 +80,24 @@ module Eth
           return
         end
 
-        _, base_type, sub_type, dimension = /([a-z]*)([0-9]*x?[0-9]*)((\[[0-9]*\])*)/.match(type).to_a
+        # ensure the type string is reasonable before attempting to parse
+        raise ParseError, "Invalid type format" unless type.is_a?(String) && type.bytesize <= 256
 
-        # type dimension can only be numeric
-        dims = dimension.scan(/\[[0-9]*\]/)
+        if type.start_with?("tuple(")
+          inner, rest = extract_tuple(type)
+          inner_types = split_tuple_types(inner)
+          inner_types.each { |t| Type.parse(t) }
+          base_type = "tuple"
+          sub_type = ""
+          dimension = rest
+        else
+          match = /\A([a-z]+)([0-9]*x?[0-9]*)((?:\[\d+\]|\[\])*)\z/.match(type)
+          raise ParseError, "Invalid type format" unless match
+          _, base_type, sub_type, dimension = match.to_a
+        end
+
+        # type dimension can only be numeric or empty for dynamic arrays
+        dims = dimension.scan(/\[\d+\]|\[\]/)
         raise ParseError, "Unknown characters found in array declaration" if dims.join != dimension
 
         # enforce base types
@@ -93,8 +107,8 @@ module Eth
         sub_type = sub_type.to_s
         @base_type = base_type
         @sub_type = sub_type
-        @dimensions = dims.map { |x| x[1...-1].to_i }
-        @components = components.map { |component| Abi::Type.parse(component["type"], component.dig("components"), component.dig("name")) } unless components.nil?
+        @dimensions = dims.map { |x| x == "[]" ? 0 : x[1...-1].to_i }
+        @components = components.map { |component| Abi::Type.parse(component["type"], component.dig("components"), component.dig("name")) } if components&.any?
         @name = component_name
       end
 
@@ -123,10 +137,10 @@ module Eth
         if dimensions.empty?
           if !(["string", "bytes", "tuple"].include?(base_type) and sub_type.empty?)
             s = 32
-          elsif base_type == "tuple" && components.none?(&:dynamic?)
+          elsif base_type == "tuple" and components&.none?(&:dynamic?)
             s = components.sum(&:size)
           end
-        elsif dimensions.last != 0 && !nested_sub.dynamic?
+        elsif dimensions.last != 0 and !nested_sub.dynamic?
           s = dimensions.last * nested_sub.size
         end
         @size ||= s
@@ -153,7 +167,7 @@ module Eth
         if base_type == "tuple"
           "(" + components.map(&:to_s).join(",") + ")" + (dimensions.size > 0 ? dimensions.map { |x| "[#{x == 0 ? "" : x}]" }.join : "")
         elsif dimensions.empty?
-          if %w[string bytes].include?(base_type) && sub_type.empty?
+          if %w[string bytes].include?(base_type) and sub_type.empty?
             base_type
           else
             "#{base_type}#{sub_type}"
@@ -175,7 +189,7 @@ module Eth
         when "bytes"
 
           # bytes can be no longer than 32 bytes
-          raise ParseError, "Maximum 32 bytes for fixed-length string or bytes" unless sub_type.empty? || sub_type.to_i <= 32
+          raise ParseError, "Maximum 32 bytes for fixed-length string or bytes" unless sub_type.empty? or (sub_type.to_i <= 32 and sub_type.to_i > 0)
         when "tuple"
 
           # tuples can not have any suffix
@@ -187,16 +201,16 @@ module Eth
 
           # integer size must be valid
           size = sub_type.to_i
-          raise ParseError, "Integer size out of bounds" unless size >= 8 && size <= 256
+          raise ParseError, "Integer size out of bounds" unless size >= 8 and size <= 256
           raise ParseError, "Integer size must be multiple of 8" unless size % 8 == 0
         when "ureal", "real", "fixed", "ufixed"
 
           # floats must have valid dimensional suffix
-          raise ParseError, "Real type must have suffix of form <high>x<low>, e.g. 128x128" unless sub_type =~ /\A[0-9]+x[0-9]+\z/
-          high, low = sub_type.split("x").map(&:to_i)
-          total = high + low
-          raise ParseError, "Real size out of bounds (max 32 bytes)" unless total >= 8 && total <= 256
-          raise ParseError, "Real high/low sizes must be multiples of 8" unless high % 8 == 0 && low % 8 == 0
+          raise ParseError, "Real type must have suffix of form <size>x<decimals>, e.g. 128x128" unless sub_type =~ /\A[0-9]+x[0-9]+\z/
+          size, decimals = sub_type.split("x").map(&:to_i)
+          total = size + decimals
+          raise ParseError, "Real size out of bounds (max 32 bytes)" unless total >= 8 and total <= 256
+          raise ParseError, "Real size must be multiples of 8" unless size % 8 == 0
         when "hash"
 
           # hashs must have numerical suffix
@@ -215,6 +229,53 @@ module Eth
           raise ParseError, "Unknown base type"
         end
       end
+
+      # Extracts the inner type list and trailing dimensions from an inline tuple definition.
+      def extract_tuple(type)
+        idx = 6 # skip "tuple("
+        depth = 1
+        while idx < type.length && depth > 0
+          case type[idx]
+          when "("
+            depth += 1
+          when ")"
+            depth -= 1
+          end
+          idx += 1
+        end
+        raise ParseError, "Invalid tuple format" unless depth.zero?
+        inner = type[6...(idx - 1)]
+        rest = type[idx..] || ""
+        [inner, rest]
+      end
+
+      # Splits a tuple component list into individual type strings, handling nested tuples.
+      def split_tuple_types(str)
+        types = []
+        depth = 0
+        current = ""
+        str.each_char do |ch|
+          case ch
+          when "("
+            depth += 1
+            current << ch
+          when ")"
+            depth -= 1
+            current << ch
+          when ","
+            if depth.zero?
+              types << current
+              current = ""
+            else
+              current << ch
+            end
+          else
+            current << ch
+          end
+        end
+        types << current unless current.empty?
+        types
+      end
     end
   end
 end

data/lib/eth/abi.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2016-2023 The Ruby-Eth Contributors
+# Copyright (c) 2016-2025 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.
@@ -38,8 +38,13 @@ module Eth
     #
     # @param types [Array] types to be ABI-encoded.
     # @param args [Array] values to be ABI-encoded.
+    # @param packed [Bool] set true to return packed encoding (default: `false`).
     # @return [String] the encoded ABI data.
-    def encode(types, args)
+    def encode(types, args, packed = false)
+      return solidity_packed(types, args) if packed
+      types = [types] unless types.instance_of? Array
+      args = [args] unless args.instance_of? Array
+      raise ArgumentError, "Types and values must be the same length" if types.length != args.length
 
       # parse all types
       parsed_types = types.map { |t| Type === t ? t : Type.parse(t) }
@@ -64,6 +69,26 @@ module Eth
       "#{head}#{tail}"
     end
 
+    # Encodes Application Binary Interface (ABI) data in non-standard packed mode.
+    # It accepts multiple arguments and encodes using the head/tail mechanism.
+    #
+    # @param types [Array] types to be ABI-encoded.
+    # @param args [Array] values to be ABI-encoded.
+    # @return [String] the encoded packed ABI data.
+    # @raise [ArgumentError] if types and args are of different size.
+    def solidity_packed(types, args)
+      raise ArgumentError, "Types and values must be the same length" if types.length != args.length
+
+      # We do not use the type system for packed encoding but want to call the parser once
+      # to enforce the type validation.
+      _ = types.map { |t| Type === t ? t : Type.parse(t) }
+
+      packed = types.zip(args).map do |type, arg|
+        Abi::Packed::Encoder.type(type, arg)
+      end.join
+      packed.force_encoding(Encoding::ASCII_8BIT)
+    end
+
     # Decodes Application Binary Interface (ABI) data. It accepts multiple
     # arguments and decodes using the head/tail mechanism.
     #
@@ -123,7 +148,9 @@ module Eth
   end
 end
 
+require "eth/abi/packed/encoder"
 require "eth/abi/decoder"
 require "eth/abi/encoder"
 require "eth/abi/event"
+require "eth/abi/function"
 require "eth/abi/type"

data/lib/eth/address.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2016-2023 The Ruby-Eth Contributors
+# Copyright (c) 2016-2025 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.
@@ -17,6 +17,8 @@ module Eth
 
   # The {Eth::Address} class to handle checksummed Ethereum addresses.
   class Address
+
+    # The literal zero address 0x0.
     ZERO = "0x0000000000000000000000000000000000000000"
 
     # Provides a special checksum error if EIP-55 is violated.

data/lib/eth/api.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2016-2023 The Ruby-Eth Contributors
+# Copyright (c) 2016-2025 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.

data/lib/eth/chain.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2016-2023 The Ruby-Eth Contributors
+# Copyright (c) 2016-2025 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.
@@ -149,13 +149,21 @@ module Eth
     # Chain ID for Arbitrum Goerli testnet.
     GOERLI_ARBITRUM = 421613.freeze
 
+    # Chain ID for Hoodi testnet.
+    HOODI = 560048.freeze
+
     # Chain ID for Sepolia testnet.
     SEPOLIA = 11155111.freeze
 
     # Chain ID for Holesovice testnet.
     HOLESOVICE = 11166111.freeze
+
+    # Chain ID for Holesovice testnet.
     HOLESKY = HOLESOVICE
 
+    # Chain ID for Basecamp testnet.
+    BASECAMP = 123420001114.freeze
+
     # Chain ID for the geth private network preset.
     PRIVATE_GETH = 1337.freeze
 

data/lib/eth/client/http.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2016-2023 The Ruby-Eth Contributors
+# Copyright (c) 2016-2025 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.
@@ -49,9 +49,13 @@ module Eth
       if !(uri.user.nil? && uri.password.nil?)
         @user = uri.user
         @password = uri.password
-        @uri = URI("#{uri.scheme}://#{uri.user}:#{uri.password}@#{@host}:#{@port}#{uri.path}")
+        if uri.query
+          @uri = URI("#{uri.scheme}://#{uri.user}:#{uri.password}@#{@host}:#{@port}#{uri.path}?#{uri.query}")
+        else
+          @uri = URI("#{uri.scheme}://#{uri.user}:#{uri.password}@#{@host}:#{@port}#{uri.path}")
+        end
       else
-        @uri = URI("#{uri.scheme}://#{@host}:#{@port}#{uri.path}")
+        @uri = uri
       end
     end
 

data/lib/eth/client/ipc.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2016-2023 The Ruby-Eth Contributors
+# Copyright (c) 2016-2025 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.

data/lib/eth/client.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2016-2023 The Ruby-Eth Contributors
+# Copyright (c) 2016-2025 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.
@@ -40,6 +40,21 @@ module Eth
     # A custom error type if a contract interaction fails.
     class ContractExecutionError < StandardError; end
 
+    # Raised when an RPC call returns an error. Carries the optional
+    # hex-encoded error data to support custom error decoding.
+    class RpcError < IOError
+      attr_reader :data
+
+      # Constructor for the {RpcError} class.
+      #
+      # @param message [String] the error message returned by the RPC.
+      # @param data [String] optional hex encoded error data.
+      def initialize(message, data = nil)
+        super(message)
+        @data = data
+      end
+    end
+
     # Creates a new RPC-Client, either by providing an HTTP/S host or
     # an IPC path. Supports basic authentication with username and password.
     #
@@ -251,21 +266,28 @@ module Eth
     #   @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.
+    # @see https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_call
     def call(contract, function, *args, **kwargs)
-      func = contract.functions.select { |func| func.name == function }
-      raise ArgumentError, "this function does not exist!" if func.nil? || func.size === 0
-      selected_func = func.first
-      func.each do |f|
-        if f.inputs.size === args.size
-          selected_func = f
-        end
-      end
-      output = call_raw(contract, selected_func, *args, **kwargs)
+      function = contract.function(function, args: args.size)
+      output = function.decode_call_result(
+        eth_call(
+          {
+            data: function.encode_call(*args),
+            to: kwargs[:address] || contract.address,
+            from: kwargs[:from],
+            gas: kwargs[:gas],
+            gasPrice: kwargs[:gas_price],
+            value: kwargs[:value],
+          }.compact
+        )["result"]
+      )
       if output&.length == 1
         output[0]
       else
         output
       end
+    rescue RpcError => e
+      raise ContractExecutionError, contract.decode_error(e)
     end
 
     # Executes a contract function with a transaction (transactional
@@ -298,13 +320,12 @@ module Eth
         else
           Tx.estimate_intrinsic_gas(contract.bin)
         end
-      fun = contract.functions.select { |func| func.name == function }[0]
       params = {
         value: kwargs[:tx_value] || 0,
         gas_limit: gas_limit,
         chain_id: chain_id,
         to: kwargs[:address] || contract.address,
-        data: call_payload(fun, args),
+        data: contract.function(function, args: args.size).encode_call(*args),
       }
       send_transaction(params, kwargs[:legacy], kwargs[:sender_key], kwargs[:nonce])
     end
@@ -320,8 +341,8 @@ module Eth
       begin
         hash = wait_for_tx(transact(contract, function, *args, **kwargs))
         return hash, tx_succeeded?(hash)
-      rescue IOError => e
-        raise ContractExecutionError, e
+      rescue RpcError => e
+        raise ContractExecutionError, contract.decode_error(e)
       end
     end
 
@@ -442,28 +463,6 @@ module Eth
       end
     end
 
-    # Non-transactional function call called from call().
-    # @see https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_call
-    def call_raw(contract, func, *args, **kwargs)
-      params = {
-        data: call_payload(func, args),
-        to: kwargs[:address] || contract.address,
-        from: kwargs[:from],
-      }.compact
-
-      raw_result = eth_call(params)["result"]
-      types = func.outputs.map { |i| i.type }
-      return nil if raw_result == "0x"
-      Eth::Abi.decode(types, raw_result)
-    end
-
-    # Encodes function call payloads.
-    def call_payload(fun, args)
-      types = fun.inputs.map(&:parsed_type)
-      encoded_str = Util.bin_to_hex(Eth::Abi.encode(types, args))
-      Util.prefix_hex(fun.signature + (encoded_str.empty? ? "0" * 64 : encoded_str))
-    end
-
     # Encodes constructor params
     def encode_constructor_params(contract, args)
       types = contract.constructor_inputs.map { |input| input.type }
@@ -481,7 +480,9 @@ module Eth
         id: next_id,
       }
       output = JSON.parse(send_request(payload.to_json))
-      raise IOError, output["error"]["message"] unless output["error"].nil?
+      if (err = output["error"])
+        raise RpcError.new(err["message"], err["data"])
+      end
       output
     end
 

data/lib/eth/constant.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2016-2023 The Ruby-Eth Contributors
+# Copyright (c) 2016-2025 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.

data/lib/eth/contract/error.rb

@@ -0,0 +1,62 @@
+# Copyright (c) 2016-2025 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 custom errors.
+  class Contract::Error
+    attr_accessor :name, :inputs, :signature, :error_string
+
+    # Constructor of the {Eth::Contract::Error} class.
+    #
+    # @param data [Hash] contract abi data for the error.
+    def initialize(data)
+      @name = data["name"]
+      @inputs = data.fetch("inputs", []).map do |input|
+        Eth::Contract::FunctionInput.new(input)
+      end
+      @error_string = self.class.calc_signature(@name, @inputs)
+      @signature = self.class.encoded_error_signature(@error_string)
+    end
+
+    # Creates error strings.
+    #
+    # @param name [String] error name.
+    # @param inputs [Array<Eth::Contract::FunctionInput>] error input class list.
+    # @return [String] error string.
+    def self.calc_signature(name, inputs)
+      "#{name}(#{inputs.map { |x| x.parsed_type.to_s }.join(",")})"
+    end
+
+    # Encodes an error signature.
+    #
+    # @param signature [String] error signature.
+    # @return [String] encoded error signature string.
+    def self.encoded_error_signature(signature)
+      Util.prefix_hex(Util.bin_to_hex(Util.keccak256(signature)[0..3]))
+    end
+
+    # Decodes a revert error payload.
+    #
+    # @param data [String] the hex-encoded revert data including selector.
+    # @return [Array] decoded error arguments.
+    def decode(data)
+      types = inputs.map(&:type)
+      payload = "0x" + data[10..]
+      Eth::Abi.decode(types, payload)
+    end
+  end
+end