eth 0.5.15 → 0.5.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 58842e5f3990be268758249080b56b70c1f26f8299ef27e7549db6cc2f675e51
-  data.tar.gz: 388a599dde8f50f34d46287e028e4dfe0c855815baa10de4a8c258b549429286
+  metadata.gz: 98f8ce464d7df37a4eba624469d53362687773991ccabf623e9d91d78e450479
+  data.tar.gz: ce0601d35ca795205565e541c97115f396c5e7553a9aa6a76421167bf6bc4e69
 SHA512:
-  metadata.gz: 3d4e42a99aebc7a47673b0706ce8476e08beca249ecae812f10c76e4f8767088b6a185c232abf9cc977a6680b08ac7b38de9d211cfc741f3bb2aa5fce9a4730c
-  data.tar.gz: cb29ed0c90b56eeae5ce519a436fada62e47690c1ca447e230d0fa2f3915fe97cd3346506c6b67e9c93a88d333197f0735529dd3c66c764d1895e76b1aa82b57
+  metadata.gz: fb9c363ec65417ce041a3a847f3d573a2128724fabb1b80483453c3097c1f726b123d78fb546b15a691ab83e64e2409ef7ef8d40461348c3948014ad52159991
+  data.tar.gz: 869b4229c3861eb7be055d0b5559e039269e267ad79203d9f4dd2923d8a08e863af9afce2cb6e973e74130db2fd6a4a04c084a0bc7460b167ab50b3813fa1592

data/.github/workflows/codeql.yml

@@ -24,15 +24,15 @@ jobs:
           - ruby
     steps:
       - name: "Checkout repository"
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
       - name: "Initialize CodeQL"
-        uses: github/codeql-action/init@v3
+        uses: github/codeql-action/init@v4
         with:
           languages: "${{ matrix.language }}"
       - name: Autobuild
-        uses: github/codeql-action/autobuild@v3
+        uses: github/codeql-action/autobuild@v4
       - name: "Perform CodeQL Analysis"
-        uses: github/codeql-action/analyze@v3
+        uses: github/codeql-action/analyze@v4
       - uses: ruby/setup-ruby@v1
         with:
           ruby-version: '3.4'

data/.github/workflows/docs.yml

@@ -10,7 +10,7 @@ jobs:
   docs:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - uses: ruby/setup-ruby@v1
       with:
         ruby-version: '3.4'
@@ -20,7 +20,7 @@ jobs:
         gem install yard
         yard doc
     - name: Deploy GH Pages
-      uses: JamesIves/github-pages-deploy-action@v4.7.3
+      uses: JamesIves/github-pages-deploy-action@v4.7.6
       with:
           branch: gh-pages
           folder: doc/

data/.github/workflows/spec.yml

@@ -19,35 +19,53 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest, macos-latest]
-        ruby: ['3.3', '3.4']
+        ruby: ['3.4', '4.0']
     steps:
-    - uses: actions/checkout@v4
-    - uses: ruby/setup-ruby@v1
-      with:
-        ruby-version: ${{ matrix.ruby }}
-        bundler-cache: false
+    - uses: actions/checkout@v6
     - name: MacOs Dependencies
+      if: matrix.os == 'macos-latest'
       run: |
+        brew update
         brew tap ethereum/ethereum
-        brew install --verbose pkg-config automake autogen geth solidity
-      if: startsWith(matrix.os, 'macOS')
+        brew install --verbose autoconf automake libtool pkg-config autogen geth solidity
     - name: Ubuntu Dependencies
+      if: matrix.os == 'ubuntu-latest'
       run: |
         sudo add-apt-repository -y ppa:ethereum/ethereum
         sudo apt-get update
-        sudo apt-get install geth solc
-      if: startsWith(matrix.os, 'Ubuntu')
+        sudo apt-get install -y autoconf automake libtool pkg-config geth solc
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+        bundler-cache: true
     - name: Run Geth
       run: |
-        geth --dev --http --ipcpath /tmp/geth.ipc &
-        disown &
+        geth --dev \
+             --http \
+             --ws \
+             --ipcpath /tmp/geth.ipc \
+             >/tmp/geth.log 2>&1 &
+        echo $! > /tmp/geth.pid
+        sleep 10
     - name: Gem Dependencies
       run: |
-        git submodule update --init
-        bundle install
+        git submodule update --init --recursive
     - name: Run Tests
       run: |
         bundle exec rspec
+    - name: Stop Geth
+      if: always()
+      run: |
+        if [ -f /tmp/geth.pid ]; then
+          kill "$(cat /tmp/geth.pid)" 2>/dev/null || true
+        fi
+    - name: Geth Logs (on failure)
+      if: failure()
+      run: |
+        if [ -f /tmp/geth.log ]; then
+          echo "===== geth log ====="
+          tail -n 200 /tmp/geth.log
+        fi
     - name: Upload coverage to Codecov
       uses: codecov/codecov-action@v5
       with:

data/CHANGELOG.md

@@ -3,12 +3,32 @@ 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)
+* Implement EIP712 array encoding [#361](https://github.com/q9f/eth.rb/pull/361)
+* Support nested dynamic arrays in ABI [#356](https://github.com/q9f/eth.rb/pull/356)
+* Allow signing transactions with external signatures [#349](https://github.com/q9f/eth.rb/pull/349)
+* Feat: add eip-4844 transactions [#345](https://github.com/q9f/eth.rb/pull/345)
+* Support Solidity custom errors per ERC-6093 [#344](https://github.com/q9f/eth.rb/pull/344)
+* Allow to use chains with id > 4294967295 [#337](https://github.com/q9f/eth.rb/pull/337)
 
-### Fixed
-* Eth/abi: handle tuple type without components [#335](https://github.com/q9f/eth.rb/issues/335)
+### Changed
+* Harden ABI type parsing [#358](https://github.com/q9f/eth.rb/pull/358)
+* Ensure ABI decoder rejects ZST offsets [#359](https://github.com/q9f/eth.rb/pull/359)
+* Test: decode eip4844 blobs [#360](https://github.com/q9f/eth.rb/pull/360)
+* Abi: decode transaction input [#354](https://github.com/q9f/eth.rb/pull/354)
+* Fix tuple output decoding for contract calls [#353](https://github.com/q9f/eth.rb/pull/353)
+* Add comprehensive Tx module tests [#352](https://github.com/q9f/eth.rb/pull/352)
+* Move error decoding to contract module [#350](https://github.com/q9f/eth.rb/pull/350)
+* Enforce minimal RLP integer decoding [#351](https://github.com/q9f/eth.rb/pull/351)
+* Fix tuple size calculation without components [#348](https://github.com/q9f/eth.rb/pull/348)
+* Docs: update readme [#347](https://github.com/q9f/eth.rb/pull/347)
+* Chore: update development dependencies [#346](https://github.com/q9f/eth.rb/pull/346)
+* Handle hex string inputs in big-endian conversion [#343](https://github.com/q9f/eth.rb/pull/343)
+* Handle uppercase hex prefixes [#339](https://github.com/q9f/eth.rb/pull/339)
+* Add methods to encode function call and decode its result [#334](https://github.com/q9f/eth.rb/pull/334)
+* Docs(util): fix hex? return type [#342](https://github.com/q9f/eth.rb/pull/342)
+* Handle hex input consistently in int_to_big_endian [#341](https://github.com/q9f/eth.rb/pull/341)
+* Fix receiver option spelling [#340](https://github.com/q9f/eth.rb/pull/340)
+* Chore: bump version to 0.5.15 [#333](https://github.com/q9f/eth.rb/pull/333)
 
 ## [0.5.14]
 ### Added

data/Gemfile

@@ -3,7 +3,7 @@
 source "https://rubygems.org"
 
 group :test, :development do
-  gem "bundler", "~> 2.5"
+  gem "bundler", ">= 2.4"
   gem "pry", "~> 0.15"
   gem "rake", "~> 13.2"
   gem "rdoc", "~> 6.13"

data/README.md

@@ -14,7 +14,7 @@
 [![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)
-[![Open-Source License](https://img.shields.io/github/license/q9f/eth.rb)](LICENSE)
+[![Open-Source License](https://img.shields.io/github/license/q9f/eth.rb)](LICENSE.txt)
 [![Contributions Welcome](https://img.shields.io/badge/contributions-welcome-brightgreen.svg?style=flat)](https://github.com/q9f/eth.rb/issues)
 
 A straightforward library to build, sign, and broadcast Ethereum transactions. It allows the separation of key and node management. Sign transactions and handle keys anywhere you can run Ruby and broadcast transactions through any local or remote node. Sign messages and recover signatures for authentication.
@@ -32,12 +32,12 @@ 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-4844 Ethereum Type-3 Transactions (with shard blobs, up to 9 blobs per block)
 - [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] RPC-Client (IPC/HTTP/WS) 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
@@ -76,10 +76,10 @@ yard doc
 The goal is to have 100% API documentation available.
 
 ## Testing
-The test suite expects working local HTTP and IPC endpoints with a prefunded developer account, e.g.:
+The test suite expects working local HTTP, WS, and IPC endpoints with a prefunded developer account, e.g.:
 
 ```shell
-geth --dev --http --ipcpath /tmp/geth.ipc &
+geth --dev --http --ws --ipcpath /tmp/geth.ipc &
 ```
 
 To run tests, simply use `rspec`. Note, that the Ethereum test fixtures are also required.

data/eth.gemspec

@@ -32,7 +32,7 @@ Gem::Specification.new do |spec|
   spec.test_files = spec.files.grep %r{^(test|spec|features)/}
 
   spec.platform = Gem::Platform::RUBY
-  spec.required_ruby_version = ">= 3.0", "< 4.0"
+  spec.required_ruby_version = ">= 3.0", "< 5.0"
 
   # bigdecimal for big decimals ;)
   spec.add_dependency "bigdecimal", "~> 3.1"
@@ -52,6 +52,15 @@ Gem::Specification.new do |spec|
   # openssl for encrypted key derivation
   spec.add_dependency "openssl", "~> 3.3"
 
+  # base64 is required explicitly in Ruby >= 3.4
+  spec.add_dependency "base64", "~> 0.1"
+
   # scrypt for encrypted key derivation
   spec.add_dependency "scrypt", "~> 3.0"
+
+  # bls12-381 for BLS signatures and pairings
+  spec.add_dependency "bls12-381", "~> 0.3"
+
+  # httpx for HTTP/2 and persistent connections
+  spec.add_dependency "httpx", "~> 1.6"
 end

data/lib/eth/abi/decoder.rb

@@ -31,48 +31,51 @@ module Eth
       # @return [String] the decoded data for the type.
       # @raise [DecodingError] if decoding fails for type.
       def type(type, arg)
-        if %w(string bytes).include?(type.base_type) and type.sub_type.empty?
-          # Case: decoding a string/bytes
-          if type.dimensions.empty?
-            l = Util.deserialize_big_endian_to_int arg[0, 32]
-            data = arg[32..-1]
-            raise DecodingError, "Wrong data size for string/bytes object" unless data.size == Util.ceil32(l)
-
-            # decoded strings and bytes
-            data[0, l]
-            # 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
+        if %w(string bytes).include?(type.base_type) and type.sub_type.empty? and type.dimensions.empty?
+          l = Util.deserialize_big_endian_to_int arg[0, 32]
+          data = arg[32..-1]
+          raise DecodingError, "Wrong data size for string/bytes object" unless data.size == Util.ceil32(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
-        elsif type.base_type == "tuple"
+          # decoded strings and bytes
+          data[0, l]
+        elsif type.base_type == "tuple" && type.dimensions.empty?
           offset = 0
-          data = {}
+          result = []
           raise DecodingError, "Cannot decode tuples without known components" if type.components.nil?
-          type.components.each do |c|
-            if c.dynamic?
-              pointer = Util.deserialize_big_endian_to_int arg[offset, 32] # Pointer to the size of the array's element
-              data_len = Util.deserialize_big_endian_to_int arg[pointer, 32] # length of the element
 
-              data[c.name] = type(c, arg[pointer, Util.ceil32(data_len) + 32])
+          head_offset = 0
+          dynamic_offsets = []
+          type.components.each_with_index do |component, index|
+            if component.dynamic?
+              raise DecodingError, "Offset out of bounds" if head_offset + 32 > arg.size
+              pointer = Util.deserialize_big_endian_to_int arg[head_offset, 32]
+              dynamic_offsets << [index, pointer]
+              head_offset += 32
+            else
+              size = component.size
+              raise DecodingError, "Offset out of bounds" if head_offset + size > arg.size
+              head_offset += size
+            end
+          end
+
+          dynamic_ranges = tuple_dynamic_ranges(dynamic_offsets, arg.size, head_offset)
+
+          type.components.each_with_index do |component, index|
+            if component.dynamic?
+              pointer, next_offset = dynamic_ranges[index]
+              raise DecodingError, "Offset out of bounds" if pointer > arg.size || next_offset > arg.size
+              raise DecodingError, "Offset out of bounds" if next_offset < pointer
+              result << type(component, arg[pointer, next_offset - pointer])
               offset += 32
             else
-              size = c.size
-              data[c.name] = type(c, arg[offset, size])
+              size = component.size
+              raise DecodingError, "Offset out of bounds" if offset + size > arg.size
+              result << type(component, arg[offset, size])
               offset += size
             end
           end
-          data
-        elsif type.dynamic?
+          result
+        elsif type.dynamic? && !type.dimensions.empty? && type.dimensions.last == 0
           l = Util.deserialize_big_endian_to_int arg[0, 32]
           nested_sub = type.nested_sub
 
@@ -83,18 +86,36 @@ module Eth
               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..]) }
+            offsets.each_with_index.map do |off, index|
+              start = 32 + off
+              stop = index + 1 < offsets.length ? 32 + offsets[index + 1] : arg.size
+              raise DecodingError, "Offset out of bounds" if stop > arg.size || stop < start
+              type(nested_sub, arg[start, stop - start])
+            end
           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
+          l = type.dimensions.last
           nested_sub = type.nested_sub
 
-          # decoded static-size arrays
-          (0...l).map { |i| type(nested_sub, arg[nested_sub.size * i, nested_sub.size]) }
+          if nested_sub.dynamic?
+            raise DecodingError, "Wrong data size for static array" unless arg.size >= 32 * l
+            offsets = (0...l).map do |i|
+              off = Util.deserialize_big_endian_to_int arg[32 * i, 32]
+              raise DecodingError, "Offset out of bounds" if off < 32 * l || off > arg.size - 32
+              off
+            end
+            offsets.each_with_index.map do |off, i|
+              size = (i + 1 < offsets.length ? offsets[i + 1] : arg.size) - off
+              type(nested_sub, arg[off, size])
+            end
+          else
+            # decoded static-size arrays with static sub-types
+            (0...l).map { |i| type(nested_sub, arg[nested_sub.size * i, nested_sub.size]) }
+          end
         else
 
           # decoded primitive types
@@ -119,7 +140,9 @@ module Eth
             size = Util.deserialize_big_endian_to_int data[0, 32]
 
             # decoded dynamic-sized array
-            data[32..-1][0, size]
+            decoded = data[32..-1][0, size]
+            decoded.force_encoding(Encoding::UTF_8)
+            decoded
           else
 
             # decoded static-sized array
@@ -159,6 +182,27 @@ module Eth
           raise DecodingError, "Unknown primitive type: #{type.base_type}"
         end
       end
+
+      private
+
+      # Computes the byte ranges for dynamic tuple components.
+      #
+      # @param offsets [Array<Array(Integer, Integer)>] list of tuples containing the component index and pointer.
+      # @param total_size [Integer] total number of bytes available for the tuple.
+      # @param head_size [Integer] size in bytes of the tuple head.
+      # @return [Hash{Integer=>Array(Integer, Integer)}] mapping component index to a [start, stop) range.
+      # @raise [DecodingError] if the encoded offsets overlap or leave the tuple head.
+      def tuple_dynamic_ranges(offsets, total_size, head_size)
+        ranges = {}
+        sorted = offsets.sort_by { |(_, pointer)| pointer }
+        sorted.each_with_index do |(index, pointer), idx|
+          raise DecodingError, "Offset out of bounds" if pointer < head_size || pointer > total_size
+          next_pointer = idx + 1 < sorted.length ? sorted[idx + 1][1] : total_size
+          raise DecodingError, "Offset out of bounds" if next_pointer < pointer || next_pointer > total_size
+          ranges[index] = [pointer, next_pointer]
+        end
+        ranges
+      end
     end
   end
 end

data/lib/eth/abi/encoder.rb

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 # -*- encoding : ascii-8bit -*-
+require "bigdecimal"
 
 # Provides the {Eth} module.
 module Eth
@@ -33,44 +34,18 @@ module Eth
       def type(type, arg)
         if %w(string bytes).include? type.base_type and type.sub_type.empty? and type.dimensions.empty?
           raise EncodingError, "Argument must be a String" unless arg.instance_of? String
+          arg = handle_hex_string arg, type
 
           # encodes strings and bytes
           size = type Type.size_type, arg.size
           padding = Constant::BYTE_ZERO * (Util.ceil32(arg.size) - arg.size)
           "#{size}#{arg}#{padding}"
-        elsif type.base_type == "tuple" && type.dimensions.size == 1 && type.dimensions[0] != 0
-          result = ""
-          result += struct_offsets(type.nested_sub, arg)
-          result += arg.map { |x| type(type.nested_sub, x) }.join
-          result
-        elsif type.dynamic? && arg.is_a?(Array)
-
-          # encodes dynamic-sized arrays
-          head = type(Type.size_type, arg.size)
-          nested_sub = type.nested_sub
-
-          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
-            head + tails.join
-          else
-            arg.each { |a| head += type(nested_sub, a) }
-            head
-          end
+        elsif type.base_type == "tuple" && type.dimensions.empty?
+          tuple arg, type
+        elsif !type.dimensions.empty?
+          encode_array type, arg
         else
-          if type.dimensions.empty?
-
-            # encode a primitive type
-            primitive_type type, arg
-          else
-
-            # encode static-size arrays
-            arg.map { |x| type(type.nested_sub, x) }.join
-          end
+          primitive_type type, arg
         end
       end
 
@@ -111,6 +86,7 @@ module Eth
 
       # Properly encodes unsigned integers.
       def uint(arg, type)
+        arg = coerce_number arg
         raise ArgumentError, "Don't know how to handle this input." unless arg.is_a? Numeric
         raise ValueOutOfBounds, "Number out of range: #{arg}" if arg > Constant::UINT_MAX or arg < Constant::UINT_MIN
         real_size = type.sub_type.to_i
@@ -121,6 +97,7 @@ module Eth
 
       # Properly encodes signed integers.
       def int(arg, type)
+        arg = coerce_number arg
         raise ArgumentError, "Don't know how to handle this input." unless arg.is_a? Numeric
         raise ValueOutOfBounds, "Number out of range: #{arg}" if arg > Constant::INT_MAX or arg < Constant::INT_MIN
         real_size = type.sub_type.to_i
@@ -137,6 +114,7 @@ module Eth
 
       # Properly encodes unsigned fixed-point numbers.
       def ufixed(arg, type)
+        arg = coerce_number arg
         raise ArgumentError, "Don't know how to handle this input." unless arg.is_a? Numeric
         high, low = type.sub_type.split("x").map(&:to_i)
         raise ValueOutOfBounds, arg unless arg >= 0 and arg < 2 ** high
@@ -145,6 +123,7 @@ module Eth
 
       # Properly encodes signed fixed-point numbers.
       def fixed(arg, type)
+        arg = coerce_number arg
         raise ArgumentError, "Don't know how to handle this input." unless arg.is_a? Numeric
         high, low = type.sub_type.split("x").map(&:to_i)
         raise ValueOutOfBounds, arg unless arg >= -2 ** (high - 1) and arg < 2 ** (high - 1)
@@ -174,8 +153,11 @@ module Eth
 
       # Properly encodes tuples.
       def tuple(arg, type)
-        raise EncodingError, "Expecting Hash: #{arg}" unless arg.instance_of? Hash
+        unless arg.is_a?(Hash) || arg.is_a?(Array)
+          raise EncodingError, "Expecting Hash or Array: #{arg}"
+        end
         raise EncodingError, "Expecting #{type.components.size} elements: #{arg}" unless arg.size == type.components.size
+        arg = arg.transform_keys(&:to_s) if arg.is_a?(Hash) # because component_type.name is String
 
         static_size = 0
         type.components.each_with_index do |component, i|
@@ -198,28 +180,84 @@ module Eth
             dynamic_values << dynamic_value
             dynamic_offset += dynamic_value.size
           else
-            offsets_and_static_values << type(component_type, arg.is_a?(Array) ? arg[i] : arg[component_type.name])
+            offsets_and_static_values << type(component_type, arg.is_a?(Array) ? arg[i] : arg.fetch(component_type.name))
           end
         end
 
         offsets_and_static_values.join + dynamic_values.join
       end
 
-      # Properly encode struct offsets.
-      def struct_offsets(type, arg)
-        result = ""
-        offset = arg.size
-        tails_encoding = arg.map { |a| type(type, a) }
-        arg.size.times do |i|
-          if i == 0
-            offset *= 32
-          else
-            offset += tails_encoding[i - 1].size
+      def coerce_number(arg)
+        return arg if arg.is_a? Numeric
+        return arg.to_i(0) if arg.is_a?(String) && arg.match?(/^-?(0x)?[0-9a-fA-F]+$/)
+        return BigDecimal(arg) if arg.is_a?(String) && arg.match?(/^-?\d+(\.\d+)?$/)
+        arg
+      end
+
+      # Encodes array values of any dimensionality.
+      #
+      # @param type [Eth::Abi::Type] the type describing the array.
+      # @param values [Array] the Ruby values to encode.
+      # @return [String] ABI encoded array payload.
+      # @raise [EncodingError] if the value cardinality does not match static dimensions.
+      def encode_array(type, values)
+        raise EncodingError, "Expecting Array value" unless values.is_a?(Array)
+
+        required_length = type.dimensions.last
+        if required_length != 0 && values.size != required_length
+          raise EncodingError, "Expecting #{required_length} elements: #{values.size} provided"
+        end
+
+        nested_sub = type.nested_sub
+
+        if required_length.zero?
+          encode_dynamic_array(nested_sub, values)
+        else
+          encode_static_array(nested_sub, values)
+        end
+      end
+
+      # Encodes dynamic-sized arrays, including nested tuples.
+      #
+      # @param nested_sub [Eth::Abi::Type] the element type.
+      # @param values [Array] elements to encode.
+      # @return [String] ABI encoded dynamic array payload.
+      def encode_dynamic_array(nested_sub, values)
+        head = type(Type.size_type, values.size)
+        element_heads, element_tails = encode_array_elements(nested_sub, values)
+        head + element_heads + element_tails
+      end
+
+      # Encodes static-sized arrays, including nested tuples.
+      #
+      # @param nested_sub [Eth::Abi::Type] the element type.
+      # @param values [Array] elements to encode.
+      # @return [String] ABI encoded static array payload.
+      def encode_static_array(nested_sub, values)
+        element_heads, element_tails = encode_array_elements(nested_sub, values)
+        element_heads + element_tails
+      end
+
+      # Encodes the head/tail portions for array elements.
+      #
+      # @param nested_sub [Eth::Abi::Type] the element type.
+      # @param values [Array] elements to encode.
+      # @return [Array<String, String>] head/tail encoded segments.
+      def encode_array_elements(nested_sub, values)
+        if nested_sub.dynamic?
+          head = ""
+          tail = ""
+          offset = values.size * 32
+          values.each do |value|
+            encoded = type(nested_sub, value)
+            head += type(Type.size_type, offset)
+            tail += encoded
+            offset += encoded.size
           end
-          offset_string = type(Type.size_type, offset)
-          result += offset_string
+          [head, tail]
+        else
+          [values.map { |value| type(nested_sub, value) }.join, ""]
         end
-        result
       end
 
       # Properly encodes hash-strings.

data/lib/eth/abi/type.rb

@@ -81,19 +81,22 @@ module Eth
         end
 
         # ensure the type string is reasonable before attempting to parse
-        raise ParseError, "Invalid type format" unless type.is_a?(String) && type.bytesize <= 256
+        raise ParseError, "Invalid type format" unless type.is_a? String
 
-        if type.start_with?("tuple(")
-          inner, rest = extract_tuple(type)
+        if type.start_with?("tuple(") || type.start_with?("(")
+          tuple_str = type.start_with?("tuple(") ? type : "tuple#{type}"
+          inner, rest = extract_tuple(tuple_str)
           inner_types = split_tuple_types(inner)
           inner_types.each { |t| Type.parse(t) }
           base_type = "tuple"
           sub_type = ""
           dimension = rest
+          components ||= inner_types.map { |t| { "type" => t } }
         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
+          sub_type = "256" if %w[uint int].include?(base_type) && sub_type.empty?
         end
 
         # type dimension can only be numeric or empty for dynamic arrays

data/lib/eth/bls.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "bls"
+
+module Eth
+  # Helper methods for interacting with BLS12-381 points and signatures
+  module Bls
+    module_function
+
+    # Decode a compressed G1 public key from hex.
+    # @param [String] hex a compressed G1 point
+    # @return [BLS::PointG1]
+    def decode_public_key(hex)
+      BLS::PointG1.from_hex Util.remove_hex_prefix(hex)
+    end
+
+    # Encode a G1 public key to compressed hex.
+    # @param [BLS::PointG1] point
+    # @return [String] hex string prefixed with 0x
+    def encode_public_key(point)
+      Util.prefix_hex point.to_hex(compressed: true)
+    end
+
+    # Decode a compressed G2 signature from hex.
+    # @param [String] hex a compressed G2 point
+    # @return [BLS::PointG2]
+    def decode_signature(hex)
+      BLS::PointG2.from_hex Util.remove_hex_prefix(hex)
+    end
+
+    # Encode a G2 signature to compressed hex.
+    # @param [BLS::PointG2] point
+    # @return [String] hex string prefixed with 0x
+    def encode_signature(point)
+      Util.prefix_hex point.to_hex(compressed: true)
+    end
+
+    # Derive a compressed public key from a private key.
+    # @param [String] priv_hex private key as hex
+    # @return [String] compressed G1 public key (hex)
+    def get_public_key(priv_hex)
+      key = BLS.get_public_key Util.remove_hex_prefix(priv_hex)
+      encode_public_key key
+    end
+
+    # Sign a message digest with the given private key.
+    # @param [String] message message digest (hex)
+    # @param [String] priv_hex private key as hex
+    # @return [String] compressed G2 signature (hex)
+    def sign(message, priv_hex)
+      sig = BLS.sign Util.remove_hex_prefix(message),
+                     Util.remove_hex_prefix(priv_hex)
+      encode_signature sig
+    end
+
+    # Verify a BLS signature using pairings. This mirrors the behaviour of
+    # the BLS12-381 pairing precompile.
+    # @param [String] message message digest (hex)
+    # @param [String] signature_hex compressed G2 signature (hex)
+    # @param [String] pubkey_hex compressed G1 public key (hex)
+    # @return [Boolean] verification result
+    def verify(message, signature_hex, pubkey_hex)
+      signature = decode_signature(signature_hex)
+      pubkey = decode_public_key(pubkey_hex)
+      BLS.verify(signature, Util.remove_hex_prefix(message), pubkey)
+    end
+  end
+end

data/lib/eth/client/http.rb

@@ -12,7 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require "net/http"
+require "uri"
+require "httpx"
 
 # Provides the {Eth} module.
 module Eth
@@ -57,6 +58,7 @@ module Eth
       else
         @uri = uri
       end
+      @client = HTTPX.plugin(:persistent).with(headers: { "Content-Type" => "application/json" })
     end
 
     # Sends an RPC request to the connected HTTP client.
@@ -64,13 +66,8 @@ module Eth
     # @param payload [Hash] the RPC request parameters.
     # @return [String] a JSON-encoded response.
     def send_request(payload)
-      http = Net::HTTP.new(@host, @port)
-      http.use_ssl = @ssl
-      header = { "Content-Type" => "application/json" }
-      request = Net::HTTP::Post.new(@uri, header)
-      request.body = payload
-      response = http.request(request)
-      response.body
+      response = @client.post(@uri, body: payload)
+      response.body.to_s
     end
   end
 

data/lib/eth/client/ws.rb

@@ -0,0 +1,323 @@
+# 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.
+
+require "socket"
+require "openssl"
+require "uri"
+require "base64"
+require "securerandom"
+require "digest/sha1"
+require "thread"
+require "ipaddr"
+
+# Provides the {Eth} module.
+module Eth
+
+  # Provides a WS/S-RPC client with automatic reconnection support.
+  class Client::Ws < Client
+
+    # The host of the WebSocket endpoint.
+    attr_reader :host
+
+    # The port of the WebSocket endpoint.
+    attr_reader :port
+
+    # The full URI of the WebSocket endpoint, including path.
+    attr_reader :uri
+
+    # Attribute indicator for SSL.
+    attr_reader :ssl
+
+    # Constructor for the WebSocket client. Should not be used; use
+    # {Client.create} instead.
+    #
+    # @param host [String] a URI pointing to a WebSocket RPC-API.
+    def initialize(host)
+      super
+      @uri = URI.parse(host)
+      raise ArgumentError, "Unable to parse the WebSocket-URI!" unless %w[ws wss].include?(@uri.scheme)
+      @host = @uri.host
+      @port = @uri.port
+      @ssl = @uri.scheme == "wss"
+      @path = build_path(@uri)
+      @mutex = Mutex.new
+      @socket = nil
+      @fragments = nil
+    end
+
+    # Sends an RPC request to the connected WebSocket endpoint.
+    #
+    # @param payload [Hash] the RPC request parameters.
+    # @return [String] a JSON-encoded response.
+    def send_request(payload)
+      attempts = 0
+      begin
+        attempts += 1
+        @mutex.synchronize do
+          ensure_socket
+          write_frame(@socket, payload)
+          return read_message(@socket)
+        end
+      rescue IOError, SystemCallError => e
+        @mutex.synchronize { close_socket }
+        retry if attempts < 2
+        raise e
+      end
+    end
+
+    # Closes the underlying WebSocket connection.
+    #
+    # @return [void]
+    def close
+      @mutex.synchronize { close_socket }
+    end
+
+    private
+
+    def ensure_socket
+      return if @socket && !@socket.closed?
+
+      socket = open_socket
+      begin
+        perform_handshake(socket)
+        @socket = socket
+        @fragments = nil
+      rescue StandardError
+        begin
+          socket.close unless socket.closed?
+        rescue IOError, SystemCallError
+          nil
+        end
+        @socket = nil
+        raise
+      end
+    end
+
+    # Establishes the TCP socket for the RPC connection and upgrades it to TLS
+    # when a secure endpoint is requested. TLS sessions enforce peer
+    # verification, load the default system trust store, and enable hostname
+    # verification when the current OpenSSL bindings support it.
+    #
+    # @return [TCPSocket, OpenSSL::SSL::SSLSocket] the established socket.
+    # @raise [IOError, SystemCallError, OpenSSL::SSL::SSLError] if the socket
+    #   cannot be opened or the TLS handshake fails.
+    def open_socket
+      tcp = TCPSocket.new(@host, @port)
+      return tcp unless @ssl
+
+      context = OpenSSL::SSL::SSLContext.new
+      params = { verify_mode: OpenSSL::SSL::VERIFY_PEER }
+      params[:verify_hostname] = true if context.respond_to?(:verify_hostname=)
+      context.set_params(params)
+      context.cert_store = OpenSSL::X509::Store.new.tap(&:set_default_paths)
+
+      ssl_socket = OpenSSL::SSL::SSLSocket.new(tcp, context)
+      ssl_socket.hostname = @host
+      ssl_socket.sync_close = true
+      ssl_socket.connect
+      ssl_socket
+    end
+
+    def perform_handshake(socket)
+      key = Base64.strict_encode64(SecureRandom.random_bytes(16))
+      request = build_handshake_request(key)
+      socket.write(request)
+      response = read_handshake_response(socket)
+      verify_handshake!(response, key)
+    end
+
+    def build_handshake_request(key)
+      origin = build_origin_header
+      host_header = build_host_header
+      "GET #{@path} HTTP/1.1\r\n" \
+      "Host: #{host_header}\r\n" \
+      "Upgrade: websocket\r\n" \
+      "Connection: Upgrade\r\n" \
+      "Sec-WebSocket-Version: 13\r\n" \
+      "Sec-WebSocket-Key: #{key}\r\n" \
+      "Origin: #{origin}\r\n\r\n"
+    end
+
+    def read_handshake_response(socket)
+      response = +""
+      until response.end_with?("\r\n\r\n")
+        chunk = socket.readpartial(1024)
+        raise IOError, "Incomplete WebSocket handshake" if chunk.nil?
+        response << chunk
+      end
+      response
+    rescue EOFError
+      raise IOError, "Incomplete WebSocket handshake"
+    end
+
+    def verify_handshake!(response, key)
+      status_line = response.lines.first&.strip
+      unless status_line&.start_with?("HTTP/1.1 101")
+        raise IOError, "WebSocket handshake failed (status: #{status_line || "unknown"})"
+      end
+
+      accept = response[/Sec-WebSocket-Accept:\s*(.+)\r/i, 1]&.strip
+      expected = Base64.strict_encode64(Digest::SHA1.digest("#{key}258EAFA5-E914-47DA-95CA-C5AB0DC85B11"))
+      raise IOError, "WebSocket handshake failed (missing accept header)" unless accept
+      raise IOError, "WebSocket handshake failed (invalid accept header)" unless accept == expected
+    end
+
+    def write_frame(socket, payload, opcode = 0x1)
+      frame_payload = payload.is_a?(String) ? payload.dup : payload.to_s
+      mask_key = SecureRandom.random_bytes(4)
+      header = [0x80 | opcode]
+
+      length = frame_payload.bytesize
+      if length <= 125
+        header << (0x80 | length)
+      elsif length <= 0xFFFF
+        header << (0x80 | 126)
+        header.concat([length].pack("n").bytes)
+      else
+        header << (0x80 | 127)
+        header.concat([length].pack("Q>").bytes)
+      end
+
+      masked_payload = apply_mask(frame_payload, mask_key)
+      socket.write(header.pack("C*") + mask_key + masked_payload)
+    end
+
+    def read_message(socket)
+      loop do
+        frame = read_frame(socket)
+        return frame if frame
+      end
+    end
+
+    def read_frame(socket)
+      header = read_bytes(socket, 2)
+      byte1, byte2 = header.bytes
+      opcode = byte1 & 0x0F
+      masked = (byte2 & 0x80) == 0x80
+      length = byte2 & 0x7F
+
+      length = read_bytes(socket, 2).unpack1("n") if length == 126
+      length = read_bytes(socket, 8).unpack1("Q>") if length == 127
+
+      mask_key = masked ? read_bytes(socket, 4).bytes : nil
+      payload = read_bytes(socket, length)
+      payload_bytes = payload.bytes
+      if mask_key
+        payload_bytes.map!.with_index { |byte, index| byte ^ mask_key[index % 4] }
+      end
+      data = payload_bytes.pack("C*")
+
+      case opcode
+      when 0x0
+        (@fragments ||= +"") << data
+        if (byte1 & 0x80) == 0x80
+          message = @fragments.dup
+          @fragments = nil
+          message
+        else
+          nil
+        end
+      when 0x1, 0x2
+        if (byte1 & 0x80) == 0x80
+          data
+        else
+          @fragments = data
+          nil
+        end
+      when 0x8
+        close_socket
+        raise IOError, "WebSocket closed"
+      when 0x9
+        write_frame(socket, data, 0xA)
+        nil
+      when 0xA
+        nil
+      else
+        nil
+      end
+    end
+
+    def read_bytes(socket, length)
+      data = +""
+      while data.bytesize < length
+        chunk = socket.read(length - data.bytesize)
+        raise IOError, "Unexpected end of WebSocket stream" if chunk.nil? || chunk.empty?
+        data << chunk
+      end
+      data
+    end
+
+    def apply_mask(payload, mask_key)
+      mask_bytes = mask_key.bytes
+      payload.bytes.map.with_index { |byte, index| byte ^ mask_bytes[index % 4] }.pack("C*")
+    end
+
+    def build_origin_header
+      scheme = @ssl ? "https" : "http"
+      host = format_origin_host(@uri.host)
+      default_port = @ssl ? 443 : 80
+      port = @uri.port
+      port_suffix = port == default_port ? "" : ":#{port}"
+      "#{scheme}://#{host}#{port_suffix}"
+    end
+
+    def build_host_header
+      "#{format_host(@uri.host)}:#{@uri.port}"
+    end
+
+    def format_origin_host(host)
+      return "localhost" if loopback_host?(host)
+      format_host(host)
+    end
+
+    def format_host(host)
+      return host unless host&.include?(":")
+      host.start_with?("[") ? host : "[#{host}]"
+    end
+
+    def loopback_host?(host)
+      return false if host.nil?
+      return true if host == "localhost"
+      IPAddr.new(host).loopback?
+    rescue IPAddr::InvalidAddressError
+      false
+    end
+
+    def close_socket
+      return unless @socket
+
+      begin
+        write_frame(@socket, [1000].pack("n"), 0x8)
+      rescue IOError, SystemCallError
+        # ignore errors while closing
+      ensure
+        begin
+          @socket.close unless @socket.closed?
+        rescue IOError, SystemCallError
+          nil
+        end
+        @socket = nil
+        @fragments = nil
+      end
+    end
+
+    def build_path(uri)
+      path = uri.path
+      path = "/" if path.nil? || path.empty?
+      query = uri.query
+      path += "?#{query}" if query
+      path
+    end
+  end
+end

data/lib/eth/client.rb

@@ -16,7 +16,7 @@
 module Eth
 
   # Provides the {Eth::Client} super-class to connect to Ethereum
-  # network's RPC-API endpoints (IPC or HTTP).
+  # network's RPC-API endpoints (IPC, HTTP/S, or WS/S).
   class Client
 
     # The client's RPC-request ID starting at 0.
@@ -40,35 +40,40 @@ 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
+    # Raised when an RPC call returns an error. Carries the error code and the optional
     # hex-encoded error data to support custom error decoding.
     class RpcError < IOError
       attr_reader :data
+      attr_reader :code
 
       # 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)
+      # @param code [String] optional error code returned by the RPC.
+      def initialize(message, data = nil, code = nil)
         super(message)
         @data = data
+        @code = code
       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.
+    # Creates a new RPC-Client, either by providing an HTTP/S host, WS/S host,
+    # or an IPC path. Supports basic authentication with username and password.
     #
-    # **Note**, this sets the folling gas defaults: {Tx::DEFAULT_PRIORITY_FEE}
+    # **Note**, this sets the following gas defaults: {Tx::DEFAULT_PRIORITY_FEE}
     # and {Tx::DEFAULT_GAS_PRICE. Use {#max_priority_fee_per_gas} and
     # {#max_fee_per_gas} to set custom values prior to submitting transactions.
     #
-    # @param host [String] either an HTTP/S host or an IPC path.
+    # @param host [String] either an HTTP/S host, WS/S host, or an IPC path.
     # @return [Eth::Client::Ipc] an IPC client.
     # @return [Eth::Client::Http] an HTTP client.
+    # @return [Eth::Client::Ws] a WebSocket client.
     # @raise [ArgumentError] in case it cannot determine the client type.
     def self.create(host)
       return Client::Ipc.new host if host.end_with? ".ipc"
       return Client::Http.new host if host.start_with? "http"
+      return Client::Ws.new host if host.start_with? "ws"
       raise ArgumentError, "Unable to detect client type!"
     end
 
@@ -481,7 +486,7 @@ module Eth
       }
       output = JSON.parse(send_request(payload.to_json))
       if (err = output["error"])
-        raise RpcError.new(err["message"], err["data"])
+        raise RpcError.new(err["message"], err["data"], err["code"])
       end
       output
     end
@@ -524,3 +529,4 @@ end
 # Load the client/* libraries
 require "eth/client/http"
 require "eth/client/ipc"
+require "eth/client/ws"

data/lib/eth/tx/eip4844.rb

@@ -23,6 +23,18 @@ module Eth
     # Ref: https://eips.ethereum.org/EIPS/eip-4844
     class Eip4844
 
+      # The blob gas consumed by a single blob.
+      GAS_PER_BLOB = (2 ** 17).freeze
+
+      # The target blob gas per block as per EIP-7691.
+      TARGET_BLOB_GAS_PER_BLOCK = 786_432.freeze
+
+      # The maximum blob gas allowed in a block as per EIP-7691.
+      MAX_BLOB_GAS_PER_BLOCK = 1_179_648.freeze
+
+      # The maximum number of blobs permitted in a single block.
+      MAX_BLOBS_PER_BLOCK = (MAX_BLOB_GAS_PER_BLOCK / GAS_PER_BLOB).freeze
+
       # The EIP-155 Chain ID.
       # Ref: https://eips.ethereum.org/EIPS/eip-155
       attr_reader :chain_id
@@ -89,7 +101,7 @@ module Eth
       # @option params [String] :data the transaction data payload.
       # @option params [Array] :access_list an optional access list.
       # @option params [Integer] :max_fee_per_blob_gas the max blob fee per gas.
-      # @option params [Array] :blob_versioned_hashes the blob versioned hashes.
+      # @option params [Array] :blob_versioned_hashes the blob versioned hashes (max 9).
       # @raise [ParameterError] if gas limit is too low.
       def initialize(params)
         fields = { recovery_id: nil, r: 0, s: 0 }.merge params

data/lib/eth/tx.rb

@@ -286,7 +286,7 @@ module Eth
     #
     # @param fields [Hash] the transaction fields.
     # @return [Hash] the validated transaction fields.
-    # @raise [ParameterError] if max blob fee or blob hashes are invalid.
+    # @raise [ParameterError] if max blob fee or blob hashes are invalid or exceed limits.
     def validate_eip4844_params(fields)
       if fields[:max_fee_per_blob_gas].nil? or fields[:max_fee_per_blob_gas] < 0
         raise ParameterError, "Invalid max blob fee #{fields[:max_fee_per_blob_gas]}!"
@@ -294,6 +294,9 @@ module Eth
       if fields[:blob_versioned_hashes].nil? or !fields[:blob_versioned_hashes].is_a? Array or fields[:blob_versioned_hashes].empty?
         raise ParameterError, "Invalid blob versioned hashes #{fields[:blob_versioned_hashes]}!"
       end
+      if fields[:blob_versioned_hashes].length > Eip4844::MAX_BLOBS_PER_BLOCK
+        raise ParameterError, "Too many blob versioned hashes #{fields[:blob_versioned_hashes].length}!"
+      end
       if fields[:to].nil? or fields[:to].empty?
         raise ParameterError, "Invalid destination address #{fields[:to]}!"
       end

data/lib/eth/version.rb

@@ -22,7 +22,7 @@ module Eth
   MINOR = 5.freeze
 
   # Defines the patch version of the {Eth} module.
-  PATCH = 15.freeze
+  PATCH = 17.freeze
 
   # Defines the version string of the {Eth} module.
   VERSION = [MAJOR, MINOR, PATCH].join(".").freeze

data/lib/eth.rb

@@ -32,5 +32,6 @@ require "eth/solidity"
 require "eth/tx"
 require "eth/unit"
 require "eth/util"
+require "eth/bls"
 require "eth/ens"
 require "eth/version"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eth
 version: !ruby/object:Gem::Version
-  version: 0.5.15
+  version: 0.5.17
 platform: ruby
 authors:
 - Steve Ellis
@@ -94,6 +94,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
 - !ruby/object:Gem::Dependency
   name: scrypt
   requirement: !ruby/object:Gem::Requirement
@@ -108,6 +122,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: bls12-381
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: httpx
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
 description: Library to handle Ethereum accounts, messages, and transactions.
 email:
 - email@steveell.is
@@ -149,10 +191,12 @@ files:
 - lib/eth/abi/type.rb
 - lib/eth/address.rb
 - lib/eth/api.rb
+- lib/eth/bls.rb
 - lib/eth/chain.rb
 - lib/eth/client.rb
 - lib/eth/client/http.rb
 - lib/eth/client/ipc.rb
+- lib/eth/client/ws.rb
 - lib/eth/constant.rb
 - lib/eth/contract.rb
 - lib/eth/contract/error.rb
@@ -206,14 +250,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '3.0'
   - - "<"
     - !ruby/object:Gem::Version
-      version: '4.0'
+      version: '5.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Ruby Ethereum library.
 test_files: []