eth 0.5.14 → 0.5.16

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,55 +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, tail = "", ""
-          head += type(Type.size_type, arg.size)
-          nested_sub = type.nested_sub
-
-          # calculate offsets
-          if %w(string bytes).include?(type.base_type) && type.sub_type.empty?
-            offset = 0
-            arg.size.times do |i|
-              if i == 0
-                offset = arg.size * 32
-              else
-                number_of_words = ((arg[i - 1].size + 32 - 1) / 32).floor
-                total_bytes_length = number_of_words * 32
-                offset += total_bytes_length + 32
-              end
-
-              head += type(Type.size_type, offset)
-            end
-          elsif nested_sub.base_type == "tuple" && nested_sub.dynamic?
-            head += struct_offsets(nested_sub, arg)
-          end
-
-          arg.size.times do |i|
-            head += type nested_sub, arg[i]
-          end
-          "#{head}#{tail}"
+        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
 
@@ -122,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
@@ -132,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
@@ -148,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
@@ -156,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)
@@ -185,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|
@@ -209,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/function.rb

@@ -0,0 +1,124 @@
+# Copyright (c) 2016-2025 The Ruby-Eth Contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -*- encoding : ascii-8bit -*-
+
+# Provides the {Eth} module.
+module Eth
+
+  # Provides a Ruby implementation of the Ethereum Application Binary Interface (ABI).
+  module Abi
+
+    # Provides a module to decode transaction input data.
+    module Function
+      extend self
+
+      # Build function signature string from ABI interface.
+      #
+      # @param interface [Hash] ABI function interface.
+      # @return [String] interface signature string.
+      def signature(interface)
+        name = interface.fetch("name")
+        inputs = interface.fetch("inputs", [])
+        types = inputs.map { |i| type(i) }
+        "#{name}(#{types.join(",")})"
+      end
+
+      # Compute selector for ABI function interface.
+      #
+      # @param interface [Hash] ABI function interface.
+      # @return [String] a hex-string selector.
+      def selector(interface)
+        sig = signature(interface)
+        Util.prefix_hex(Util.bin_to_hex(Util.keccak256(sig))[0, 8])
+      end
+
+      # Gets the input type for functions.
+      #
+      # @param input [Hash] function input.
+      # @return [String] input type.
+      def type(input)
+        if input["type"] == "tuple"
+          "(#{input["components"].map { |c| type(c) }.join(",")})"
+        elsif input["type"] == "enum"
+          "uint8"
+        else
+          input["type"]
+        end
+      end
+
+      # A decoded function call.
+      class CallDescription
+        # The function ABI interface used to decode the call.
+        attr_accessor :function_interface
+
+        # The positional arguments of the call.
+        attr_accessor :args
+
+        # The named arguments of the call.
+        attr_accessor :kwargs
+
+        # The function selector.
+        attr_accessor :selector
+
+        # Creates a description object for a decoded function call.
+        #
+        # @param function_interface [Hash] function ABI type.
+        # @param selector [String] function selector hex-string.
+        # @param args [Array] decoded positional arguments.
+        # @param kwargs [Hash] decoded keyword arguments.
+        def initialize(function_interface, selector, args, kwargs)
+          @function_interface = function_interface
+          @selector = selector
+          @args = args
+          @kwargs = kwargs
+        end
+
+        # The function name. (e.g. transfer)
+        def name
+          @name ||= function_interface.fetch("name")
+        end
+
+        # The function signature. (e.g. transfer(address,uint256))
+        def signature
+          @signature ||= Function.signature(function_interface)
+        end
+      end
+
+      # Decodes a transaction input with a set of ABI interfaces.
+      #
+      # @param interfaces [Array] function ABI types.
+      # @param data [String] transaction input data.
+      # @return [CallDescription, nil] a CallDescription object or nil if selector unknown.
+      def decode(interfaces, data)
+        data = Util.remove_hex_prefix(data)
+        selector = Util.prefix_hex(data[0, 8])
+        payload = Util.prefix_hex(data[8..] || "")
+
+        selector_to_interfaces = Hash[interfaces.map { |i| [selector(i), i] }]
+        if (interface = selector_to_interfaces[selector])
+          inputs = interface.fetch("inputs", [])
+          types = inputs.map { |i| type(i) }
+          args = Abi.decode(types, payload)
+          kwargs = {}
+          inputs.each_with_index do |input, i|
+            name = input.fetch("name", "")
+            kwargs[name.to_sym] = args[i] unless name.empty?
+          end
+          CallDescription.new(interface, selector, args, kwargs)
+        end
+      end
+    end
+  end
+end

data/lib/eth/abi/type.rb

@@ -80,10 +80,27 @@ module Eth
           return
         end
 
-        _, base_type, sub_type, dimension = /([a-z]*)([0-9]*x?[0-9]*)((\[[0-9]*\])*)/.match(type).to_a
+        # ensure the type string is reasonable before attempting to parse
+        raise ParseError, "Invalid type format" unless type.is_a? String
+
+        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
-        dims = dimension.scan(/\[[0-9]*\]/)
+        # type dimension can only be numeric or empty for dynamic arrays
+        dims = dimension.scan(/\[\d+\]|\[\]/)
         raise ParseError, "Unknown characters found in array declaration" if dims.join != dimension
 
         # enforce base types
@@ -93,7 +110,7 @@ module Eth
         sub_type = sub_type.to_s
         @base_type = base_type
         @sub_type = sub_type
-        @dimensions = dims.map { |x| x[1...-1].to_i }
+        @dimensions = dims.map { |x| x == "[]" ? 0 : x[1...-1].to_i }
         @components = components.map { |component| Abi::Type.parse(component["type"], component.dig("components"), component.dig("name")) } if components&.any?
         @name = component_name
       end
@@ -123,7 +140,7 @@ module Eth
         if dimensions.empty?
           if !(["string", "bytes", "tuple"].include?(base_type) and sub_type.empty?)
             s = 32
-          elsif base_type == "tuple" and components.none?(&:dynamic?)
+          elsif base_type == "tuple" and components&.none?(&:dynamic?)
             s = components.sum(&:size)
           end
         elsif dimensions.last != 0 and !nested_sub.dynamic?
@@ -215,6 +232,53 @@ module Eth
           raise ParseError, "Unknown base type"
         end
       end
+
+      # Extracts the inner type list and trailing dimensions from an inline tuple definition.
+      def extract_tuple(type)
+        idx = 6 # skip "tuple("
+        depth = 1
+        while idx < type.length && depth > 0
+          case type[idx]
+          when "("
+            depth += 1
+          when ")"
+            depth -= 1
+          end
+          idx += 1
+        end
+        raise ParseError, "Invalid tuple format" unless depth.zero?
+        inner = type[6...(idx - 1)]
+        rest = type[idx..] || ""
+        [inner, rest]
+      end
+
+      # Splits a tuple component list into individual type strings, handling nested tuples.
+      def split_tuple_types(str)
+        types = []
+        depth = 0
+        current = ""
+        str.each_char do |ch|
+          case ch
+          when "("
+            depth += 1
+            current << ch
+          when ")"
+            depth -= 1
+            current << ch
+          when ","
+            if depth.zero?
+              types << current
+              current = ""
+            else
+              current << ch
+            end
+          else
+            current << ch
+          end
+        end
+        types << current unless current.empty?
+        types
+      end
     end
   end
 end

data/lib/eth/abi.rb

@@ -44,6 +44,7 @@ module Eth
       return solidity_packed(types, args) if packed
       types = [types] unless types.instance_of? Array
       args = [args] unless args.instance_of? Array
+      raise ArgumentError, "Types and values must be the same length" if types.length != args.length
 
       # parse all types
       parsed_types = types.map { |t| Type === t ? t : Type.parse(t) }
@@ -151,4 +152,5 @@ require "eth/abi/packed/encoder"
 require "eth/abi/decoder"
 require "eth/abi/encoder"
 require "eth/abi/event"
+require "eth/abi/function"
 require "eth/abi/type"

data/lib/eth/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/chain.rb

@@ -161,6 +161,9 @@ module Eth
     # Chain ID for Holesovice testnet.
     HOLESKY = HOLESOVICE
 
+    # Chain ID for Basecamp testnet.
+    BASECAMP = 123420001114.freeze
+
     # Chain ID for the geth private network preset.
     PRIVATE_GETH = 1337.freeze
 

data/lib/eth/client/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