eth 0.5.14 → 0.5.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c5f56a3acb3981d3087e8125660e5670b8ba8bf6a5255e2742e439498327cd82
-  data.tar.gz: c54057d9b851ad567e846e390949927afe1986387eaba95fc8facb0aa3fef20d
+  metadata.gz: 58842e5f3990be268758249080b56b70c1f26f8299ef27e7549db6cc2f675e51
+  data.tar.gz: 388a599dde8f50f34d46287e028e4dfe0c855815baa10de4a8c258b549429286
 SHA512:
-  metadata.gz: ee0dacd29dde60d8368c382a8d0fdf444895a66f2795689961112f34e752fced4a350e26b255d5bc4b1872e7c423c5780cc35487bd2b349f984ac0f75facbfd8
-  data.tar.gz: ca7fbe6c973aceb5dcc56031dbfa03903392ba9ad2ff0aa90d29c4c6311cc899961954e606c9c400df523305815eb89b26bc1fed2c0d65fcb042b59f0b63064f
+  metadata.gz: 3d4e42a99aebc7a47673b0706ce8476e08beca249ecae812f10c76e4f8767088b6a185c232abf9cc977a6680b08ac7b38de9d211cfc741f3bb2aa5fce9a4730c
+  data.tar.gz: cb29ed0c90b56eeae5ce519a436fada62e47690c1ca447e230d0fa2f3915fe97cd3346506c6b67e9c93a88d333197f0735529dd3c66c764d1895e76b1aa82b57

data/CHANGELOG.md

@@ -1,6 +1,39 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 
+## [0.5.15]
+### Added
+* Eth/tx: add support for EIP-4844 transactions [#345](https://github.com/q9f/eth.rb/pull/345)
+* Eth/contract: support solidity custom errors as per ERC-6093 [#344](https://github.com/q9f/eth.rb/pull/344)
+* Eth/abi: decode transaction input [#354](https://github.com/q9f/eth.rb/pull/354)
+
+### Fixed
+* Eth/abi: handle tuple type without components [#335](https://github.com/q9f/eth.rb/issues/335)
+
+## [0.5.14]
+### Added
+* Add ability to decode event parameters using ABI reference. [#328](https://github.com/q9f/eth.rb/pull/328)
+* Add support for EIP-7702 transactions  [#320](https://github.com/q9f/eth.rb/pull/320)
+* Eth/abi: implement packed encoder [#310](https://github.com/q9f/eth.rb/pull/310)
+
+### Changed
+* Chore: run rufo, add docs [#332](https://github.com/q9f/eth.rb/pull/332)
+* Spec/client: fix nonce too low error handling in spec [#331](https://github.com/q9f/eth.rb/pull/331)
+* Move the tests that are failing due to a geth upgrade to pending  [#330](https://github.com/q9f/eth.rb/pull/330)
+* Spec/client: don't require any rpc api token for tests [#326](https://github.com/q9f/eth.rb/pull/326)
+* Build(deps): bump JamesIves/github-pages-deploy-action from 4.7.2 to 4.7.3 [#327](https://github.com/q9f/eth.rb/pull/327)
+* Eth/eip712: prepare tests for packed encoding [#216](https://github.com/q9f/eth.rb/pull/216)
+* Spec/solidity: mute system call output [#319](https://github.com/q9f/eth.rb/pull/319)
+* Updated nesting of describe blocks in the EIP-1559 spec. [#318](https://github.com/q9f/eth.rb/pull/318)
+* Update README.md [#317](https://github.com/q9f/eth.rb/pull/317)
+* Docs: update README.md [#314](https://github.com/q9f/eth.rb/pull/314)
+* Gem: update copyright headers [#312](https://github.com/q9f/eth.rb/pull/312)
+* Build(deps): bump JamesIves/github-pages-deploy-action from 4.7.1 to 4.7.2 [#309](https://github.com/q9f/eth.rb/pull/309)
+* Spec: switch from infura to drpc [#308](https://github.com/q9f/eth.rb/pull/308)
+* Ci: update ruby version [#307](https://github.com/q9f/eth.rb/pull/307)
+* Gem: bump version to 0.5.14 [#305](https://github.com/q9f/eth.rb/pull/305)
+* Docs: update changelog [#304](https://github.com/q9f/eth.rb/pull/304)
+
 ## [0.5.13]
 ### Changed
 * Eth/api: update to latest available go-ethereum apis [#301](https://github.com/q9f/eth.rb/pull/301)

data/CODE_OF_CONDUCT.md

@@ -115,8 +115,6 @@ community.
 
 ## Attribution
 
-This Code of Conduct is adapted from the [Contributor Covenant][homepage],
-version 2.1, available at
-[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
-Community Impact Guidelines were inspired by
-[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+This Code of Conduct is adapted from the [Contributor Covenant](https://www.contributor-covenant.org),
+version 2.1, available at [v2.1](https://www.contributor-covenant.org/version/2/1/code_of_conduct.html).
+Community Impact Guidelines were inspired by Mozilla's code of conduct enforcement ladder.

data/Gemfile

@@ -3,14 +3,14 @@
 source "https://rubygems.org"
 
 group :test, :development do
-  gem "bundler", "~> 2.4"
+  gem "bundler", "~> 2.5"
   gem "pry", "~> 0.15"
   gem "rake", "~> 13.2"
-  gem "rdoc", "~> 6.9"
+  gem "rdoc", "~> 6.13"
   gem "rspec", "~> 3.13"
   gem "rufo", "~> 0.18"
   gem "simplecov", "~> 0.22"
-  gem "simplecov-cobertura", "~> 2.1"
+  gem "simplecov-cobertura", "~> 3.0"
   gem "yard", "~> 0.9"
 end
 

data/README.md

@@ -10,9 +10,7 @@
 [![GitHub release (latest by date)](https://img.shields.io/github/v/release/q9f/eth.rb)](https://github.com/q9f/eth.rb/releases)
 [![Gem](https://img.shields.io/gem/v/eth)](https://rubygems.org/gems/eth)
 [![Gem](https://img.shields.io/gem/dt/eth)](https://rubygems.org/gems/eth)
-[![Visitors](https://hits.seeyoufarm.com/api/count/incr/badge.svg?url=https%3A%2F%2Fgithub.com%2Fq9f%2Feth.rb&count_bg=%2379C83D&title_bg=%23555555&icon=rubygems.svg&icon_color=%23FF0000&title=visitors&edge_flat=false)](https://hits.seeyoufarm.com)
 [![codecov](https://codecov.io/gh/q9f/eth.rb/branch/main/graph/badge.svg?token=IK7USBPBZY)](https://codecov.io/gh/q9f/eth.rb)
-[![Maintainability](https://api.codeclimate.com/v1/badges/469e6f66425198ad7614/maintainability)](https://codeclimate.com/github/q9f/eth.rb/maintainability)
 [![Top Language](https://img.shields.io/github/languages/top/q9f/eth.rb?color=red)](https://github.com/q9f/eth.rb/pulse)
 [![Yard Doc API](https://img.shields.io/badge/documentation-API-blue)](https://q9f.github.io/eth.rb)
 [![Usage Wiki](https://img.shields.io/badge/usage-WIKI-blue)](https://github.com/q9f/eth.rb/wiki)
@@ -34,11 +32,15 @@ What you get:
 - [x] EIP-2028 Call-data intrinsic gas cost estimates (plus access lists)
 - [x] EIP-2718 Ethereum Transaction Envelopes (and types)
 - [x] EIP-2930 Ethereum Type-1 Transactions (with access lists)
+- [x] EIP-4844 Ethereum Type-3 Transactions (with shard blobs)
+- [x] EIP-7702 Ethereum Type-4 Transactions (with authorization lists)
 - [x] ABI-Encoder and Decoder (including type parser)
+- [x] Packed ABI-Encoder for Solidity smart contracts
 - [x] RLP-Encoder and Decoder (including sedes)
 - [x] RPC-Client (IPC/HTTP) for Execution-Layer APIs
 - [x] Solidity bindings (compile contracts from Ruby)
 - [x] Full smart-contract support (deploy, transact, and call)
+- [x] ERC-6093 custom Solidity errors
 
 ## Installation
 Add this line to your application's Gemfile:
@@ -88,7 +90,7 @@ bundle install
 rspec
 ```
 
-The goal is to have 100% specification coverage for all code inside this gem.
+The goal is to have 100% unit-test coverage for all code inside this gem.
 
 ## Contributing
 Pull requests are welcome! To contribute, please consider the following:

data/SECURITY.md

@@ -10,8 +10,8 @@ later.
 
 | Gem            | Version | Supported          |
 | -------------- | ------- | ------------------ |
-| `eth`          | 0.5.x   | :white_check_mark: |
-| `eth`          | < 0.5   | :x:                |
+| `eth`          | >= 0.5  | :white_check_mark: |
+| `eth`          | <  0.5  | :x:                |
 | `ethereum`     | _any_   | :x:                |
 | `ethereum-abi` | _any_   | :x:                |
 | `rlp`          | _any_   | :x:                |

data/eth.gemspec

@@ -50,7 +50,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "rbsecp256k1", "~> 6.0"
 
   # openssl for encrypted key derivation
-  spec.add_dependency "openssl", ">= 2.2", "< 4.0"
+  spec.add_dependency "openssl", "~> 3.3"
 
   # scrypt for encrypted key derivation
   spec.add_dependency "scrypt", "~> 3.0"

data/lib/eth/abi/decoder.rb

@@ -43,11 +43,14 @@ module Eth
             # Case: decoding array of string/bytes
           else
             l = Util.deserialize_big_endian_to_int arg[0, 32]
+            raise DecodingError, "Wrong data size for dynamic array" unless arg.size >= 32 + 32 * l
 
             # Decode each element of the array
             (1..l).map do |i|
               pointer = Util.deserialize_big_endian_to_int arg[i * 32, 32] # Pointer to the size of the array's element
+              raise DecodingError, "Offset out of bounds" if pointer < 32 * l || pointer > arg.size - 64
               data_l = Util.deserialize_big_endian_to_int arg[32 + pointer, 32] # length of the element
+              raise DecodingError, "Offset out of bounds" if pointer + 32 + Util.ceil32(data_l) > arg.size
               type(Type.parse(type.base_type), arg[pointer + 32, Util.ceil32(data_l) + 32])
             end
           end
@@ -73,11 +76,19 @@ module Eth
           l = Util.deserialize_big_endian_to_int arg[0, 32]
           nested_sub = type.nested_sub
 
-          # ref https://github.com/ethereum/tests/issues/691
-          raise NotImplementedError, "Decoding dynamic arrays with nested dynamic sub-types is not implemented for ABI." if nested_sub.dynamic?
-
-          # decoded dynamic-sized arrays
-          (0...l).map { |i| type(nested_sub, arg[32 + nested_sub.size * i, nested_sub.size]) }
+          if nested_sub.dynamic?
+            raise DecodingError, "Wrong data size for dynamic array" unless arg.size >= 32 + 32 * l
+            offsets = (0...l).map do |i|
+              off = Util.deserialize_big_endian_to_int arg[32 + 32 * i, 32]
+              raise DecodingError, "Offset out of bounds" if off < 32 * l || off > arg.size - 64
+              off
+            end
+            offsets.map { |off| type(nested_sub, arg[32 + off..]) }
+          else
+            raise DecodingError, "Wrong data size for dynamic array" unless arg.size >= 32 + nested_sub.size * l
+            # decoded dynamic-sized arrays with static sub-types
+            (0...l).map { |i| type(nested_sub, arg[32 + nested_sub.size * i, nested_sub.size]) }
+          end
         elsif !type.dimensions.empty?
           l = type.dimensions.first
           nested_sub = type.nested_sub

data/lib/eth/abi/encoder.rb

@@ -46,32 +46,21 @@ module Eth
         elsif type.dynamic? && arg.is_a?(Array)
 
           # encodes dynamic-sized arrays
-          head, tail = "", ""
-          head += type(Type.size_type, arg.size)
+          head = type(Type.size_type, arg.size)
           nested_sub = type.nested_sub
 
-          # calculate offsets
-          if %w(string bytes).include?(type.base_type) && type.sub_type.empty?
-            offset = 0
-            arg.size.times do |i|
-              if i == 0
-                offset = arg.size * 32
-              else
-                number_of_words = ((arg[i - 1].size + 32 - 1) / 32).floor
-                total_bytes_length = number_of_words * 32
-                offset += total_bytes_length + 32
-              end
-
+          if nested_sub.dynamic?
+            tails = arg.map { |a| type(nested_sub, a) }
+            offset = arg.size * 32
+            tails.each do |t|
               head += type(Type.size_type, offset)
+              offset += t.size
             end
-          elsif nested_sub.base_type == "tuple" && nested_sub.dynamic?
-            head += struct_offsets(nested_sub, arg)
-          end
-
-          arg.size.times do |i|
-            head += type nested_sub, arg[i]
+            head + tails.join
+          else
+            arg.each { |a| head += type(nested_sub, a) }
+            head
           end
-          "#{head}#{tail}"
         else
           if type.dimensions.empty?
 

data/lib/eth/abi/function.rb

@@ -0,0 +1,124 @@
+# 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
+
+    # Provides a module to decode transaction input data.
+    module Function
+      extend self
+
+      # Build function signature string from ABI interface.
+      #
+      # @param interface [Hash] ABI function interface.
+      # @return [String] interface signature string.
+      def signature(interface)
+        name = interface.fetch("name")
+        inputs = interface.fetch("inputs", [])
+        types = inputs.map { |i| type(i) }
+        "#{name}(#{types.join(",")})"
+      end
+
+      # Compute selector for ABI function interface.
+      #
+      # @param interface [Hash] ABI function interface.
+      # @return [String] a hex-string selector.
+      def selector(interface)
+        sig = signature(interface)
+        Util.prefix_hex(Util.bin_to_hex(Util.keccak256(sig))[0, 8])
+      end
+
+      # Gets the input type for functions.
+      #
+      # @param input [Hash] function input.
+      # @return [String] input type.
+      def type(input)
+        if input["type"] == "tuple"
+          "(#{input["components"].map { |c| type(c) }.join(",")})"
+        elsif input["type"] == "enum"
+          "uint8"
+        else
+          input["type"]
+        end
+      end
+
+      # A decoded function call.
+      class CallDescription
+        # The function ABI interface used to decode the call.
+        attr_accessor :function_interface
+
+        # The positional arguments of the call.
+        attr_accessor :args
+
+        # The named arguments of the call.
+        attr_accessor :kwargs
+
+        # The function selector.
+        attr_accessor :selector
+
+        # Creates a description object for a decoded function call.
+        #
+        # @param function_interface [Hash] function ABI type.
+        # @param selector [String] function selector hex-string.
+        # @param args [Array] decoded positional arguments.
+        # @param kwargs [Hash] decoded keyword arguments.
+        def initialize(function_interface, selector, args, kwargs)
+          @function_interface = function_interface
+          @selector = selector
+          @args = args
+          @kwargs = kwargs
+        end
+
+        # The function name. (e.g. transfer)
+        def name
+          @name ||= function_interface.fetch("name")
+        end
+
+        # The function signature. (e.g. transfer(address,uint256))
+        def signature
+          @signature ||= Function.signature(function_interface)
+        end
+      end
+
+      # Decodes a transaction input with a set of ABI interfaces.
+      #
+      # @param interfaces [Array] function ABI types.
+      # @param data [String] transaction input data.
+      # @return [CallDescription, nil] a CallDescription object or nil if selector unknown.
+      def decode(interfaces, data)
+        data = Util.remove_hex_prefix(data)
+        selector = Util.prefix_hex(data[0, 8])
+        payload = Util.prefix_hex(data[8..] || "")
+
+        selector_to_interfaces = Hash[interfaces.map { |i| [selector(i), i] }]
+        if (interface = selector_to_interfaces[selector])
+          inputs = interface.fetch("inputs", [])
+          types = inputs.map { |i| type(i) }
+          args = Abi.decode(types, payload)
+          kwargs = {}
+          inputs.each_with_index do |input, i|
+            name = input.fetch("name", "")
+            kwargs[name.to_sym] = args[i] unless name.empty?
+          end
+          CallDescription.new(interface, selector, args, kwargs)
+        end
+      end
+    end
+  end
+end

data/lib/eth/abi/type.rb

@@ -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
+
+        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
-        dims = dimension.scan(/\[[0-9]*\]/)
+        # 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,7 +107,7 @@ 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 }
+        @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,7 +137,7 @@ module Eth
         if dimensions.empty?
           if !(["string", "bytes", "tuple"].include?(base_type) and sub_type.empty?)
             s = 32
-          elsif base_type == "tuple" and components.none?(&:dynamic?)
+          elsif base_type == "tuple" and components&.none?(&:dynamic?)
             s = components.sum(&:size)
           end
         elsif dimensions.last != 0 and !nested_sub.dynamic?
@@ -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

@@ -44,6 +44,7 @@ module Eth
       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) }
@@ -151,4 +152,5 @@ 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/chain.rb

@@ -161,6 +161,9 @@ module Eth
     # 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.rb

@@ -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/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