etheruby 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 200899891a140cea002a7e7d9c1ac9916908275b
-  data.tar.gz: d01b91005637a2ee3543a0d1206a8a59bd265f93
+  metadata.gz: 0c566325afa370e6f3d4dc52964b205b26a53da7
+  data.tar.gz: 10cd9eac53229fe3a293fe0cefc879abf9d2cc3f
 SHA512:
-  metadata.gz: 76545aa6b9a4f8bf92e18b35556a2b4361607e5628760d940c4badf57e9a564dde5785fd6b3694c409a4800bf2df4e0f5129abbf1f3f1b78d36334015cd3386f
-  data.tar.gz: d7f1fcaf796b041096484d2ba695a5c9acbd4ee1c92cc22dea0822b3664dd807e2035b372751e2d8d968f13a483f1a2933578f5241fdc8ac8bc95c809a96f045
+  metadata.gz: 6dc714bdcc04e5778b508d809e5e29fb230c4a1640f3e377c55d123a12d9929eb879f6d73175274816b7491a0943c2e96a0b60216ce240b2630e3038ff5553e8
+  data.tar.gz: c3cae2decb6fb2c2f8e79c3d27ed2dcbf3cf2c2ece666382445892cba8f226a4946e1f598a4f2803dd358b0158f35fab32c9cf24b3c1270a83c2ab8a97ea708b

data/lib/etheruby/arguments_generator.rb

@@ -1,9 +1,12 @@
+require 'bigdecimal'
+require_relative 'type_matchers'
+
 module Etheruby
 
   class IncorrectTypeError < StandardError; end
   class ArgumentsCountError < StandardError; end
+  class InvalidFormatForDataError < StandardError; end
 
-  # https://github.com/ethereum/wiki/wiki/Ethereum-Contract-ABI
   class ArgumentsGenerator
 
     attr_reader :params, :args
@@ -13,51 +16,33 @@ module Etheruby
       @args = args
     end
 
-    def is_sized_type(param)
-      param.to_s.match /^([a-z]+)(\d+)$/
-    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)
 
-    def is_static_array_type(param)
-      param.to_s.match(/^([a-z]+)\[(\d+)\]$/)
-    end
+      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)
 
-    def is_dynamic_array_type(param)
-      param.to_s.match(/^([a-z]+)\[\]$/)
+      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
-      arguments = ""
-      # For each parameter of the method called, we
-      # match the corresponding type to encode and we send the
-      # parameter given to this encoder
-      (0..params.count-1).each do |i|
-        param, arg = params[i], args[i]
-        if match = is_sized_type(param)
-          # Parameter is a sized type, e.g. uint256, byte32 ...
-          method_name = "#{match[1]}_encode".to_sym
-          if respond_to?(method_name)
-            arguments += send(method_name, match[2].to_i, arg)
-          else
-            raise IncorrectTypeError.new("Type #{param} cannot be encoded")
-          end
-        elsif match = is_static_array_type(param)
-          # Parameter is a staticly sized array type, e.g. uint256[24]
-          arguments += static_array(match[1], match[2].to_i, arg)
-        elsif match = is_dynamic_array_type(param)
-          # Parameter is a dynamicaly sized array type, e.g. uint256[]
-          arguments += dynamic_array(match[1], arg)
-        else
-          # Parameter is a single-word type : string, bytes, address etc...
-          method_name = "#{param}_encode".to_sym
-          if respond_to?(method_name)
-            arguments += send(method_name, arg)
-          else
-            raise IncorrectTypeError.new("Type #{param} cannot be encoded")
-          end
-        end
-      end
-      arguments
+      (0..params.count-1).map { |i| treat_variable(params[i], args[i]) }.join
     end
 
     ##
@@ -74,37 +59,60 @@ module Etheruby
     ##
     # uint<X> encoding
     def uint_encode(size, arg)
-      arg.to_s(16).rjust(size / 4,'0')
+      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, arg)
-      #Todo
+    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
+      end
+      int_encode(size_i, int_part) + \
+      decimal_representation(size_d, dec_part)
     end
 
     ##
-    # ufixed<X> encoding
-    def ufixed_encode(size, arg)
-      #Todo
+    # 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(type, size, arg)
-      #Todo
+    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(type, arg)
-      #Todo
+    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) }.join.rjust(size,'0')
+      arg.map{ |b| b.to_s(16).rjust(2,'0') }.join.rjust(size,'0')
     end
 
     ##
@@ -122,7 +130,7 @@ module Etheruby
     ##
     # bytes (dynamic size) encoding
     def bytes_encode(arg)
-      uint_encode(256, arg.count) + arg.map{ |b| b.to_s(16) }.join
+      uint_encode(256, arg.count) + arg.map{ |b| b.to_s(16).rjust(2,'0') }.join
     end
 
     ##

data/lib/etheruby/client.rb

@@ -20,7 +20,7 @@ module Etheruby
       @sym = sym
     end
     def method_missing(sym, *data)
-      body = { 'id' => 'jsonrpc', 'method' => "#{@sym}_#{sym}", 'params' => data }
+      body = { 'id' => '1', 'method' => "#{@sym}_#{sym}", 'params' => data }
       text_response = http_post_request(::MultiJson.dump(body))
       ::MultiJson.load(text_response)
     end

data/lib/etheruby/response_parser.rb

@@ -0,0 +1,110 @@
+require_relative 'type_matchers'
+
+module Etheruby
+
+  class ResponseParser
+
+    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
+    end
+
+    def parse
+      if @returns.count == 1
+        treat_variable(@returns[0])
+      else
+        @returns.map { |type| treat_variable(type) }
+      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/type_matchers.rb

@@ -0,0 +1,25 @@
+module Etheruby
+
+  module TypeMatchers
+
+    def is_sized_type(param)
+      param.to_s.match /^([a-z]+)(\d+)$/
+    end
+
+    def is_dualsized_type(param)
+      param.to_s.match /^(.+)(\d+)x(\d+)$/
+    end
+
+    def is_static_array_type(param)
+      param.to_s.match(/^(.+)\[(\d+)\]$/)
+    end
+
+    def is_dynamic_array_type(param)
+      param.to_s.match(/^(.+)\[\]$/)
+    end
+
+    module_function :is_sized_type, :is_dualsized_type,
+                    :is_static_array_type, :is_dynamic_array_type
+  end
+
+end

data/lib/etheruby.rb

@@ -3,6 +3,7 @@ require 'logger'
 require_relative 'etheruby/client'
 require_relative 'etheruby/contract_method_dsl'
 require_relative 'etheruby/arguments_generator'
+require_relative 'etheruby/response_parser'
 
 module Etheruby
   class NoContractMethodError < StandardError; end
@@ -52,7 +53,11 @@ module Etheruby
         else
           @@logger.debug("Response from API for #{method_info[:name]} : #{response.inspect}")
         end
-        response['result']
+        if method_info.has_key? :returns
+          ResponseParser.new(method_info[:returns], response['result']).parse
+        else
+          response['result']
+        end
       end
 
       def self.address

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: etheruby
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Jérémy SEBAN
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-16 00:00:00.000000000 Z
+date: 2017-01-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: digest-sha3
@@ -80,7 +80,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.5'
-description: Describe ethereum smart-contract and execute them with ease.
+description: Etheruby is a library including a client for the JSON-RPC API and a Object-Contract
+  Mapper to interact with smart-contracts.
 email: jeremy@seban.eu
 executables: []
 extensions: []
@@ -90,6 +91,8 @@ files:
 - lib/etheruby/arguments_generator.rb
 - lib/etheruby/client.rb
 - lib/etheruby/contract_method_dsl.rb
+- lib/etheruby/response_parser.rb
+- lib/etheruby/type_matchers.rb
 homepage: https://github.com/MechanicalSloth/etheruby
 licenses:
 - MIT