abicoder 0.1.0 → 0.1.1

data/lib/abicoder/codec.rb

@@ -1,413 +0,0 @@
-
-module ABI
-  ##
-  # Contract ABI encoding and decoding.
-  #
-  # @see https://github.com/ethereum/wiki/wiki/Ethereum-Contract-ABI
-  #
-  class Codec
-    class EncodingError < StandardError; end
-    class DecodingError < StandardError; end
-    class ValueError < StandardError; end
-
-    class ValueOutOfBounds < ValueError; end
-
-    ##
-    # Encodes multiple arguments using the head/tail mechanism.
-    #
-    def encode_abi(types, args)
-      ## for convenience check if types is a String
-      ##   otherwise assume ABI::Type already
-      types = types.map { |type| type.is_a?( String ) ? Type.parse( type ) : type }
-
-      head_size = (0...args.size)
-        .map {|i| types[i].size || 32 }
-        .reduce(0, &:+)
-
-      head, tail = '', ''
-      args.each_with_index do |arg, i|
-        if types[i].dynamic?
-          head += encode_type(Type.size_type, head_size + tail.size)
-          tail += encode_type(types[i], arg)
-        else
-          head += encode_type(types[i], arg)
-        end
-      end
-
-      "#{head}#{tail}"
-    end
-
-    ##
-    # Encodes a single value (static or dynamic).
-    #
-    # @param type [ABI::Type] value type
-    # @param arg [Object] value
-    #
-    # @return [String] encoded bytes
-    #
-    def encode_type(type, arg)
-      if ['string', 'bytes'].include?(type.base) && type.sub.empty?
-        encode_primitive_type type, arg
-      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'
-        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)
-      when 'int'
-        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 '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
-          value = Utils.rpad arg, BYTE_ZERO, Utils.ceil32(arg.size)
-          "#{size}#{value}"
-        else # fixed length type
-          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
-
-        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 '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
-
-
-    def min_data_size( types )
-      types.size*32
-    end
-
-    ##
-    # Decodes multiple arguments using the head/tail mechanism.
-    #
-    def decode_abi( types, data, raise_errors = false )
-      ## for convenience check if types is a String
-      ##   otherwise assume ABI::Type already
-      types = types.map { |type| type.is_a?( String ) ? Type.parse( type ) : type }
-
-      outputs = [nil] * types.size
-      start_positions = [nil] * types.size + [data.size]
-
-      # TODO: refactor, a reverse iteration will be better
-      pos = 0
-      types.each_with_index do |t, i|
-        # 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]
-            j -= 1
-          end
-
-          pos += 32
-        else
-          outputs[i] = zero_padding data, pos, t.size, start_positions
-          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
-
-      if raise_errors && pos > data.size
-        raise DecodingError, "Not enough data for head"
-      end
-
-
-      types.each_with_index do |t, i|
-        if t.dynamic?
-          offset, next_offset = start_positions[i, 2]
-          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
-
-      types.zip(outputs).map {|(type, out)| decode_type(type, out) }
-    end
-
-
-    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)
-      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.dims.empty? && (l = type.dims.last)>0 # static-sized arrays
-        subtype = type.subtype
-        if subtype.dynamic?
-          start_positions = (0...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[subtype.size*i, subtype.size]) }
-        end
-
-      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| 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]] }
-
-          outputs.map {|out| decode_type(subtype, out) }
-        else
-          (0...l).map {|i| decode_type(subtype, arg[32 + subtype.size*i, subtype.size]) }
-        end
-
-      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
-          if data.length==32
-            data[0..32]
-          else
-            size = Utils.big_endian_to_int data[0,32]
-            data[32..-1][0,size]
-          end
-        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 'ufixed'
-        high, low = type.sub.split('x').map(&:to_i)
-        Utils.big_endian_to_int(data) * 1.0 / 2**low
-      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
-        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
-        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
-        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
-        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
-        0
-      else
-        raise EncodingError, "Cannot decode int: #{n}"
-      end
-    end
-end # class Codec
-
-
-
-def self.codec
-  @codec ||= Codec.new
-end
-
-def self.encode_abi( types, args )
-    codec.encode_abi( types, args )
-end
-
-def self.decode_abi( types, data, raise_errors = false )
-    codec.decode_abi( types, data, raise_errors )
-end
-
-## add alternate names
-##  todo/fix: change to encode / decode by default
-##              from encode_abi / decode_abi  - why? why not?
-class << self
-   alias_method :encode, :encode_abi
-   alias_method :decode, :decode_abi
-end
-
-end  # module ABI
-

data/lib/abicoder/type.rb

@@ -1,141 +0,0 @@
-module ABI
-class Type
-
-  class ParseError < StandardError; end
-
-  ##
-  # Crazy regexp to seperate out base type component (eg. uint), size (eg.
-  # 256, 128, nil), array component (eg. [], [45], nil)
-  #
-  BASE_TYPE_RX = /([a-z]*)
-                  ([0-9]*)
-                  ((\[[0-9]*\])*)
-                 /x
-
-  def self._parse_base_type( str )
-    _, base, sub, dimension = BASE_TYPE_RX.match( str ).to_a
-
-    dims = dimension.scan( /\[[0-9]*\]/ )
-    if dims.join != dimension
-      raise ParseError, "Unknown characters found in array declaration"
-    end
-
-    dims = dims.map {|x| x[1...-1].to_i }
-
-    [base, sub, dims]
-  end
-
-
-
-    TUPLE_TYPE_RX = /^\((.*)\)
-                    ((\[[0-9]*\])*)
-                  /x
-
-  def self.parse( type )
-        if type =~ TUPLE_TYPE_RX
-              types = $1
-              dims  = $2.scan( /\[[0-9]*\]/ )
-              dims  = dims.map {|x| x[1...-1].to_i}
-          return Tuple._parse( types, dims )
-        end
-
-
-       base, sub, dims = _parse_base_type( type )
-
-        case base
-          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/
-
-            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 'address'
-            raise ParseError, "Address cannot have suffix" unless sub.empty?
-          when 'bool'
-            raise ParseError, "Bool cannot have suffix" unless sub.empty?
-          else
-            puts "  type: >#{type}<"
-            raise ParseError, "Unrecognized type base: #{base}"
-        end
-
-        new( base, sub, dims )
-      end
-
-
-      def self.size_type
-        @size_type ||= new( 'uint', '256' )
-      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 ||= calculate_size
-    end
-
-    def calculate_size
-               if @dims.empty?
-                  if ['string','bytes'].include?( @base ) && @sub.empty?
-                    nil
-                  else
-                    32
-                  end
-                else
-                  if @dims.last == 0    # note: 0 used 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 [ABI::Type]
-    #
-    def subtype
-      @subtype ||= Type.new( @base, @sub, @dims[0...-1] )
-    end
-
-
-    def format
-      ## rebuild minimal type string
-      buf = "#{@base}"
-      buf << @sub  unless @sub.empty?
-      buf << (@dims.map {|dim| dim==0 ? '[]' : "[#{dim}]"}.join)   unless @dims.empty?
-      buf
-    end
-end   # class Type
-end  # module ABI

data/lib/abicoder/type_tuple.rb

@@ -1,106 +0,0 @@
-module ABI
-
-
-class Tuple < Type
-
-    def self._parse_tuple_type( str )
-      ## note: types assumes string WITHOUT enclosing () e.g.
-      ##  tuple(string,string,bool)  =>  expected as "string,string,bool"
-
-      depth     = 0
-      collected = []
-      current   = ''
-
-      ### todo/fix: replace with a simple parser!!!
-      ##    allow  () and move verbose tuple() too!!!
-      str.each_char 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?
-
-      collected
-    end
-
-
-    ## note:  use Type.parse NOT Tuple._parse
-    ##           to parse Tuple!!!
-    def self._parse( tuple, dims=[] )
-      ## puts "  enter Tuple.parse( types: >#{tuple.inspect}<, dims: >#{dims.inspect}< )"
-
-      # e.g.
-      #=>   enter Tuple.parse( types: >"string,string,bool"<, dims: >[]< )
-      types        = _parse_tuple_type( tuple )
-      parsed_types = types.map{ |t| Type.parse( t ) }
-
-      Tuple.new( parsed_types, dims )
-    end
-
-
-
-    attr_reader :types
-
-    def initialize( types, dims=[] )
-      super( 'tuple', '', dims )
-      @types = types
-
-      ## puts "tuple:"
-      ## pp self
-    end
-
-
-    def ==(another_type)
-      another_type.kind_of?(Tuple) &&
-        @types == another_type.types  &&
-        @dims  == another_type.dims
-    end
-
-    def size
-      @size ||= calculate_size
-    end
-
-    def calculate_size
-      if @dims.empty?
-        s = 0
-        @types.each do |type|
-          ts = type.size
-          return nil if ts.nil?
-          s += ts
-        end
-        s
-      else
-        if @dims.last == 0     # note:  0 used 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
-
-    def format
-      ## rebuild minimal string
-      buf = "(#{@types.map {|t| t.format }.join(',')})"
-    end
-
-
-end  # class Tuple
-end  ## module ABI