Fix exception when etherscan responds no status

README.md

@@ -211,7 +211,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/izetex/web3-eth. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on GitHub at https://github.com/Bloxy-info/web3-eth. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
 
 ## License

lib/web3/eth.rb

@@ -8,6 +8,9 @@
 require "web3/eth/log"
 require "web3/eth/transaction_receipt"
 require "web3/eth/eth_module"
+require "web3/eth/debug/debug_module"
+require "web3/eth/debug/transaction_call_trace"
 require "web3/eth/trace_module"
+require "web3/eth/parity_module"
 require "web3/eth/etherscan"
 require "web3/eth/rpc"

lib/web3/eth/abi/abi_coder.rb

@@ -192,10 +192,15 @@ def encode_primitive_type(type, arg)
       end
     end
 
+
+    def min_data_size types
+      types.size*32
+    end
+
     ##
     # Decodes multiple arguments using the head/tail mechanism.
     #
-    def decode_abi(types, data)
+    def decode_abi types, data, raise_errors = false
       parsed_types = types.map {|t| Type.parse(t) }
 
       outputs = [nil] * types.size
@@ -207,8 +212,17 @@ def decode_abi(types, data)
         # If a type is static, grab the data directly, otherwise record its
         # start position
         if t.dynamic?
+
+          if raise_errors && pos>data.size-1
+            raise DecodingError, "Position out of bounds #{pos}>#{data.size-1}"
+          end
+
           start_positions[i] = Utils.big_endian_to_int(data[pos, 32])
 
+          if raise_errors && start_positions[i]>data.size-1
+            raise DecodingError, "Start position out of bounds #{start_positions[i]}>#{data.size-1}"
+          end
+
           j = i - 1
           while j >= 0 && start_positions[j].nil?
             start_positions[j] = start_positions[i]
@@ -217,7 +231,7 @@ def decode_abi(types, data)
 
           pos += 32
         else
-          outputs[i] = data[pos, t.size]
+          outputs[i] = zero_padding data, pos, t.size, start_positions
           pos += t.size
         end
       end
@@ -230,36 +244,61 @@ def decode_abi(types, data)
         j -= 1
       end
 
-#      raise DecodingError, "Not enough data for head" unless pos <= data.size
+      if raise_errors && pos > data.size
+        raise DecodingError, "Not enough data for head"
+      end
+
 
       parsed_types.each_with_index do |t, i|
         if t.dynamic?
           offset, next_offset = start_positions[i, 2]
-          outputs[i] = data[offset...next_offset]
+          if offset<=data.size && next_offset<=data.size
+            outputs[i] = data[offset...next_offset]
+          end
         end
       end
 
+      if raise_errors && outputs.include?(nil)
+        raise DecodingError, "Not all data can be parsed"
+      end
+
       parsed_types.zip(outputs).map {|(type, out)| decode_type(type, out) }
     end
     alias :decode :decode_abi
 
+    def zero_padding data, pos, count, start_positions
+      if pos >= data.size
+        start_positions[start_positions.size-1] += count
+        "\x00"*count
+      elsif pos + count > data.size
+        start_positions[start_positions.size-1] += ( count - (data.size-pos))
+        data[pos,data.size-pos] + "\x00"*( count - (data.size-pos))
+      else
+        data[pos, count]
+      end
+    end
+
     def decode_typed_data type_name, data
       decode_primitive_type Type.parse(type_name), data
     end
 
     def decode_type(type, arg)
-      if %w(string bytes).include?(type.base) && type.sub.empty?
+      return nil if arg.nil? || arg.empty?
+      if type.kind_of?(Tuple) && type.dims.empty?
+        arg ? decode_abi(type.types, arg) : []
+      elsif %w(string bytes).include?(type.base) && type.sub.empty?
         l = Utils.big_endian_to_int arg[0,32]
         data = arg[32..-1]
         data[0, l]
       elsif type.dynamic?
         l = Utils.big_endian_to_int arg[0,32]
+        raise DecodingError, "Too long length: #{l}" if l>100000
         subtype = type.subtype
 
         if subtype.dynamic?
           raise DecodingError, "Not enough data for head" unless arg.size >= 32 + 32*l
 
-          start_positions = (1..l).map {|i| Utils.big_endian_to_int arg[32*i, 32] }
+          start_positions = (1..l).map {|i| 32+Utils.big_endian_to_int(arg[32*i, 32]) }
           start_positions.push arg.size
 
           outputs = (0...l).map {|i| arg[start_positions[i]...start_positions[i+1]] }

lib/web3/eth/abi/type.rb

@@ -12,6 +12,13 @@ class <<self
       # 256, 128x128, nil), array component (eg. [], [45], nil)
       #
       def parse(type)
+
+        return parse('uint256') if type=='trcToken'
+
+        if type =~ /^\((.*)\)((\[[0-9]*\])*)/
+          return Tuple.parse $1, $2.scan(/\[[0-9]*\]/)
+        end
+
         _, base, sub, dimension = /([a-z]*)([0-9]*x?[0-9]*)((\[[0-9]*\])*)/.match(type).to_a
 
         dims = dimension.scan(/\[[0-9]*\]/)
@@ -20,9 +27,7 @@ def parse(type)
         case base
           when ''
             return parse 'address'
-          when 'string'
-            raise ParseError, "String type must have no suffix or numerical suffix" unless sub.empty?
-          when 'bytes'
+          when 'bytes', 'string'
             raise ParseError, "Maximum 32 bytes for fixed-length string or bytes" unless sub.empty? || sub.to_i <= 32
           when 'uint', 'int'
             raise ParseError, "Integer type must have numerical suffix" unless sub =~ /\A[0-9]+\z/
@@ -37,7 +42,8 @@ def parse(type)
             total = high + low
 
             raise ParseError, "Fixed size out of bounds (max 32 bytes)" unless total >= 8 && total <= 256
-            raise ParseError, "Fixed high/low sizes must be multiples of 8" unless high % 8 == 0 && low % 8 == 0
+            raise ParseError, "Fixed high size must be multiple of 8" unless high % 8 == 0
+            raise ParseError, "Low sizes must be 0 to 80" unless low>0 && low<=80
           when 'hash'
             raise ParseError, "Hash type must have numerical suffix" unless sub =~ /\A[0-9]+\z/
           when 'address'
@@ -115,4 +121,82 @@ def subtype
     end
 
   end
+
+  class Tuple < Type
+
+    def self.parse types, dims
+
+      depth = 0
+      collected = []
+      current = ''
+
+      types.split('').each do |c|
+        case c
+          when ',' then
+            if depth==0
+              collected << current
+              current = ''
+            else
+              current += c
+            end
+          when '(' then
+            depth += 1
+            current += c
+          when ')' then
+            depth -= 1
+            current += c
+          else
+            current += c
+        end
+
+      end
+      collected << current unless current.empty?
+
+      Tuple.new collected, dims.map {|x| x[1...-1].to_i}
+
+    end
+
+    attr_reader :types, :parsed_types
+    def initialize types, dims
+      super('tuple', '', dims)
+      @types = types
+      @parsed_types = types.map{|t| Type.parse t}
+    end
+
+    def ==(another_type)
+      another_type.kind_of?(Tuple) &&
+          another_type.types == types &&
+          another_type.dims == dims
+    end
+
+    def size
+      @size ||= calculate_size
+    end
+
+    def calculate_size
+      if dims.empty?
+        s = 0
+        parsed_types.each do |type|
+          ts = type.size
+          return nil if ts.nil?
+          s += ts
+        end
+        s
+      else
+        if dims.last == 0 # 0 for dynamic array []
+          nil
+        else
+          subtype.dynamic? ? nil : dims.last * subtype.size
+        end
+      end
+
+
+    end
+
+    def subtype
+      @subtype ||= Tuple.new(types, dims[0...-1])
+    end
+
+  end
+
 end

lib/web3/eth/block.rb

@@ -27,6 +27,30 @@ def block_number
         from_hex number
       end
 
+      def block_difficulty
+        self.respond_to?(:difficulty) ? from_hex(difficulty) : 0
+      end
+
+      def block_gasLimit
+        self.respond_to?(:gasLimit) ? from_hex(gasLimit) : 0
+      end
+
+      def block_gasUsed
+        self.respond_to?(:gasUsed) ? from_hex(gasUsed) : 0
+      end
+
+      def block_nonce
+        self.respond_to?(:nonce) ? from_hex(nonce) : 0
+      end
+
+      def block_size
+        self.respond_to?(:size) ?  from_hex(size) : 0
+      end
+
+      def block_totalDifficulty
+        self.respond_to?(:totalDifficulty) ? from_hex(totalDifficulty) : 0
+      end
+
     end
 
   end