eth 0.5.15 → 0.5.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 58842e5f3990be268758249080b56b70c1f26f8299ef27e7549db6cc2f675e51
-  data.tar.gz: 388a599dde8f50f34d46287e028e4dfe0c855815baa10de4a8c258b549429286
+  metadata.gz: ad70051a0aa71d2f7ed5a4acea236b677c9d1f4eb3467f8194de19a8de9f8714
+  data.tar.gz: 5558228d301116bd2be49ac184c01f3c2d1cb0e725deb9ab3f070021927b63cf
 SHA512:
-  metadata.gz: 3d4e42a99aebc7a47673b0706ce8476e08beca249ecae812f10c76e4f8767088b6a185c232abf9cc977a6680b08ac7b38de9d211cfc741f3bb2aa5fce9a4730c
-  data.tar.gz: cb29ed0c90b56eeae5ce519a436fada62e47690c1ca447e230d0fa2f3915fe97cd3346506c6b67e9c93a88d333197f0735529dd3c66c764d1895e76b1aa82b57
+  metadata.gz: acf9b6267efa46befed740d7d00c5938ed8d384b3297c57953f71c2ae5ebac31bd279a44694dd3675f77648f66e381dccacb70f533896600b3fd1bdc15a04a3b
+  data.tar.gz: dbb137aa5449234ba86f64951740d0f985693f37d1da329a70b7efdfb44b17a8bb2511a74560ac07a8d116aba100894e584c55fc3cc367c5c91e48fed456593a

data/.github/workflows/codeql.yml

@@ -24,15 +24,15 @@ jobs:
           - ruby
     steps:
       - name: "Checkout repository"
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
       - 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@v5
     - uses: ruby/setup-ruby@v1
       with:
         ruby-version: '3.4'

data/.github/workflows/spec.yml

@@ -21,33 +21,51 @@ jobs:
         os: [ubuntu-latest, macos-latest]
         ruby: ['3.3', '3.4']
     steps:
-    - uses: actions/checkout@v4
-    - uses: ruby/setup-ruby@v1
-      with:
-        ruby-version: ${{ matrix.ruby }}
-        bundler-cache: false
+    - uses: actions/checkout@v5
     - 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/README.md

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

@@ -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.
@@ -55,20 +55,22 @@ module Eth
       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}
     # 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
 
@@ -524,3 +526,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 = 16.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.16
 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
@@ -213,7 +257,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !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: []