eth 0.5.13 → 0.5.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc5ddb568fad899fb1b19cce7995c8152b799475fbca603932d840d561fa4b4c
-  data.tar.gz: fc69a4e2c2866a719336cc94a0adb9244383a6c80116ab7da8a1165262743ac9
+  metadata.gz: c5f56a3acb3981d3087e8125660e5670b8ba8bf6a5255e2742e439498327cd82
+  data.tar.gz: c54057d9b851ad567e846e390949927afe1986387eaba95fc8facb0aa3fef20d
 SHA512:
-  metadata.gz: 35062c2f2b04723b2889195a5a16c662e2f2913fed4ecc3d5903a6167ed125d23a3b066125756023b2b71451f5899a58f5a36e61049f0e744b6a24583a6eff9e
-  data.tar.gz: 51732510c1e64a48d3095fb6a6502038e493ace3390da31cde1006f67f4b7a4e130f78de2ab667ae235ce4285c2bb986a3720be8b6648e91d845de5bdb6f1a8f
+  metadata.gz: ee0dacd29dde60d8368c382a8d0fdf444895a66f2795689961112f34e752fced4a350e26b255d5bc4b1872e7c423c5780cc35487bd2b349f984ac0f75facbfd8
+  data.tar.gz: ca7fbe6c973aceb5dcc56031dbfa03903392ba9ad2ff0aa90d29c4c6311cc899961954e606c9c400df523305815eb89b26bc1fed2c0d65fcb042b59f0b63064f

data/.github/workflows/codeql.yml

@@ -35,7 +35,7 @@ jobs:
         uses: github/codeql-action/analyze@v3
       - uses: ruby/setup-ruby@v1
         with:
-          ruby-version: '3.3'
+          ruby-version: '3.4'
           bundler-cache: true
       - name: "Run rufo code formatting checks"
         run: |

data/.github/workflows/docs.yml

@@ -13,14 +13,14 @@ jobs:
     - uses: actions/checkout@v4
     - uses: ruby/setup-ruby@v1
       with:
-        ruby-version: '3.3'
+        ruby-version: '3.4'
         bundler-cache: true
     - name: Run Yard Doc
       run: |
         gem install yard
         yard doc
     - name: Deploy GH Pages
-      uses: JamesIves/github-pages-deploy-action@v4.7.1
+      uses: JamesIves/github-pages-deploy-action@v4.7.3
       with:
           branch: gh-pages
           folder: doc/

data/.github/workflows/spec.yml

@@ -19,7 +19,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest, macos-latest]
-        ruby: ['3.2', '3.3']
+        ruby: ['3.3', '3.4']
     steps:
     - uses: actions/checkout@v4
     - uses: ruby/setup-ruby@v1
@@ -48,8 +48,6 @@ jobs:
     - name: Run Tests
       run: |
         bundle exec rspec
-      env:
-        INFURA_TOKEN: ${{ secrets.INFURA_TOKEN }}
     - name: Upload coverage to Codecov
       uses: codecov/codecov-action@v5
       with:

data/LICENSE.txt

@@ -187,7 +187,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   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/README.md

@@ -80,8 +80,6 @@ The test suite expects working local HTTP and IPC endpoints with a prefunded dev
 geth --dev --http --ipcpath /tmp/geth.ipc &
 ```
 
-It also expects an `$INFURA_TOKEN` in environment to test some ENS queries on mainnet.
-
 To run tests, simply use `rspec`. Note, that the Ethereum test fixtures are also required.
 
 ```shell
@@ -95,7 +93,7 @@ The goal is to have 100% specification coverage for all code inside this gem.
 ## Contributing
 Pull requests are welcome! To contribute, please consider the following:
 * Code should be fully documented. Run `yard doc` and make sure it does not yield any warnings or undocumented sets.
-* Code should be fully covered by tests. Run `rspec` to make sure all tests pass. The CI has an integration that will assis you to identify uncovered lines of code and get coverage up to 100%.
+* Code should be fully covered by tests. Run `rspec` to make sure all tests pass. The CI has an integration that will assist you to identify uncovered lines of code and get coverage up to 100%.
 * Code should be formatted properly. Try to eliminate the most common issues such as trailing white-spaces or duplicate new-lines. Usage of the `rufo` gem is recommended.
 * Submit pull requests, questions, or issues to Github: <https://github.com/q9f/eth.rb>
 

data/eth.gemspec

@@ -34,6 +34,9 @@ Gem::Specification.new do |spec|
   spec.platform = Gem::Platform::RUBY
   spec.required_ruby_version = ">= 3.0", "< 4.0"
 
+  # bigdecimal for big decimals ;)
+  spec.add_dependency "bigdecimal", "~> 3.1"
+
   # forwardable for contracts meta programming
   spec.add_dependency "forwardable", "~> 1.3"
 

data/lib/eth/abi/decoder.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.
@@ -102,7 +102,7 @@ module Eth
         when "address"
 
           # decoded address with 0x-prefix
-          "0x#{Util.bin_to_hex data[12..-1]}"
+          Address.new(Util.bin_to_hex data[12..-1]).to_s.downcase
         when "string", "bytes"
           if type.sub_type.empty?
             size = Util.deserialize_big_endian_to_int data[0, 32]

data/lib/eth/abi/encoder.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,7 +49,6 @@ module Eth
           head, tail = "", ""
           head += type(Type.size_type, arg.size)
           nested_sub = type.nested_sub
-          nested_sub_size = type.nested_sub.size
 
           # calculate offsets
           if %w(string bytes).include?(type.base_type) && type.sub_type.empty?
@@ -93,15 +92,15 @@ module Eth
       # @return [String] the encoded primitive type.
       # @raise [EncodingError] if value does not match type.
       # @raise [ValueOutOfBounds] if value is out of bounds for type.
-      # @raise [EncodingError] if encoding fails for type.
+      # @raise [ArgumentError] if encoding fails for type.
       def primitive_type(type, arg)
         case type.base_type
         when "uint"
           uint arg, type
-        when "bool"
-          bool arg
         when "int"
           int arg, type
+        when "bool"
+          bool arg
         when "ureal", "ufixed"
           ufixed arg, type
         when "real", "fixed"

data/lib/eth/abi/event.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.
@@ -44,6 +44,10 @@ module Eth
         "#{name}(#{types.join(",")})"
       end
 
+      # Gets the input type for events.
+      #
+      # @param input [Hash] events input.
+      # @return [String] input type.
       def type(input)
         if input["type"] == "tuple"
           "(#{input["components"].map { |c| type(c) }.join(",")})"

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.
@@ -94,7 +94,7 @@ module Eth
         @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?
+        @components = components.map { |component| Abi::Type.parse(component["type"], component.dig("components"), component.dig("name")) } if components&.any?
         @name = component_name
       end
 
@@ -123,10 +123,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 +153,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 +175,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 +187,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

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,12 @@ 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
 
       # parse all types
       parsed_types = types.map { |t| Type === t ? t : Type.parse(t) }
@@ -64,6 +68,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,6 +147,7 @@ module Eth
   end
 end
 
+require "eth/abi/packed/encoder"
 require "eth/abi/decoder"
 require "eth/abi/encoder"
 require "eth/abi/event"

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,11 +149,16 @@ 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 the geth private network preset.

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.

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.