ruby-ethereum 0.9.3 → 0.9.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8c18a40778f44a8f514e98f791b5a5238fc5e5f8
-  data.tar.gz: 0589c28717d274a533bb50612b6dd0fc14e99e0a
+  metadata.gz: d5dea8f0df777458359a58003ad2c36d5bab5c97
+  data.tar.gz: 3ad437895256c6a02baf5a65502e87f6fc2d3b3d
 SHA512:
-  metadata.gz: 889d80e5709de13b79b5877003c943f8d8d114fec8d42788f8835b8c935920535eee15c0be0d899853fba6d5c0075530aa3269bc745f5410f7a238ba084723ad
-  data.tar.gz: 9a1b4ba43049ae72d983cf9ba48d551dd21a54c01d5bc481828360b0b4abf6ff2dcdb1f7175673d9805cc8a4e3e30156e603be9a3aef27b31e181b5e95c8d84c
+  metadata.gz: f85feb3ff2fadd5822eb1927d714f3afa6c9bdab8fa4a475e1e34cbdad8b3e901a907395ad69fbe3f284ee23bc0b7f01c17729b684c379f2b7f57aeb26ae9814
+  data.tar.gz: 63eeecac33f4f8a60cc1274097d8871cc708debff8e6e304279485e34a22b1fd8bce2bb64f4db4023e59d4e56d91440c66a7a9faa6f49e5911f138e9c4ad4430

data/README.md

@@ -6,15 +6,7 @@ A Ruby implementation of [Ethereum](https://ethereum.org).
 
 ## Install Secp256k1
 
-```
-git clone git@github.com:bitcoin/bitcoin.git
-git checkout v0.11.2
-
-./autogen.sh
-./configure
-make
-sudo make install
-```
+https://github.com/cryptape/ruby-bitcoin-secp256k1
 
 ## Caveats
 

data/lib/ethereum/abi.rb

@@ -18,7 +18,7 @@ module Ethereum
 
     class EncodingError < StandardError; end
     class DecodingError < StandardError; end
-    class ValueOutOfBounds < StandardError; end
+    class ValueOutOfBounds < ValueError; end
 
     ##
     # Encodes multiple arguments using the head/tail mechanism.
@@ -54,12 +54,7 @@ module Ethereum
     #
     def encode_type(type, arg)
       if %w(string bytes).include?(type.base) && type.sub.empty?
-        raise ArgumentError, "arg must be a string" unless arg.instance_of?(String)
-
-        size = encode_type Type.size_type, arg.size
-        padding = BYTE_ZERO * (Utils.ceil32(arg.size) - arg.size)
-
-        "#{size}#{arg}#{padding}"
+        encode_primitive_type type, arg
       elsif type.dynamic?
         raise ArgumentError, "arg must be an array" unless arg.instance_of?(Array)
 
@@ -94,44 +89,76 @@ module Ethereum
     def encode_primitive_type(type, arg)
       case type.base
       when 'uint'
-        real_size = type.sub.to_i
-        i = get_uint arg
-
-        raise ValueOutOfBounds, arg unless i >= 0 && i < 2**real_size
-        Utils.zpad_int i
+        begin
+          real_size = type.sub.to_i
+          i = get_uint arg
+
+          raise ValueOutOfBounds, arg unless i >= 0 && i < 2**real_size
+          Utils.zpad_int i
+        rescue EncodingError
+          raise ValueOutOfBounds, arg
+        end
       when 'bool'
         raise ArgumentError, "arg is not bool: #{arg}" unless arg.instance_of?(TrueClass) || arg.instance_of?(FalseClass)
-        Utils.zpad_int(arg ? 1: 0)
+        Utils.zpad_int(arg ? 1 : 0)
       when 'int'
-        real_size = type.sub.to_i
-        i = get_int arg
-
-        raise ValueOutOfBounds, arg unless i >= -2**(real_size-1) && i < 2**(real_size-1)
-        Utils.zpad_int(i % 2**type.sub.to_i)
-      when 'ureal', 'ufixed'
+        begin
+          real_size = type.sub.to_i
+          i = get_int arg
+
+          raise ValueOutOfBounds, arg unless i >= -2**(real_size-1) && i < 2**(real_size-1)
+          Utils.zpad_int(i % 2**type.sub.to_i)
+        rescue EncodingError
+          raise ValueOutOfBounds, arg
+        end
+      when 'ufixed'
         high, low = type.sub.split('x').map(&:to_i)
 
         raise ValueOutOfBounds, arg unless arg >= 0 && arg < 2**high
         Utils.zpad_int((arg * 2**low).to_i)
-      when 'real', 'fixed'
+      when 'fixed'
         high, low = type.sub.split('x').map(&:to_i)
 
         raise ValueOutOfBounds, arg unless arg >= -2**(high - 1) && arg < 2**(high - 1)
 
         i = (arg * 2**low).to_i
         Utils.zpad_int(i % 2**(high+low))
-      when 'string', 'bytes'
-        raise EncodingError, "Expecting string: #{arg}" unless arg.instance_of?(String)
+      when 'string'
+        if arg.encoding.name == 'UTF-8'
+          arg = arg.b
+        else
+          begin
+            arg.unpack('U*')
+          rescue ArgumentError
+            raise ValueError, "string must be UTF-8 encoded"
+          end
+        end
 
         if type.sub.empty? # variable length type
+          raise ValueOutOfBounds, "Integer invalid or out of range: #{arg.size}" if arg.size >= TT256
           size = Utils.zpad_int arg.size
-          padding = BYTE_ZERO * (Utils.ceil32(arg.size) - arg.size)
-          "#{size}#{arg}#{padding}"
+          value = Utils.rpad arg, BYTE_ZERO, Utils.ceil32(arg.size)
+          "#{size}#{value}"
         else # fixed length type
-          raise ValueOutOfBounds, arg unless arg.size <= type.sub.to_i
+          sub = type.sub.to_i
+          raise ValueOutOfBounds, "invalid string length #{sub}" if arg.size > sub
+          raise ValueOutOfBounds, "invalid string length #{sub}" if sub < 0 || sub > 32
+          Utils.rpad(arg, BYTE_ZERO, 32)
+        end
+      when 'bytes'
+        raise EncodingError, "Expecting string: #{arg}" unless arg.instance_of?(String)
+        arg = arg.b
 
-          padding = BYTE_ZERO * (32 - arg.size)
-          "#{arg}#{padding}"
+        if type.sub.empty? # variable length type
+          raise ValueOutOfBounds, "Integer invalid or out of range: #{arg.size}" if arg.size >= TT256
+          size = Utils.zpad_int arg.size
+          value = Utils.rpad arg, BYTE_ZERO, Utils.ceil32(arg.size)
+          "#{size}#{value}"
+        else # fixed length type
+          sub = type.sub.to_i
+          raise ValueOutOfBounds, "invalid bytes length #{sub}" if arg.size > sub
+          raise ValueOutOfBounds, "invalid bytes length #{sub}" if sub < 0 || sub > 32
+          Utils.rpad(arg, BYTE_ZERO, 32)
         end
       when 'hash'
         size = type.sub.to_i
@@ -266,10 +293,10 @@ module Ethereum
       when 'int'
         u = Utils.big_endian_to_int data
         u >= 2**(type.sub.to_i-1) ? (u - 2**type.sub.to_i) : u
-      when 'ureal', 'ufixed'
+      when 'ufixed'
         high, low = type.sub.split('x').map(&:to_i)
         Utils.big_endian_to_int(data) * 1.0 / 2**low
-      when 'real', 'fixed'
+      when 'fixed'
         high, low = type.sub.split('x').map(&:to_i)
         u = Utils.big_endian_to_int data
         i = u >= 2**(high+low-1) ? (u - 2**(high+low)) : u
@@ -289,13 +316,17 @@ module Ethereum
         raise EncodingError, "Number out of range: #{n}" if n > UINT_MAX || n < UINT_MIN
         n
       when String
-        if n.size == 40
-          Utils.big_endian_to_int Utils.decode_hex(n)
-        elsif n.size <= 32
-          Utils.big_endian_to_int n
-        else
-          raise EncodingError, "String too long: #{n}"
-        end
+        i = if n.size == 40
+              Utils.decode_hex(n)
+            elsif n.size <= 32
+              n
+            else
+              raise EncodingError, "String too long: #{n}"
+            end
+        i = Utils.big_endian_to_int i
+
+        raise EncodingError, "Number out of range: #{i}" if i > UINT_MAX || i < UINT_MIN
+        i
       when true
         1
       when false, nil
@@ -311,14 +342,18 @@ module Ethereum
         raise EncodingError, "Number out of range: #{n}" if n > INT_MAX || n < INT_MIN
         n
       when String
-        if n.size == 40
-          i = Utils.big_endian_to_int Utils.decode_hex(n)
-        elsif n.size <= 32
-          i = Utils.big_endian_to_int n
-        else
-          raise EncodingError, "String too long: #{n}"
-        end
-        i > INT_MAX ? (i-TT256) : i
+        i = if n.size == 40
+              Utils.decode_hex(n)
+            elsif n.size <= 32
+              n
+            else
+              raise EncodingError, "String too long: #{n}"
+            end
+        i = Utils.big_endian_to_int i
+
+        i = i > INT_MAX ? (i-TT256) : i
+        raise EncodingError, "Number out of range: #{i}" if i > INT_MAX || i < INT_MIN
+        i
       when true
         1
       when false, nil

data/lib/ethereum/abi/contract_translator.rb

@@ -6,140 +6,180 @@ module Ethereum
   module ABI
     class ContractTranslator
 
-      def initialize(full_signature)
-        @v = {
+      def initialize(contract_interface)
+        if contract_interface.instance_of?(String)
+          contract_interface = JSON.parse contract_interface
+        end
+
+        @contract = {
+          constructor_data: nil,
           function_data: {},
           event_data: {}
         }
 
-        if full_signature.instance_of?(String)
-          full_signature = JSON.parse full_signature
-        end
-
-        full_signature.each do |sig_item|
-          next if sig_item['type'] == 'constructor'
-
-          encode_types = sig_item['inputs'].map {|f| f['type'] }
-          signature = sig_item['inputs'].map {|f| [f['type'], f['name']] }
-          name = sig_item['name']
-
-          if name =~ /\(/
-            name = name[0, name.index('(')]
-          end
-
-          # TODO: removable?
-          #if @v.has_key?(name.to_sym)
-          #  i = 2
-          #  i += 1 while @v.has_key?(:"#{name}#{i}")
-          #  name += i.to_s
-
-          #  logger.warn "multiple methods with the same name. Use #{name} to call #{sig_item['name']} with types #{encode_types}"
-          #end
-
-          if sig_item['type'] == 'function'
-            decode_types = sig_item['outputs'].map {|f| f['type'] }
-            is_unknown_type = sig_item['outputs'].size.true? && sig_item['outputs'][0]['name'] == 'unknown_out'
-            function_data[name.to_sym] = {
+        contract_interface.each do |desc|
+          encode_types = desc['inputs'].map {|e| e['type'] }
+          signature = desc['inputs'].map {|e| [e['type'], e['name']] }
+
+          # type can be omitted, defaulting to function
+          type = desc['type'] || 'function'
+          case type
+          when 'function'
+            name = basename desc['name']
+            decode_types = desc['outputs'].map {|e| e['type'] }
+            @contract[:function_data][name] = {
               prefix: method_id(name, encode_types),
               encode_types: encode_types,
               decode_types: decode_types,
-              is_unknown_type: is_unknown_type,
-              is_constant: sig_item.fetch('constant', false),
+              is_constant: desc.fetch('constant', false),
               signature: signature
             }
-          elsif sig_item['type'] == 'event'
-            indexed = sig_item['inputs'].map {|f| f['indexed'] }
-            names = sig_item['inputs'].map {|f| f['name'] }
-
-            event_data[event_id(name, encode_types)] = {
+          when 'event'
+            name = basename desc['name']
+            indexed = desc['inputs'].map {|e| e['indexed'] }
+            names = desc['inputs'].map {|e| e['name'] }
+            @contract[:event_data][event_id(name, encode_types)] = {
               types: encode_types,
               name: name,
               names: names,
               indexed: indexed,
-              anonymous: sig_item.fetch('anonymous', false)
+              anonymous: desc.fetch('anonymous', false)
             }
+          when 'constructor'
+            raise ValueError, "Only one constructor is supported." if @contract[:constructor_data]
+            @contract[:constructor_data] = {
+              encode_types: encode_types,
+              signature: signature
+            }
+          else
+            raise ValueError, "Unknown interface type: #{type}"
           end
         end
       end
 
+      ##
+      # Return the encoded function call.
+      #
+      # @param name [String] One of the existing functions described in the
+      #   contract interface.
+      # @param args [Array[Object]] The function arguments that will be encoded
+      #   and used in the contract execution in the vm.
+      #
+      # @return [String] The encoded function name and arguments so that it can
+      #   be used with the evm to execute a function call, the binary string
+      #   follows the Ethereum Contract ABI.
+      #
       def encode(name, args)
-        fdata = function_data[name.to_sym]
-        id = Utils.zpad(Utils.encode_int(fdata[:prefix]), 4)
-        calldata = ABI.encode_abi fdata[:encode_types], args
-        "#{id}#{calldata}"
+        raise ValueError, "Unknown function #{name}" unless function_data.include?(name)
+
+        desc = function_data[name]
+        func_id = Utils.zpad(Utils.encode_int(desc[:prefix]), 4)
+        calldata = ABI.encode_abi desc[:encode_types], args
+
+        "#{func_id}#{calldata}"
       end
 
-      def decode(name, data)
-        fdata = function_data[name.to_sym]
+      ##
+      # Return the encoded constructor call.
+      #
+      def encode_constructor_arguments(args)
+        raise ValueError, "The contract interface didn't have a constructor" unless constructor_data
 
-        if fdata[:is_unknown_type]
-          i = 0
-          o = []
+        ABI.encode_abi constructor_data[:encode_types], args
+      end
 
-          while i < data.size
-            o.push Utils.to_signed(Utils.big_endian_to_int(data[i,32]))
-            i += 32
-          end
+      ##
+      # Return the function call result decoded.
+      #
+      # @param name [String] One of the existing functions described in the
+      #   contract interface.
+      # @param data [String] The encoded result from calling function `name`.
+      #
+      # @return [Array[Object]] The values returned by the call to function
+      #
+      def decode_function_result(name, data)
+        desc = function_data[name]
+        ABI.decode_abi desc[:decode_types], data
+      end
+      alias :decode :decode_function_result
+
+      ##
+      # Return a dictionary represent the log.
+      #
+      # Notes: this function won't work with anonymous events.
+      #
+      # @param log_topics [Array[String]] The log's indexed arguments.
+      # @param log_data [String] The encoded non-indexed arguments.
+      #
+      def decode_event(log_topics, log_data)
+        # topics[0]: keccak256(normalized_event_name)
+        raise ValueError, "Unknown log type" unless log_topics.size > 0 && event_data.has_key?(log_topics[0])
+
+        event_id = log_topics[0]
+        event = event_data[event_id]
+
+        names = event[:names]
+        types = event[:types]
+        indexed = event[:indexed]
 
-          return 0 if o.empty?
-          o.size == 1 ? o[0] : o
-        else
-          ABI.decode_abi fdata[:decode_types], data
+        unindexed_types = types.zip(indexed).select {|(t, i)| i.false? }.map(&:first)
+        unindexed_args = ABI.decode_abi unindexed_types, log_data
+
+        result = {}
+        indexed_count = 1 # skip topics[0]
+        names.each_with_index do |name, i|
+          v = if indexed[i].true?
+                topic_bytes = Utils.zpad_int log_topics[indexed_count]
+                indexed_count += 1
+                ABI.decode_primitive_type ABI::Type.parse(types[i]), topic_bytes
+              else
+                unindexed_args.shift
+              end
+
+          result[name] = v
         end
+
+        result['_event_type'] = event[:name]
+        result
+      end
+
+      ##.
+      # Return a dictionary representation of the Log instance.
+      #
+      # Note: this function won't work with anonymous events.
+      #
+      # @param log [Log] The Log instance that needs to be parsed.
+      # @param noprint [Bool] Flag to turn off printing of the decoded log
+      #   instance.
+      #
+      def listen(log, noprint: true)
+        result = decode_event log.topics, log.data
+        p result if noprint
+        result
+      rescue ValueError
+        nil # api compatibility
+      end
+
+      def constructor_data
+        @contract[:constructor_data]
       end
 
       def function_data
-        @v[:function_data]
+        @contract[:function_data]
       end
 
       def event_data
-        @v[:event_data]
+        @contract[:event_data]
       end
 
       def function(name)
-        function_data[name.to_sym]
+        function_data[name]
       end
 
       def event(name, encode_types)
         event_data[event_id(name, encode_types)]
       end
 
-      def is_unknown_type(name)
-        function_data[name.to_sym][:is_unknown_type]
-      end
-
-      def listen(log, noprint=false)
-        return if log.topics.size == 0 || !event_data.has_key?(log.topics[0])
-
-        data = event_data[log.topics[0]]
-        types = data[:types]
-        name = data[:name]
-        names = data[:names]
-        indexed = data[:indexed]
-        indexed_types = types.zip(indexed).select {|(t, i)| i.true? }.map(&:first)
-        unindexed_types = types.zip(indexed).select {|(t, i)| i.false? }.map(&:first)
-
-        deserialized_args = ABI.decode_abi unindexed_types, log.data
-
-        o = {}
-        c1, c2 = 0, 0
-        names.each_with_index do |n, i|
-          if indexed[i].true?
-            topic_bytes = Utils.zpad_int log.topics[c1+1]
-            o[n] = ABI.decode_primitive_type ABI::Type.parse(indexed_types[c1]), topic_bytes
-            c1 += 1
-          else
-            o[n] = deserialized_args[c2]
-            c2 += 1
-          end
-        end
-
-        o['_event_type'] = name
-        p o unless noprint
-
-        o
-      end
-
       def method_id(name, encode_types)
         Utils.big_endian_to_int Utils.keccak256(get_sig(name, encode_types))[0,4]
       end
@@ -155,20 +195,25 @@ module Ethereum
       end
 
       def get_sig(name, encode_types)
-        "#{name}(#{encode_types.map {|x| canonical_name(x) }.join(',')})"
+        "#{name}(#{encode_types.map {|x| canonical_type(x) }.join(',')})"
       end
 
-      def canonical_name(x)
+      def canonical_type(x)
         case x
         when /\A(uint|int)(\[.*\])?\z/
           "#{$1}256#{$2}"
-        when /\A(real|ureal|fixed|ufixed)(\[.*\])?\z/
+        when /\A(fixed|ufixed)(\[.*\])?\z/
           "#{$1}128x128#{$2}"
         else
           x
         end
       end
 
+      def basename(n)
+        i = n.index '('
+        i ? n[0,i] : n
+      end
+
     end
   end
 end