abicoder 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 45fa5adeeafa44036fa386f4ab36d3f822e5f91706423d578ea822e0d6fc01a8
-  data.tar.gz: 8430f2cdfeed351cee319596152b3c6d23ae506d6a51823ac909175df264eaff
+  metadata.gz: 23ce318ecd9bff53b9586cb30f15aac0f405991baae8ed3823fd8a1f1e357ca6
+  data.tar.gz: 4760a854236914e5d4fe42db0ced4f51bad4a7132fe14fe813f02af3f99043ca
 SHA512:
-  metadata.gz: 4bb46c9aa7376a6d3ff7a0ed76b51c60b6068e9705ed8b7ce2980d89dc1a38e7331ffd3681e616264138d7f0d9819cf7981d4a26c323a7fef0ec42792c956c9e
-  data.tar.gz: 97ea5904ab15a98eea02f3a62d123c674bd34145828d04b93853dc615cf07031556143b6f51d4fa484a1b33479d26c7a6a1916acbb2df6dd503d4629e1dacac8
+  metadata.gz: 82f6dfb3fb1f7eb2cb5352196d7a33476da85a684a93d72785ee37ca47af712f2864b46ddfbe6bc7bac76be3c0cb6f152620e0de9e883f8eaff44f12b57b9241
+  data.tar.gz: 3ca6cdc5aaabb5bfaa4c13aff8f5daaba0880e5b3c33e4ada1aa02053617a20e0681e27bf8f2a6451919d5233923c5ca69fe97a0bd4bafb3aa6cbbecf5405ee4

data/Manifest.txt

@@ -3,4 +3,8 @@ Manifest.txt
 README.md
 Rakefile
 lib/abicoder.rb
+lib/abicoder/codec.rb
+lib/abicoder/type.rb
+lib/abicoder/type_tuple.rb
+lib/abicoder/utils.rb
 lib/abicoder/version.rb

data/README.md

@@ -1,6 +1,6 @@
 #  Application Binary Inteface (ABI) Coder For Ethereum & Co.
 
-abicoder - application binary interface (abi) encoding / decoding machinery / helper for Ethereum & Co. (blockchain) contracts
+abicoder - "lite" application binary interface (abi) encoding / decoding machinery / helper for Ethereum & Co. (blockchain) contracts with zero-dependencies for easy (re)use
 
 
 * home  :: [github.com/rubycocos/blockchain](https://github.com/rubycocos/blockchain)
@@ -12,7 +12,67 @@ abicoder - application binary interface (abi) encoding / decoding machinery / he
 
 ## Usage
 
-To be done
+
+``` ruby
+require 'abicode'
+
+#####
+#  try ABI.encode
+
+##  Encoding simple types
+ABI.encode( [ 'uint256', 'string' ],
+               [ 1234, 'Hello World' ]).hexdigest
+#=> "00000000000000000000000000000000000000000000000000000000000004d2"+
+#   "0000000000000000000000000000000000000000000000000000000000000040"+
+#   "000000000000000000000000000000000000000000000000000000000000000b"+
+#   "48656c6c6f20576f726c64000000000000000000000000000000000000000000"
+
+## Encoding with arrays types
+ABI.encode([ 'uint256[]', 'string' ],
+              [ [1234, 5678] , 'Hello World' ]).hexdigest
+#=> "0000000000000000000000000000000000000000000000000000000000000040"+
+#   "00000000000000000000000000000000000000000000000000000000000000a0"+
+#   "0000000000000000000000000000000000000000000000000000000000000002"+
+#   "00000000000000000000000000000000000000000000000000000000000004d2"+
+#   "000000000000000000000000000000000000000000000000000000000000162e"+
+#   "000000000000000000000000000000000000000000000000000000000000000b"+
+#   "48656c6c6f20576f726c64000000000000000000000000000000000000000000"
+
+
+#####
+#  try ABI.decode
+
+##  Decoding simple types
+data = hex'00000000000000000000000000000000000000000000000000000000000004d2'+
+          '0000000000000000000000000000000000000000000000000000000000000040'+
+          '000000000000000000000000000000000000000000000000000000000000000b'+
+          '48656c6c6f20576f726c64000000000000000000000000000000000000000000'
+ABI.decode([ 'uint256', 'string' ], data)
+#=>  [1234, "Hello World"]
+
+
+##  Decoding with arrays types
+data = hex'0000000000000000000000000000000000000000000000000000000000000040'+
+          '00000000000000000000000000000000000000000000000000000000000000a0'+
+          '0000000000000000000000000000000000000000000000000000000000000002'+
+          '00000000000000000000000000000000000000000000000000000000000004d2'+
+          '000000000000000000000000000000000000000000000000000000000000162e'+
+          '000000000000000000000000000000000000000000000000000000000000000b'+
+          '48656c6c6f20576f726c64000000000000000000000000000000000000000000'
+ABI.decode([ 'uint256[]', 'string' ], data )
+#=>  [[1234, 5678], "Hello World"]
+
+
+## Decoding complex structs (also known as tuples)
+data = hex'00000000000000000000000000000000000000000000000000000000000004d2'+
+          '0000000000000000000000000000000000000000000000000000000000000040'+
+          '000000000000000000000000000000000000000000000000000000000000162e'+
+          '0000000000000000000000000000000000000000000000000000000000000040'+
+          '000000000000000000000000000000000000000000000000000000000000000b'+
+          '48656c6c6f20576f726c64000000000000000000000000000000000000000000'
+ABI.decode([ 'uint256', '(uint256,string)'], data)
+#=> [1234, [5678, "Hello World"]]
+```
 
 
 

data/Rakefile

@@ -2,11 +2,18 @@ require 'hoe'
 require './lib/abicoder/version.rb'
 
 
+###
+# hack/ quick fix for broken intuit_values - overwrite with dummy
+class Hoe
+  def intuit_values( input ); end
+end
+
+
 Hoe.spec 'abicoder' do
 
   self.version = ABICoder::VERSION
 
-  self.summary = "abicoder - application binary interface (abi) encoding / decoding machinery / helper for Ethereum & Co. (blockchain) contracts"
+  self.summary = "abicoder - 'lite' application binary interface (abi) encoding / decoding machinery / helper for Ethereum & Co. (blockchain) contracts with zero-dependencies for easy (re)use"
   self.description = summary
 
   self.urls    = { home: 'https://github.com/rubycocos/blockchain' }

data/lib/abicoder/codec.rb

@@ -0,0 +1,413 @@
+
+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

@@ -0,0 +1,141 @@
+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

@@ -0,0 +1,106 @@
+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

data/lib/abicoder/utils.rb

@@ -0,0 +1,81 @@
+module ABI
+module Helpers
+
+########################
+#  encoding / decoding helpers
+
+def lpad(x, symbol, l)
+  return x if x.size >= l
+  symbol * (l - x.size) + x
+end
+
+def rpad(x, symbol, l)
+  return x if x.size >= l
+  x + symbol * (l - x.size)
+end
+
+def zpad(x, l)
+  lpad( x, BYTE_ZERO, l )
+end
+
+def zpad_int(n, l=32)
+  zpad( encode_int(n), l )
+end
+
+def zpad_hex(s, l=32)
+  zpad( decode_hex(s), l )
+end
+
+
+
+def big_endian_to_int(s)
+  s = s.sub( /\A(\x00)+/, '' )   ## keep "performance" shortcut - why? why not?
+  ### todo/check - allow nil - why? why not?
+  ##  raise DeserializationError, "Invalid serialization (not minimal length)" if !@size && serial.size > 0 && serial[0] == BYTE_ZERO
+  s = s || BYTE_ZERO
+  s.unpack("H*").first.to_i(16)
+end
+
+
+def int_to_big_endian(n)
+       if n == 0
+         BYTE_EMPTY
+       else
+         hex = n.to_s(16)
+         hex = "0#{hex}"   if hex.size.odd?
+
+         [hex].pack("H*")    ## note Util.hex_to_bin() "inline" shortcut
+       end
+end
+
+
+def encode_int(n)
+  raise ArgumentError, "Integer invalid or out of range: #{n}" unless n.is_a?(Integer) && n >= 0 && n <= UINT_MAX
+  int_to_big_endian( n )
+end
+
+
+def encode_hex(b)
+  raise TypeError, "Value must be an instance of String" unless b.instance_of?(String)
+  b.unpack("H*").first
+end
+
+def decode_hex(str)
+  raise TypeError, "Value must be an instance of string" unless str.instance_of?(String)
+  raise TypeError, 'Non-hexadecimal digit found' unless str =~ /\A[0-9a-fA-F]*\z/
+  [str].pack("H*")
+end
+
+def ceil32(x)
+  x % 32 == 0 ? x : (x + 32 - x%32)
+end
+end  # module Helpers
+
+
+module Utils
+  extend Helpers
+  ## e.g. Utils.encode_hex( ) etc.
+end
+
+end  # module ABI
+

data/lib/abicoder/version.rb

@@ -1,8 +1,8 @@
 
 module ABICoder
   MAJOR = 0
-  MINOR = 0
-  PATCH = 1
+  MINOR = 1
+  PATCH = 0
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 
   def self.version

data/lib/abicoder.rb

@@ -3,13 +3,43 @@
 ## our own code
 require_relative 'abicoder/version'    # note: let version always go first
 
+module ABI
+ ###################
+  ### some (shared) constants  (move to constants.rb or such - why? why not?)
 
+   ## todo/check:  use auto-freeze string literals magic comment - why? why not?
+   ##
+   ## todo/fix: move  BYTE_EMPTY, BYTE_ZERO, BYTE_ONE to upstream to bytes gem
+   ##    and make "global" constants - why? why not?
+
+   BYTE_EMPTY = "".b.freeze
+   BYTE_ZERO  = "\x00".b.freeze
+   BYTE_ONE   = "\x01".b.freeze      ## note: used for encoding bool for now
 
-module ABI
 
+   UINT_MAX = 2**256 - 1
+   UINT_MIN = 0
+   INT_MAX  = 2**255 - 1
+   INT_MIN  = -2**255
 
+
+    ### todo/check - what is TT the abbrevation for ???
+    TT32   = 2**32
+    TT40   = 2**40      ## todo/check  - used where and why???
+    TT160  = 2**160     ## todo/check  - used where and why???
+    TT256  = 2**256     ## todo/check  - used where and why???
+    TT64M1 = 2**64 - 1  ## todo/check  - used where and why???
 end  # module ABI
 
+require_relative 'abicoder/utils'
+
+
+require_relative 'abicoder/type'
+require_relative 'abicoder/type_tuple'
+
+require_relative 'abicoder/codec'
+
+
 
 
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: abicoder
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Gerald Bauer
@@ -44,8 +44,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.23'
-description: abicoder - application binary interface (abi) encoding / decoding machinery
-  / helper for Ethereum & Co. (blockchain) contracts
+description: abicoder - 'lite' application binary interface (abi) encoding / decoding
+  machinery / helper for Ethereum & Co. (blockchain) contracts with zero-dependencies
+  for easy (re)use
 email: wwwmake@googlegroups.com
 executables: []
 extensions: []
@@ -59,6 +60,10 @@ files:
 - README.md
 - Rakefile
 - lib/abicoder.rb
+- lib/abicoder/codec.rb
+- lib/abicoder/type.rb
+- lib/abicoder/type_tuple.rb
+- lib/abicoder/utils.rb
 - lib/abicoder/version.rb
 homepage: https://github.com/rubycocos/blockchain
 licenses:
@@ -84,6 +89,7 @@ requirements: []
 rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
-summary: abicoder - application binary interface (abi) encoding / decoding machinery
-  / helper for Ethereum & Co. (blockchain) contracts
+summary: abicoder - 'lite' application binary interface (abi) encoding / decoding
+  machinery / helper for Ethereum & Co. (blockchain) contracts with zero-dependencies
+  for easy (re)use
 test_files: []