eth 0.5.8 → 0.5.10

data/lib/eth/abi/event.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2016-2022 The Ruby-Eth Contributors
+# Copyright (c) 2016-2023 The Ruby-Eth Contributors
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

data/lib/eth/abi/type.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2016-2022 The Ruby-Eth Contributors
+# Copyright (c) 2016-2023 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.
@@ -35,18 +35,28 @@ module Eth
       # The dimension attribute, e.g., `[10]` for an array of size 10.
       attr :dimensions
 
+      # The components of a tuple type.
+      attr :components
+
+      # The name of tuple component.
+      attr :name
+
       # Create a new Type object for base types, sub types, and dimensions.
       # Should not be used; use {Type.parse} instead.
       #
       # @param base_type [String] the base-type attribute.
       # @param sub_type [String] the sub-type attribute.
       # @param dimensions [Array] the dimension attribute.
+      # @param components [Array] the components attribute.
+      # @param component_name [String] the tuple component's name.
       # @return [Eth::Abi::Type] an ABI type object.
-      def initialize(base_type, sub_type, dimensions)
+      def initialize(base_type, sub_type, dimensions, components = nil, component_name = nil)
         sub_type = sub_type.to_s
         @base_type = base_type
         @sub_type = sub_type
         @dimensions = dimensions
+        @components = components
+        @name = component_name
       end
 
       # Converts the self.parse method into a constructor.
@@ -56,9 +66,12 @@ module Eth
       # Creates a new Type upon success (using konstructor).
       #
       # @param type [String] a common Solidity type.
+      # @param components [Array] the components attribute.
+      # @param component_name [String] the tuple component's name.
       # @return [Eth::Abi::Type] a parsed Type object.
       # @raise [ParseError] if it fails to parse the type.
-      def parse(type)
+      def parse(type, components = nil, component_name = nil)
+        return type if type.is_a?(Type)
         _, base_type, sub_type, dimension = /([a-z]*)([0-9]*x?[0-9]*)((\[[0-9]*\])*)/.match(type).to_a
 
         # type dimension can only be numeric
@@ -73,6 +86,8 @@ module Eth
         @base_type = base_type
         @sub_type = sub_type
         @dimensions = dims.map { |x| x[1...-1].to_i }
+        @components = components.map { |component| Eth::Abi::Type.parse(component["type"], component.dig("components"), component.dig("name")) } unless components.nil?
+        @name = component_name
       end
 
       # Creates a new uint256 type used for size.
@@ -98,15 +113,13 @@ module Eth
       def size
         s = nil
         if dimensions.empty?
-          unless ["string", "bytes"].include?(base_type) and sub_type.empty?
+          if !(["string", "bytes", "tuple"].include?(base_type) and sub_type.empty?)
             s = 32
+          elsif base_type == "tuple" && components.none?(&:dynamic?)
+            s = components.sum(&:size)
           end
-        else
-          unless dimensions.last == 0
-            unless nested_sub.is_dynamic?
-              s = dimensions.last * nested_sub.size
-            end
-          end
+        elsif dimensions.last != 0 && !nested_sub.dynamic?
+          s = dimensions.last * nested_sub.size
         end
         @size ||= s
       end
@@ -114,7 +127,7 @@ module Eth
       # Helpes to determine whether array is of dynamic size.
       #
       # @return [Boolean] true if array is of dynamic size.
-      def is_dynamic?
+      def dynamic?
         size.nil?
       end
 
@@ -122,7 +135,24 @@ module Eth
       #
       # @return [Eth::Abi::Type] nested sub-type.
       def nested_sub
-        @nested_sub ||= self.class.new(base_type, sub_type, dimensions[0...-1])
+        @nested_sub ||= self.class.new(base_type, sub_type, dimensions[0...-1], components, name)
+      end
+
+      # Allows exporting the type as string.
+      #
+      # @return [String] the type string.
+      def to_s
+        if base_type == "tuple"
+          "(" + components.map(&:to_s).join(",") + ")" + (dimensions.size > 0 ? dimensions.map { |x| "[#{x == 0 ? "" : x}]" }.join : "")
+        elsif dimensions.empty?
+          if %w[string bytes].include?(base_type) && sub_type.empty?
+            base_type
+          else
+            "#{base_type}#{sub_type}"
+          end
+        else
+          "#{base_type}#{sub_type}#{dimensions.map { |x| "[#{x == 0 ? "" : x}]" }.join}"
+        end
       end
 
       private
@@ -138,6 +168,10 @@ module Eth
 
           # bytes can be no longer than 32 bytes
           raise ParseError, "Maximum 32 bytes for fixed-length string or bytes" unless sub_type.empty? || sub_type.to_i <= 32
+        when "tuple"
+
+          # tuples can not have any suffix
+          raise ParseError, "Tuple type must have no suffix or numerical suffix" unless sub_type.empty?
         when "uint", "int"
 
           # integers must have a numerical suffix

data/lib/eth/abi.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2016-2022 The Ruby-Eth Contributors
+# Copyright (c) 2016-2023 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.
@@ -45,7 +45,7 @@ module Eth
     def encode(types, args)
 
       # parse all types
-      parsed_types = types.map { |t| Type.parse(t) }
+      parsed_types = types.map { |t| Type === t ? t : Type.parse(t) }
 
       # prepare the "head"
       head_size = (0...args.size)
@@ -55,7 +55,7 @@ module Eth
 
       # encode types and arguments
       args.each_with_index do |arg, i|
-        if parsed_types[i].is_dynamic?
+        if parsed_types[i].dynamic?
           head += encode_type Type.size_type, head_size + tail.size
           tail += encode_type parsed_types[i], arg
         else
@@ -81,12 +81,16 @@ module Eth
         size = encode_type Type.size_type, arg.size
         padding = Constant::BYTE_ZERO * (Util.ceil32(arg.size) - arg.size)
         return "#{size}#{arg}#{padding}"
-      elsif type.is_dynamic?
-        raise EncodingError, "Argument must be an Array" unless arg.instance_of? Array
+      elsif type.base_type == "tuple" && type.dimensions.size == 1 && type.dimensions[0] != 0
+        result = ""
+        result += encode_struct_offsets(type.nested_sub, arg)
+        result += arg.map { |x| encode_type(type.nested_sub, x) }.join
+        result
+      elsif type.dynamic? && arg.is_a?(Array)
 
         # encodes dynamic-sized arrays
         head, tail = "", ""
-        head += encode_type Type.size_type, arg.size
+        head += encode_type(Type.size_type, arg.size)
         nested_sub = type.nested_sub
         nested_sub_size = type.nested_sub.size
 
@@ -102,8 +106,10 @@ module Eth
               offset += total_bytes_length + 32
             end
 
-            head += encode_type Type.size_type, offset
+            head += encode_type(Type.size_type, offset)
           end
+        elsif nested_sub.base_type == "tuple" && nested_sub.dynamic?
+          head += encode_struct_offsets(nested_sub, arg)
         end
 
         arg.size.times do |i|
@@ -145,6 +151,8 @@ module Eth
         return encode_fixed arg, type
       when "string", "bytes"
         return encode_bytes arg, type
+      when "tuple"
+        return encode_tuple arg, type
       when "hash"
         return encode_hash arg, type
       when "address"
@@ -163,7 +171,7 @@ module Eth
     def decode(types, data)
 
       # accept hex abi but decode it first
-      data = Util.hex_to_bin data if Util.is_hex? data
+      data = Util.hex_to_bin data if Util.hex? data
 
       # parse all types
       parsed_types = types.map { |t| Type.parse(t) }
@@ -173,7 +181,7 @@ module Eth
       start_positions = [nil] * types.size + [data.size]
       pos = 0
       parsed_types.each_with_index do |t, i|
-        if t.is_dynamic?
+        if t.dynamic?
 
           # record start position for dynamic type
           start_positions[i] = Util.deserialize_big_endian_to_int(data[pos, 32])
@@ -201,7 +209,7 @@ module Eth
 
       # add dynamic types
       parsed_types.each_with_index do |t, i|
-        if t.is_dynamic?
+        if t.dynamic?
           offset, next_offset = start_positions[i, 2]
           outputs[i] = data[offset...next_offset]
         end
@@ -225,12 +233,12 @@ module Eth
 
         # decoded strings and bytes
         return data[0, l]
-      elsif type.is_dynamic?
+      elsif type.dynamic?
         l = Util.deserialize_big_endian_to_int arg[0, 32]
         nested_sub = type.nested_sub
 
         # ref https://github.com/ethereum/tests/issues/691
-        raise NotImplementedError, "Decoding dynamic arrays with nested dynamic sub-types is not implemented for ABI." if nested_sub.is_dynamic?
+        raise NotImplementedError, "Decoding dynamic arrays with nested dynamic sub-types is not implemented for ABI." if nested_sub.dynamic?
 
         # decoded dynamic-sized arrays
         return (0...l).map { |i| decode_type(nested_sub, arg[32 + nested_sub.size * i, nested_sub.size]) }
@@ -381,6 +389,56 @@ module Eth
       end
     end
 
+    # Properly encodes tuples.
+    def encode_tuple(arg, type)
+      raise EncodingError, "Expecting Hash: #{arg}" unless arg.instance_of? Hash
+      raise EncodingError, "Expecting #{type.components.size} elements: #{arg}" unless arg.size == type.components.size
+
+      static_size = 0
+      type.components.each_with_index do |component, i|
+        if type.components[i].dynamic?
+          static_size += 32
+        else
+          static_size += Util.ceil32(type.components[i].size || 0)
+        end
+      end
+
+      dynamic_offset = static_size
+      offsets_and_static_values = []
+      dynamic_values = []
+
+      type.components.each_with_index do |component, i|
+        component_type = type.components[i]
+        if component_type.dynamic?
+          offsets_and_static_values << encode_type(Type.size_type, dynamic_offset)
+          dynamic_value = encode_type(component_type, arg.is_a?(Array) ? arg[i] : arg[component_type.name])
+          dynamic_values << dynamic_value
+          dynamic_offset += dynamic_value.size
+        else
+          offsets_and_static_values << encode_type(component_type, arg.is_a?(Array) ? arg[i] : arg[component_type.name])
+        end
+      end
+
+      offsets_and_static_values.join + dynamic_values.join
+    end
+
+    # Properly encode struct offsets.
+    def encode_struct_offsets(type, arg)
+      result = ""
+      offset = arg.size
+      tails_encoding = arg.map { |a| encode_type(type, a) }
+      arg.size.times do |i|
+        if i == 0
+          offset *= 32
+        else
+          offset += tails_encoding[i - 1].size
+        end
+        offset_string = encode_type(Type.size_type, offset)
+        result += offset_string
+      end
+      result
+    end
+
     # Properly encodes hash-strings.
     def encode_hash(arg, type)
       size = type.sub_type.to_i
@@ -428,8 +486,8 @@ module Eth
     # The ABI encoder needs to be able to determine between a hex `"123"`
     # and a binary `"123"` string.
     def handle_hex_string(arg, type)
-      if Util.is_prefixed? arg or
-         (arg.size === type.sub_type.to_i * 2 and Util.is_hex? arg)
+      if Util.prefixed? arg or
+         (arg.size === type.sub_type.to_i * 2 and Util.hex? arg)
 
         # There is no way telling whether a string is hex or binary with certainty
         # in Ruby. Therefore, we assume a `0x` prefix to indicate a hex string.

data/lib/eth/address.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2016-2022 The Ruby-Eth Contributors
+# Copyright (c) 2016-2023 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.
@@ -29,7 +29,7 @@ module Eth
     #
     # @param address [String] hex string representing an ethereum address.
     def initialize(address)
-      unless Util.is_hex? address
+      unless Util.hex? address
         raise CheckSumError, "Unknown address type #{address}!"
       end
       @address = Util.prefix_hex address

data/lib/eth/api.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2016-2022 The Ruby-Eth Contributors
+# Copyright (c) 2016-2023 The Ruby-Eth Contributors
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

data/lib/eth/chain.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2016-2022 The Ruby-Eth Contributors
+# Copyright (c) 2016-2023 The Ruby-Eth Contributors
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -38,12 +38,18 @@ module Eth
     # Chain ID for POA Network mainnet.
     POA_NET = 99.freeze
 
-    # Chain ID for Gnosis mainnet.
+    # Chain ID for xDAI mainnet (now Gnosis Chain).
     XDAI = 100.freeze
 
-    # Chain ID for the Polygon Matic mainnet.
+    # Chain ID for Gnosis mainnet (formerly xDAI).
+    GNOSIS = XDAI.freeze
+
+    # Chain ID for the Matic mainnet (now Polygon).
     MATIC = 137.freeze
 
+    # Chain ID for the Polygon mainnet (formerly Matic).
+    POLYGON = MATIC.freeze
+
     # Chain ID for Arbitrum mainnet.
     ARBITRUM = 42161.freeze
 
@@ -86,9 +92,15 @@ module Eth
     # Chain ID for Arbitrum Rinkeby testnet.
     RINKEBY_ARBITRUM = 421611.freeze
 
+    # Chain ID for Arbitrum Goerli testnet.
+    GOERLI_ARBITRUM = 421613.freeze
+
     # Chain ID for Sepolia testnet.
     SEPOLIA = 11155111.freeze
 
+    # Chain ID for Holesovice testnet.
+    HOLESOVICE = 11166111.freeze
+
     # Chain ID for the geth private network preset.
     PRIVATE_GETH = 1337.freeze
 
@@ -97,7 +109,7 @@ module Eth
     #
     # @param v [Integer] the signature's `v` value.
     # @return [Boolean] true if ledger's legacy value.
-    def is_ledger?(v)
+    def ledger?(v)
       [0, 1].include? v
     end
 
@@ -106,7 +118,7 @@ module Eth
     #
     # @param v [Integer] the signature's `v` value.
     # @return [Boolean] true if legacy value.
-    def is_legacy?(v)
+    def legacy?(v)
       [27, 28].include? v
     end
 
@@ -120,11 +132,11 @@ module Eth
     def to_recovery_id(v, chain_id = ETHEREUM)
       e = 0 + 2 * chain_id + 35
       i = 1 + 2 * chain_id + 35
-      if [0, 1].include? v
+      if ledger? v
 
         # some wallets are using a `v` of 0 or 1 (ledger)
         return v
-      elsif is_legacy? v
+      elsif legacy? v
 
         # this is the pre-EIP-155 legacy case
         return v - 27

data/lib/eth/client/http.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2016-2022 The Ruby-Eth Contributors
+# Copyright (c) 2016-2023 The Ruby-Eth Contributors
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

data/lib/eth/client/http_auth.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2016-2022 The Ruby-Eth Contributors
+# Copyright (c) 2016-2023 The Ruby-Eth Contributors
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

data/lib/eth/client/ipc.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2016-2022 The Ruby-Eth Contributors
+# Copyright (c) 2016-2023 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.