ethereum-abi 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5929d9e3f2d9f92e4ee09812a83be6ed5ec8f483
+  data.tar.gz: 9113211fd4457ca8b4d1aaef4f35a2ed02936ce4
+SHA512:
+  metadata.gz: 73b55734bf2fbe1a1cc37ff68904869eb54a6c85c574a5062a259e59b6125fb43732cb25dc15925e59468c8b0acf4f6474a45210aa3d2e243547c169130ef360
+  data.tar.gz: 5931f31438e902fc35bc2b2d8c5959c95465698ef6214356da4621df4d65b0a18f7b7f698d82ba70ff8aa83dae029efb3a286a0d5d005d7e8cae2ab2e4c054c1

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 zhangyaning
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,3 @@
+A Ruby implementation of [Ethereum-Contract-ABI](https://github.com/ethereum/wiki/wiki/Ethereum-Contract-ABI).
+
+Extracted from [ruby-ethereum](https://github.com/janx/ruby-ethereum)

data/lib/ethereum/abi.rb

@@ -0,0 +1,333 @@
+require 'ethereum/abi/contract_translator'
+require 'ethereum/abi/type'
+require 'ethereum/abi/constant'
+require 'ethereum/exceptions'
+require 'block_logger'
+require 'rlp'
+
+module Ethereum
+  ##
+  # Contract ABI encoding and decoding.
+  #
+  # @see https://github.com/ethereum/wiki/wiki/Ethereum-Contract-ABI
+  #
+  module ABI
+
+    extend self
+
+    include Constant
+
+    class EncodingError < StandardError; end
+    class DecodingError < StandardError; end
+    class ValueOutOfBounds < StandardError; end
+
+    ##
+    # Encodes multiple arguments using the head/tail mechanism.
+    #
+    def encode_abi(types, args)
+      parsed_types = types.map {|t| Type.parse(t) }
+
+      head_size = (0...args.size)
+        .map {|i| parsed_types[i].size || 32 }
+        .reduce(0, &:+)
+
+      head, tail = '', ''
+      args.each_with_index do |arg, i|
+        if parsed_types[i].dynamic?
+          head += encode_type(Type.size_type, head_size + tail.size)
+          tail += encode_type(parsed_types[i], arg)
+        else
+          head += encode_type(parsed_types[i], arg)
+        end
+      end
+
+      "#{head}#{tail}"
+    end
+    alias :encode :encode_abi
+
+    ##
+    # Encodes a single value (static or dynamic).
+    #
+    # @param type [Ethereum::ABI::Type] value type
+    # @param arg [Object] value
+    #
+    # @return [String] encoded bytes
+    #
+    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}"
+      elsif type.dynamic?
+        raise ArgumentError, "arg must be an array" unless arg.instance_of?(Array)
+
+        head, tail = '', ''
+        if type.dims.last == 0
+          head += encode_type(Type.size_type, arg.size)
+        else
+          raise ArgumentError, "Wrong array size: found #{arg.size}, expecting #{type.dims.last}" unless arg.size == type.dims.last
+        end
+
+        sub_type = type.subtype
+        sub_size = type.subtype.size
+        arg.size.times do |i|
+          if sub_size.nil?
+            head += encode_type(Type.size_type, 32*arg.size + tail.size)
+            tail += encode_type(sub_type, arg[i])
+          else
+            head += encode_type(sub_type, arg[i])
+          end
+        end
+
+        "#{head}#{tail}"
+      else # static type
+        if type.dims.empty?
+          encode_primitive_type type, arg
+        else
+          arg.map {|x| encode_type(type.subtype, x) }.join
+        end
+      end
+    end
+
+    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
+      when 'bool'
+        raise ArgumentError, "arg is not bool: #{arg}" unless arg.instance_of?(TrueClass) || arg.instance_of?(FalseClass)
+        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'
+        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'
+        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)
+
+        if type.sub.empty? # variable length type
+          size = Utils.zpad_int arg.size
+          padding = BYTE_ZERO * (Utils.ceil32(arg.size) - arg.size)
+          "#{size}#{arg}#{padding}"
+        else # fixed length type
+          raise ValueOutOfBounds, arg unless arg.size <= type.sub.to_i
+
+          padding = BYTE_ZERO * (32 - arg.size)
+          "#{arg}#{padding}"
+        end
+      when 'hash'
+        size = type.sub.to_i
+        raise EncodingError, "too long: #{arg}" unless size > 0 && size <= 32
+
+        if arg.is_a?(Integer)
+          Utils.zpad_int(arg)
+        elsif arg.size == size
+          Utils.zpad arg, 32
+        elsif arg.size == size * 2
+          Utils.zpad_hex arg
+        else
+          raise EncodingError, "Could not parse hash: #{arg}"
+        end
+      when 'address'
+        if arg.is_a?(Integer)
+          Utils.zpad_int arg
+        elsif arg.size == 20
+          Utils.zpad arg, 32
+        elsif arg.size == 40
+          Utils.zpad_hex arg
+        elsif arg.size == 42 && arg[0,2] == '0x'
+          Utils.zpad_hex arg[2..-1]
+        else
+          raise EncodingError, "Could not parse address: #{arg}"
+        end
+      else
+        raise EncodingError, "Unhandled type: #{type.base} #{type.sub}"
+      end
+    end
+
+    ##
+    # Decodes multiple arguments using the head/tail mechanism.
+    #
+    def decode_abi(types, data)
+      parsed_types = types.map {|t| Type.parse(t) }
+
+      outputs = [nil] * types.size
+      start_positions = [nil] * types.size + [data.size]
+
+      # TODO: refactor, a reverse iteration will be better
+      pos = 0
+      parsed_types.each_with_index do |t, i|
+        # If a type is static, grab the data directly, otherwise record its
+        # start position
+        if t.dynamic?
+          start_positions[i] = Utils.big_endian_to_int(data[pos, 32])
+
+          j = i - 1
+          while j >= 0 && start_positions[j].nil?
+            start_positions[j] = start_positions[i]
+            j -= 1
+          end
+
+          pos += 32
+        else
+          outputs[i] = data[pos, t.size]
+          pos += t.size
+        end
+      end
+
+      # We add a start position equal to the length of the entire data for
+      # convenience.
+      j = types.size - 1
+      while j >= 0 && start_positions[j].nil?
+        start_positions[j] = start_positions[types.size]
+        j -= 1
+      end
+
+      raise DecodingError, "Not enough data for head" unless pos <= data.size
+
+      parsed_types.each_with_index do |t, i|
+        if t.dynamic?
+          offset, next_offset = start_positions[i, 2]
+          outputs[i] = data[offset...next_offset]
+        end
+      end
+
+      parsed_types.zip(outputs).map {|(type, out)| decode_type(type, out) }
+    end
+    alias :decode :decode_abi
+
+    def decode_type(type, arg)
+      if %w(string bytes).include?(type.base) && type.sub.empty?
+        l = Utils.big_endian_to_int arg[0,32]
+        data = arg[32..-1]
+
+        raise DecodingError, "Wrong data size for string/bytes object" unless data.size == Utils.ceil32(l)
+
+        data[0, l]
+      elsif type.dynamic?
+        l = Utils.big_endian_to_int arg[0,32]
+        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.push arg.size
+
+          outputs = (0...l).map {|i| arg[start_positions[i]...start_positions[i+1]] }
+
+          outputs.map {|out| decode_type(subtype, out) }
+        else
+          (0...l).map {|i| decode_type(subtype, arg[32 + subtype.size*i, subtype.size]) }
+        end
+      elsif !type.dims.empty? # static-sized arrays
+        l = type.dims.last[0]
+        subtype = type.subtype
+
+        (0...l).map {|i| decode_type(subtype, arg[subtype.size*i, subtype.size]) }
+      else
+        decode_primitive_type type, arg
+      end
+    end
+
+    def decode_primitive_type(type, data)
+      case type.base
+      when 'address'
+        Utils.encode_hex data[12..-1]
+      when 'string', 'bytes'
+        if type.sub.empty? # dynamic
+          size = Utils.big_endian_to_int data[0,32]
+          data[32..-1][0,size]
+        else # fixed
+          data[0, type.sub.to_i]
+        end
+      when 'hash'
+        data[(32 - type.sub.to_i), type.sub.to_i]
+      when 'uint'
+        Utils.big_endian_to_int data
+      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'
+        high, low = type.sub.split('x').map(&:to_i)
+        Utils.big_endian_to_int(data) * 1.0 / 2**low
+      when 'real', '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
+        i * 1.0 / 2**low
+      when 'bool'
+        data[-1] == BYTE_ONE
+      else
+        raise DecodingError, "Unknown primitive type: #{type.base}"
+      end
+    end
+
+    private
+
+    def get_uint(n)
+      case n
+      when Integer
+        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
+      when true
+        1
+      when false, nil
+        0
+      else
+        raise EncodingError, "Cannot decode uint: #{n}"
+      end
+    end
+
+    def get_int(n)
+      case n
+      when Integer
+        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
+      when true
+        1
+      when false, nil
+        0
+      else
+        raise EncodingError, "Cannot decode int: #{n}"
+      end
+    end
+
+  end
+end

data/lib/ethereum/abi/constant.rb

@@ -0,0 +1,26 @@
+# -*- encoding : ascii-8bit -*-
+
+module Ethereum
+  module ABI
+    module Constant
+      BYTE_EMPTY = "".freeze
+      BYTE_ZERO = "\x00".freeze
+      BYTE_ONE  = "\x01".freeze
+
+      TT32  = 2**32
+      TT256 = 2**256
+      TT64M1 = 2**64 - 1
+
+      UINT_MAX = 2**256 - 1
+      UINT_MIN = 0
+      INT_MAX = 2**255 - 1
+      INT_MIN = -2**255
+
+      HASH_ZERO = ("\x00"*32).freeze
+
+      PUBKEY_ZERO = ("\x00"*32).freeze
+      PRIVKEY_ZERO = ("\x00"*32).freeze
+      PRIVKEY_ZERO_HEX = ('0'*64).freeze
+    end
+  end
+end

data/lib/ethereum/abi/contract_translator.rb

@@ -0,0 +1,184 @@
+# -*- encoding : ascii-8bit -*-
+
+require 'json'
+
+module Ethereum
+  module ABI
+    class ContractTranslator
+
+      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: {}
+        }
+
+        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_constant: desc.fetch('constant', false),
+              signature: signature
+            }
+          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: 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)
+        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
+
+      ##
+      # Return the encoded constructor call.
+      #
+      def encode_constructor_arguments(args)
+        raise ValueError, "The contract interface didn't have a constructor" unless constructor_data
+
+        ABI.encode_abi constructor_data[:encode_types], args
+      end
+
+      def decode(name, data)
+        desc = function_data[name]
+        ABI.decode_abi desc[:decode_types], data
+      end
+
+      def constructor_data
+        @contract[:constructor_data]
+      end
+
+      def function_data
+        @contract[:function_data]
+      end
+
+      def event_data
+        @contract[:event_data]
+      end
+
+      def function(name)
+        function_data[name]
+      end
+
+      def event(name, encode_types)
+        event_data[event_id(name, encode_types)]
+      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
+
+      def event_id(name, encode_types)
+        Utils.big_endian_to_int Utils.keccak256(get_sig(name, encode_types))
+      end
+
+      private
+
+      def logger
+        @logger ||= Logger.new 'eth.abi.contract_translator'
+      end
+
+      def get_sig(name, encode_types)
+        "#{name}(#{encode_types.map {|x| canonical_name(x) }.join(',')})"
+      end
+
+      def canonical_name(x)
+        case x
+        when /\A(uint|int)(\[.*\])?\z/
+          "#{$1}256#{$2}"
+        when /\A(real|ureal|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

data/lib/ethereum/abi/type.rb

@@ -0,0 +1,117 @@
+# -*- encoding : ascii-8bit -*-
+
+module Ethereum
+  module ABI
+    class Type
+
+      class ParseError < StandardError; end
+
+      class <<self
+        ##
+        # Crazy regexp to seperate out base type component (eg. uint), size (eg.
+        # 256, 128x128, nil), array component (eg. [], [45], nil)
+        #
+        def parse(type)
+          _, base, sub, dimension = /([a-z]*)([0-9]*x?[0-9]*)((\[[0-9]*\])*)/.match(type).to_a
+
+          dims = dimension.scan(/\[[0-9]*\]/)
+          raise ParseError, "Unknown characters found in array declaration" if dims.join != dimension
+
+          case base
+          when 'string'
+            raise ParseError, "String type must have no suffix or numerical suffix" unless sub.empty?
+          when 'bytes'
+            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/
+
+            size = sub.to_i
+            raise ParseError, "Integer size out of bounds" unless size >= 8 && size <= 256
+            raise ParseError, "Integer size must be multiple of 8" unless size % 8 == 0
+          when 'ureal', 'real', 'fixed', 'ufixed'
+            raise ParseError, "Real type must have suffix of form <high>x<low>, e.g. 128x128" unless sub =~ /\A[0-9]+x[0-9]+\z/
+
+            high, low = sub.split('x').map(&:to_i)
+            total = high + low
+
+            raise ParseError, "Real size out of bounds (max 32 bytes)" unless total >= 8 && total <= 256
+            raise ParseError, "Real high/low sizes must be multiples of 8" unless high % 8 == 0 && low % 8 == 0
+          when 'hash'
+            raise ParseError, "Hash type must have numerical suffix" unless sub =~ /\A[0-9]+\z/
+          when 'address'
+            raise ParseError, "Address cannot have suffix" unless sub.empty?
+          when 'bool'
+            raise ParseError, "Bool cannot have suffix" unless sub.empty?
+          else
+            raise ParseError, "Unrecognized type base: #{base}"
+          end
+
+          new(base, sub, dims.map {|x| x[1...-1].to_i })
+        end
+
+        def size_type
+          @size_type ||= new('uint', 256, [])
+        end
+      end
+
+      attr :base, :sub, :dims
+
+      ##
+      # @param base [String] base name of type, e.g. uint for uint256[4]
+      # @param sub  [String] subscript of type, e.g. 256 for uint256[4]
+      # @param dims [Array[Integer]] dimensions of array type, e.g. [1,2,0]
+      #   for uint256[1][2][], [] for non-array type
+      #
+      def initialize(base, sub, dims)
+        @base = base
+        @sub  = sub
+        @dims = dims
+      end
+
+      def ==(another_type)
+        base == another_type.base &&
+          sub == another_type.sub &&
+          dims == another_type.dims
+      end
+
+      ##
+      # Get the static size of a type, or nil if dynamic.
+      #
+      # @return [Integer, NilClass]  size of static type, or nil for dynamic
+      #   type
+      #
+      def size
+        @size ||= if dims.empty?
+                    if %w(string bytes).include?(base) && sub.empty?
+                      nil
+                    else
+                      32
+                    end
+                  else
+                    if dims.last == 0 # 0 for dynamic array []
+                      nil
+                    else
+                      subtype.dynamic? ? nil : dims.last * subtype.size
+                    end
+                  end
+      end
+
+      def dynamic?
+        size.nil?
+      end
+
+      ##
+      # Type with one dimension lesser.
+      #
+      # @example
+      #   Type.parse("uint256[2][]").subtype # => Type.new('uint', 256, [2])
+      #
+      # @return [Ethereum::ABI::Type]
+      #
+      def subtype
+        @subtype ||= self.class.new(base, sub, dims[0...-1])
+      end
+
+    end
+  end
+end

data/lib/ethereum/abi/version.rb

@@ -0,0 +1,5 @@
+module Ethereum
+  module ABI
+    VERSION = "0.0.1"
+  end
+end

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: ethereum-abi
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Zhang.Ya.Ning
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-08-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ethereum-base
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.4
+- !ruby/object:Gem::Dependency
+  name: block_logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+- !ruby/object:Gem::Dependency
+  name: rlp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.3
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.5'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 5.8.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 5.8.3
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.7.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.7.6
+description: Ethereum ABI implementation in ruby.
+email:
+- zhangyaning1985@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/ethereum/abi.rb
+- lib/ethereum/abi/constant.rb
+- lib/ethereum/abi/contract_translator.rb
+- lib/ethereum/abi/type.rb
+- lib/ethereum/abi/version.rb
+homepage: https://github.com/u2/ethereum-abi
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Ethereum ABI, ruby version.
+test_files: []
+has_rdoc: