etheruby 0.0.3 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0c566325afa370e6f3d4dc52964b205b26a53da7
-  data.tar.gz: 10cd9eac53229fe3a293fe0cefc879abf9d2cc3f
+  metadata.gz: 62e7a1ef2415572fb35e1617898576247fabeccb
+  data.tar.gz: 9f6747ff369f23fe11f3a67c0b815b6a53bbfd72
 SHA512:
-  metadata.gz: 6dc714bdcc04e5778b508d809e5e29fb230c4a1640f3e377c55d123a12d9929eb879f6d73175274816b7491a0943c2e96a0b60216ce240b2630e3038ff5553e8
-  data.tar.gz: c3cae2decb6fb2c2f8e79c3d27ed2dcbf3cf2c2ece666382445892cba8f226a4946e1f598a4f2803dd358b0158f35fab32c9cf24b3c1270a83c2ab8a97ea708b
+  metadata.gz: b5deae709916778cfd2e39217f22edb24929da0a57054cd5020a0882e8bf222d3b1928d90140a21ce99f9aaeb0eb103f4172031f1d9b857f05aee62ea39e9648
+  data.tar.gz: f725746f91570b71d37d89b62c241945688603fedaf17f0fb56db178511eb73206edd72d9d45fba75b88ebdb16458765e242166222d81765b7c03649e99b9051

data/lib/etheruby/arguments_generator.rb

@@ -1,11 +1,11 @@
 require 'bigdecimal'
 require_relative 'type_matchers'
+require_relative 'treat_variable'
+require_relative 'encoders/int'
 
 module Etheruby
 
-  class IncorrectTypeError < StandardError; end
   class ArgumentsCountError < StandardError; end
-  class InvalidFormatForDataError < StandardError; end
 
   class ArgumentsGenerator
 
@@ -16,127 +16,23 @@ module Etheruby
       @args = args
     end
 
-    def treat_variable(param, arg)
-      if match = TypeMatchers.is_sized_type(param)
-        # Parameter is a sized type, e.g. uint256, byte32 ...
-        send("#{match[1]}_encode".to_sym, match[2].to_i, arg)
-
-      elsif match = TypeMatchers.is_dualsized_type(param)
-        # Parameter is a dual sized array type, e.g. fixed16x16
-        send("#{match[1]}_encode".to_sym, match[2].to_i, match[3].to_i, arg)
-
-      elsif match = TypeMatchers.is_static_array_type(param)
-        # Parameter is a staticly sized array type, e.g. uint256[24]
-        static_array_encode(match[1], match[2].to_i, arg)
-
-      elsif match = TypeMatchers.is_dynamic_array_type(param)
-        # Parameter is a dynamicaly sized array type, e.g. uint256[]
-        dynamic_array_encode(match[1], arg)
-
-      else
-        # Parameter is a single-word type : string, bytes, address etc...
-        send("#{param}_encode".to_sym, arg)
-
-      end
-    end
-
     def to_s
-      raise ArgumentsCountError.new unless params.count == args.count
-      (0..params.count-1).map { |i| treat_variable(params[i], args[i]) }.join
-    end
-
-    ##
-    # int<X> encoding
-    def int_encode(size, arg)
-      if arg >= 0
-          arg.to_s(16).rjust(size / 4, '0')
-      else
-          mask = (1 << size) - 1
-          (arg & mask).to_s(16)
-      end
-    end
-
-    ##
-    # uint<X> encoding
-    def uint_encode(size, arg)
-      raise InvalidFormatForDataError.new("unsigned integer #{arg} < 0") if arg < 0
-      int_encode(size, arg)
-    end
-
-    ##
-    # ufixed<X> encoding
-    def ufixed_encode(size_i, size_d, arg)
-      raise InvalidFormatForDataError.new("unsigned fixed #{arg} < 0") if arg < 0
-      fixed_encode(size_i, size_d, arg)
-    end
-
-    ##
-    # fixed<X> encoding
-    def fixed_encode(size_i, size_d, arg)
-      raise InvalidFormatForDataError.new("Please use BigDecimal !") unless arg.is_a? BigDecimal
-      if arg >= 0
-        int_part, dec_part = arg.to_i, arg - arg.to_i
-      else
-        int_part, dec_part = arg.to_i, (arg + arg.to_i.abs).abs
+      raise ArgumentsCountError.new("Bad number of arguments") unless args.count == params.count
+      head = ''
+      tail = ''
+      current_tail_position = (params.count*32)
+      (0..params.count-1).each do |i|
+        param, arg = params[i], args[i]
+        if Etheruby.is_static_type? param
+          head += Etheruby.treat_variable(param, arg, :encode).to_s
+        else
+          head += Etheruby::Encoders::Uint.new(current_tail_position).encode
+          content = Etheruby.treat_variable(param, arg, :encode).to_s
+          current_tail_position += content.length/2
+          tail += content
+        end
       end
-      int_encode(size_i, int_part) + \
-      decimal_representation(size_d, dec_part)
-    end
-
-    ##
-    # Represent the decimal part in hexadimal according to the precision
-    def decimal_representation(precision, value)
-      (0..precision-1).map {
-        int_part, value = (value*2).to_i, (value*2) - (value*2).to_i
-        int_part
-      }.each_slice(8).map { |slice|
-        slice.join.to_i(2).to_s(16).rjust(2,'0')
-      }.join
-    end
-
-    ##
-    # Encode a static array
-    def static_array_encode(type, size, arg)
-      raise InvalidFormatForDataError.new(
-        "Array have #{arg.count} items for #{size} sized variable"
-      ) unless arg.count == size
-      arg.map { |item| treat_variable(type, item) }.join
-    end
-
-    ##
-    # Creates a dynamic array
-    def dynamic_array_encode(type, arg)
-      uint_encode(256, arg.count) + static_array_encode(type, arg.count, arg)
-    end
-
-    ##
-    # byte<X> encodeing
-    def byte_encode(size, arg)
-      arg.map{ |b| b.to_s(16).rjust(2,'0') }.join.rjust(size,'0')
-    end
-
-    ##
-    # address<X> encoding
-    def address_encode(arg)
-      uint_encode(160, arg)
-    end
-
-    ##
-    # string<x> encoding (as bytes)
-    def string_encode(arg)
-      bytes_encode(arg.codepoints)
-    end
-
-    ##
-    # bytes (dynamic size) encoding
-    def bytes_encode(arg)
-      uint_encode(256, arg.count) + arg.map{ |b| b.to_s(16).rjust(2,'0') }.join
-    end
-
-    ##
-    # boolean encoding (as uint8)
-    def bool_encode(arg)
-      uint_encode(8, arg ? 1 : 0)
+      return head + tail
     end
 
   end

data/lib/etheruby/encoders/address.rb

@@ -0,0 +1,17 @@
+require_relative 'base'
+require_relative 'int'
+
+module Etheruby::Encoders
+
+  class Address < Base
+    def encode
+      Uint.new(data).encode
+    end
+
+    def decode
+      v, s = Uint.new(data).decode
+      return "0x#{v.to_s(16)}", s
+    end
+  end
+
+end

data/lib/etheruby/encoders/arrays.rb

@@ -0,0 +1,91 @@
+require_relative 'base'
+require_relative 'int'
+require_relative '../treat_variable'
+
+module Etheruby::Encoders
+
+  class StaticArray < Base
+
+    attr_reader :type, :size
+
+    def initialize(_type, _size, _data)
+      super(_data)
+      @type = _type
+      @size = _size
+    end
+
+    def to_s
+      encode
+    end
+
+    def encode
+      if Etheruby::is_static_type? type
+        data.map{ |d| Etheruby::treat_variable(type, d, :encode) }.join
+      else
+        head_x = ''
+        enc_x = ''
+        c_pos = size * 32
+        data.map { |d|
+          treated = Etheruby::treat_variable(type, d, :encode)
+          {size: treated.length/2, value: treated}
+        }.each { |item|
+          head_x += Uint.new(c_pos).encode
+          c_pos += item[:size]
+          enc_x += item[:value]
+        }
+        head_x + enc_x
+      end
+    end
+
+    def decode
+      if Etheruby::is_static_type?(type)
+        sub_decode(0, data)
+      else
+        sub_decode(size*32, data[size*2*32..data.length])
+      end
+    end
+
+    private
+
+      def sub_decode(total_taken, real_data)
+        values = []
+        loop do
+          v, s = Etheruby::treat_variable(type, real_data, :decode)
+          v, s = v.decode if v.is_a? StaticArray or v.is_a? DynamicArray
+          values << v
+          total_taken += s
+          break if values.count == size
+          real_data = real_data[s*2..real_data.length]
+        end
+        return values, total_taken
+      end
+
+  end
+
+  class DynamicArray < Base
+
+    attr_reader :type
+
+    def initialize(_type, _data)
+      super(_data)
+      @type = _type
+    end
+
+    def to_s
+      encode
+    end
+
+    def encode
+      Uint.new(data.count).encode + \
+        StaticArray.new(type, data.count, data).encode
+    end
+
+    def decode
+      size, taken = Uint.new(data[0..63]).decode
+      v, s = StaticArray.new(type, size, data[64..data.length]).decode
+      return v, s+taken
+    end
+
+  end
+
+end

data/lib/etheruby/encoders/base.rb

@@ -0,0 +1,28 @@
+module Etheruby
+
+  module Encoders
+
+    class IncorrectTypeError < StandardError; end
+    class InvalidFormatForDataError < StandardError; end
+
+    class Base
+      attr_reader :data
+
+      def initialize(_data)
+        @data = _data
+      end
+
+      protected
+
+        def determinate_closest_padding(size)
+          if size % 32 == 0
+            size
+          else
+            32*(size/32+1)
+          end
+        end
+    end
+
+  end
+
+end

data/lib/etheruby/encoders/bool.rb

@@ -0,0 +1,16 @@
+require_relative 'base'
+require_relative 'int'
+
+module Etheruby::Encoders
+
+  class Bool < Base
+    def encode
+      Uint.new(data ? 1 : 0).encode
+    end
+
+    def decode
+      Uint.new(data).decode[0] == 1
+    end
+  end
+
+end

data/lib/etheruby/encoders/bytes.rb

@@ -0,0 +1,41 @@
+require_relative 'base'
+require_relative 'int'
+
+module Etheruby::Encoders
+
+  class Byte < Base
+
+    attr_reader :size
+
+    def initialize(_size,_data)
+      super(_data)
+      @size = _size
+    end
+
+    def encode
+      data.map{ |b|
+        b.to_s(16).rjust(2,'0')
+      }.join.ljust(determinate_closest_padding(size)*2, '0')
+    end
+
+    def decode
+      return data[0..(size*2)-1].split('').each_slice(2).map{ |b| b.join.to_i(16) },
+             determinate_closest_padding(size)
+    end
+
+  end
+
+  class Bytes < Base
+
+    def encode
+      Uint.new(data.length).encode + Byte.new(data.length, data).encode
+    end
+
+    def decode
+      size = Uint.new(data[0..63]).decode[0]
+      return Byte.new(size,data[64..data.length]).decode[0], determinate_closest_padding(size+32)
+    end
+
+  end
+
+end

data/lib/etheruby/encoders/fixed.rb

@@ -0,0 +1,78 @@
+require_relative 'base'
+require_relative 'int'
+
+module Etheruby::Encoders
+
+  class FixedBase < Base
+    attr_reader :size_i, :size_d
+
+    def initialize(_size_i, _size_d, _data)
+      super(_data)
+      @size_i = _size_i
+      @size_d = _size_d
+    end
+
+    protected
+
+      def encode_decimal_representation(value)
+        (0..@size_d-1).map {
+          int_part, value = (value*2).to_i, (value*2) - (value*2).to_i
+          int_part
+        }.each_slice(8).map { |slice|
+          slice.join.to_i(2).to_s(16).rjust(2,'0')
+        }.join
+      end
+
+      def decode_decimal_representation(part)
+        value = 0.0
+        exp = -1
+        bin_rpr = part.to_i(16).to_s(2).rjust(@size_d,'0')
+        bin_rpr.split("").each do |bit|
+          value += 2**exp if bit == '1'
+          exp -= 1
+        end
+        value
+      end
+  end
+
+  class Fixed < FixedBase
+
+    def encode
+      if data >= 0
+        int_part, dec_part = data.to_i, data - data.to_i
+      else
+        int_part, dec_part = data.to_i, (data + data.to_i.abs).abs
+      end
+      Int.new(int_part).encode(size_i/4) + \
+        encode_decimal_representation(dec_part).ljust((256-size_i)/4,'0')
+    end
+
+    def decode
+      @data = data[0..63]
+      int_part = Int.new(data[0..(size_i/4)-1]).decode[0]
+      dec_part = decode_decimal_representation(data[(size_i / 4)..data.length])
+      if int_part >= 0
+        return (dec_part + int_part), 32
+      else
+        return -(dec_part + int_part.abs), 32
+      end
+    end
+
+  end
+
+  class Ufixed < FixedBase
+
+    def encode
+      raise InvalidFormatForDataError.new("Unsigned fixed #{data} < 0") if data < 0
+      Fixed.new(size_i, size_d, data).encode
+    end
+
+    def decode
+      @data = data[0..63]
+      return Uint.new(data[0..(size_i/4)-1]).decode[0] +
+        decode_decimal_representation(data[(size_i / 4)..data.length]), 32
+    end
+
+  end
+
+end

data/lib/etheruby/encoders/int.rb

@@ -0,0 +1,41 @@
+require_relative 'base'
+
+module Etheruby::Encoders
+
+  class Int < Base
+
+    def encode(pad_to=64)
+      if data >= 0
+        data.to_s(16).rjust(pad_to, '0')
+      else
+        mask = (1 << pad_to*4) - 1
+        (data & mask).to_s(16).rjust(pad_to, 'f')
+      end
+    end
+
+    def decode
+      in_int = data[0..63].to_i(16)
+      in_bin = in_int.to_s(2).rjust(64, '0')
+      if in_bin[0] == '1'
+        return -(in_bin.split("").map{ |i| i == '1' ? '0' : '1' }.join.to_i(2) + 1), 32
+      else
+        return in_int, 32
+      end
+    end
+
+  end
+
+  class Uint < Base
+
+    def encode(pad_to=64)
+      raise InvalidFormatForDataError.new("Unsigned integer #{data} < 0") if data < 0
+      Int.new(data).encode(pad_to)
+    end
+
+    def decode
+      return data[0..63].to_i(16), 32
+    end
+
+  end
+
+end

data/lib/etheruby/encoders/string.rb

@@ -0,0 +1,17 @@
+require_relative 'base'
+require_relative 'bytes'
+
+module Etheruby::Encoders
+
+  class String < Base
+    def encode
+      Bytes.new(data.codepoints).encode
+    end
+
+    def decode
+      v, s = Bytes.new(data).decode
+      return v.pack('U*'), s
+    end
+  end
+
+end

data/lib/etheruby/response_parser.rb

@@ -4,107 +4,23 @@ module Etheruby
 
   class ResponseParser
 
+    attr_reader :returns, :response
+
     def initialize(_returns, _response)
       @returns = _returns
-      @response = _response
-    end
-
-    def treat_variable(param)
-      if match = TypeMatchers.is_sized_type(param)
-        # Parameter is a sized type, e.g. uint256, byte32 ...
-        send("#{match[1]}_decode".to_sym, match[2].to_i)
-
-      elsif match = TypeMatchers.is_dualsized_type(param)
-        # Parameter is a dual sized array type, e.g. fixed16x16
-        send("#{match[1]}_decode".to_sym, match[2].to_i, match[3].to_i)
-
-      elsif match = TypeMatchers.is_static_array_type(param)
-        # Parameter is a staticly sized array type, e.g. uint256[24]
-        static_array_decode(match[1], match[2].to_i)
-
-      elsif match = TypeMatchers.is_dynamic_array_type(param)
-        # Parameter is a dynamicaly sized array type, e.g. uint256[]
-        dynamic_array_decode(match[1])
-
-      else
-        # Parameter is a single-word type : string, bytes, address etc...
-        send("#{param}_decode".to_sym)
-
-      end
+      @response = _response[2.._response.length]
     end
 
     def parse
-      if @returns.count == 1
-        treat_variable(@returns[0])
+      if returns.count == 1
+        Etheruby::treat_variable(returns[0], response, :decode)
       else
-        @returns.map { |type| treat_variable(type) }
+        returns.each do |type|
+          
+        end
       end
     end
 
-    # Each decode method will receive in parameters the response string remaining
-    # to parse. It will extract the type of the response considering it as the
-    # first thing in the string and returns the string without it. Doing this,
-    # method calls will be chainable easily.
-
-    ##
-    # int<X> decoding
-    def int_decode(size)
-    end
-
-    ##
-    # uint<X> decoding
-    def uint_decode(size)
-      v, @response = @response[0..(size/4)].to_i(16), 
-                     @response[(size/4)..@response.length]
-      v
-    end
-
-    ##
-    # ufixed<X> decoding
-    def ufixed_decode(size_i, size_d)
-    end
-
-    ##
-    # fixed<X> decoding
-    def fixed_decode(size_i, size_d)
-    end
-
-    ##
-    # Decodes a static array
-    def static_array_decode(type, size)
-    end
-
-    ##
-    # Decodes a dynamic array
-    def dynamic_array_decode(type)
-    end
-
-    ##
-    # byte<X> decoding
-    def byte_decode(size)
-    end
-
-    ##
-    # address<X> decoding
-    def address_decode
-    end
-
-    ##
-    # string<x> decoding (as bytes)
-    def string_decode
-    end
-
-    ##
-    # bytes (dynamic size) decoding
-    def bytes_decode
-    end
-
-    ##
-    # boolean decoding (as uint8)
-    def bool_decode
-      uint_decode(8) == 1
-    end
-
   end
 
 end

data/lib/etheruby/treat_variable.rb

@@ -0,0 +1,52 @@
+require_relative 'encoders/address'
+require_relative 'encoders/arrays'
+require_relative 'encoders/bool'
+require_relative 'encoders/bytes'
+require_relative 'encoders/fixed'
+require_relative 'encoders/int'
+require_relative 'encoders/string'
+require_relative 'type_matchers'
+
+module Etheruby
+
+  def is_static_type?(param)
+    !(%w(string bytes).include?(param.to_s) || TypeMatchers.is_dynamic_array_type(param))
+  end
+
+  def is_array?(param)
+    TypeMatchers.is_static_array_type(param) || TypeMatchers.is_dynamic_array_type(param)
+  end
+
+  def treat_variable(param, arg, direction)
+    if match = TypeMatchers.is_sized_type(param)
+      # Parameter is a sized type, e.g. uint256, byte32 ...
+      klass = Etheruby::Encoders.const_get(match[1].capitalize)
+      return case klass
+      when Encoders::Bytes
+        Byte.new(match[2].to_i, arg)
+      else
+        klass.new(arg)
+      end.send(direction)
+
+    elsif match = TypeMatchers.is_dualsized_type(param)
+      # Parameter is a dual sized array type, e.g. fixed16x16, ufixed128x128
+      return Etheruby::Encoders.const_get(match[1].capitalize).
+             new(match[2].to_i, match[3].to_i, arg).send(direction)
+
+    elsif match = TypeMatchers.is_static_array_type(param)
+      # Parameter is a staticly sized array type, e.g. uint256[24]
+      Etheruby::Encoders::StaticArray.new(match[1], match[2].to_i, arg)
+
+    elsif match = TypeMatchers.is_dynamic_array_type(param)
+      # Parameter is a dynamicaly sized array type, e.g. uint256[]
+      Etheruby::Encoders::DynamicArray.new(match[1], arg).send(direction)
+
+    else
+      # Parameter is a single-word type : string, bytes, address etc...
+      Etheruby::Encoders.const_get(param.capitalize).new(arg).send(direction)
+
+    end
+  end
+
+  module_function :treat_variable, :is_static_type?, :is_array?
+end

data/lib/etheruby/type_matchers.rb

@@ -7,7 +7,7 @@ module Etheruby
     end
 
     def is_dualsized_type(param)
-      param.to_s.match /^(.+)(\d+)x(\d+)$/
+      param.to_s.match /^([a-z]+)(\d+)x(\d+)$/
     end
 
     def is_static_array_type(param)

data/lib/etheruby.rb

@@ -47,7 +47,7 @@ module Etheruby
           composed_body[kw] = method_info[kw] if method_info.has_key? kw
         }
         @@logger.debug("Calling #{method_info[:name]} with parameters #{composed_body.inspect}")
-        response = Client.eth.call composed_body, "latest"
+        response = call_api composed_body
         if response.has_key? 'error'
           @@logger.error("Failed contract execution #{response['error']['message']}")
         else
@@ -60,6 +60,10 @@ module Etheruby
         end
       end
 
+      def self.call_api(composed_body)
+        Client.eth.call composed_body, "latest"
+      end
+
       def self.address
         "0x#{@@address.to_s(16)}"
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: etheruby
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors:
 - Jérémy SEBAN
@@ -91,7 +91,16 @@ files:
 - lib/etheruby/arguments_generator.rb
 - lib/etheruby/client.rb
 - lib/etheruby/contract_method_dsl.rb
+- lib/etheruby/encoders/address.rb
+- lib/etheruby/encoders/arrays.rb
+- lib/etheruby/encoders/base.rb
+- lib/etheruby/encoders/bool.rb
+- lib/etheruby/encoders/bytes.rb
+- lib/etheruby/encoders/fixed.rb
+- lib/etheruby/encoders/int.rb
+- lib/etheruby/encoders/string.rb
 - lib/etheruby/response_parser.rb
+- lib/etheruby/treat_variable.rb
 - lib/etheruby/type_matchers.rb
 homepage: https://github.com/MechanicalSloth/etheruby
 licenses: