abicoder 0.1.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3bc1e75e6080a55ae3447f7cfd3630ed587edf021658dd9159584fbb3ef28743
-  data.tar.gz: 84d27e90d278d0c2fc84db605005735164b4a63c084c087777218eadadb0044b
+  metadata.gz: f6aed5c766df24d4cf394f10fdaec00a7a42375cf85c5eab0a07d8f7f22ad3ec
+  data.tar.gz: 80c9a39735f1e383f168fdca5980d66acbf039a2bfbffe15866f0fb89a7090cf
 SHA512:
-  metadata.gz: 597f54c3c8e21027bb10d326c7c6763653d752ad3285abc1c2086023d17c6dc9207d8e99f16a008265bff3a2ad61e1f261db501911c46df56a509660102dc019
-  data.tar.gz: b776e32b5afd57e233aef6ffb87dba66b65272533f60f635c371e0a199fad593a1bd55cd6248f39a3002849b66e77ecf1bb7bd06f3ccc453cc87854d0c77d059
+  metadata.gz: 9142a552978835f45a2be5bd80190905b9feeb519f135c8ae72f428826a2e7ccec467a1dbbfbfef8ddd2b097b1397f008429379230abc8ac6bcaf4aa53f7ec99
+  data.tar.gz: 37a0e2773d33a8c74881ccd8ab137e362dacde34c6dd076be0eed6ffe5b22f302ac8cdd2220e94ed124b5036a836b21b7977c0629daf9e749c45b2465e4aab47

data/README.md

@@ -1,6 +1,6 @@
 #  Application Binary Inteface (ABI) Coder For Ethereum & Co.
 
-abicoder - "lite" application binary interface (abi) encoding / decoding machinery / helper for Ethereum & Co. (blockchain) contracts with zero-dependencies for easy (re)use
+abicoder - "lite" application binary interface (abi) encoding / decoding machinery / helper (incl. nested arrays and/or tuples) for Ethereum & Co. (blockchain) contracts with zero-dependencies for easy (re)use
 
 
 * home  :: [github.com/rubycocos/blockchain](https://github.com/rubycocos/blockchain)

data/Rakefile

@@ -13,7 +13,7 @@ Hoe.spec 'abicoder' do
 
   self.version = ABICoder::VERSION
 
-  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.summary = "abicoder - 'lite' application binary interface (abi) encoding / decoding machinery / helper (incl. nested arrays and/or tuples) 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/decoder.rb

@@ -7,6 +7,10 @@ class Decoder
     # Decodes multiple arguments using the head/tail mechanism.
     #
     def decode( types, data, raise_errors = false )
+       ##
+       ##  todo/check:  always change data (string) to binary encoding (e.g. data = data.b )
+       ##                    or such - why? why not?
+
       ## for convenience check if types is a String
       ##   otherwise assume ABI::Type already
       types = types.map { |type| type.is_a?( Type ) ? type : Type.parse( type ) }
@@ -14,7 +18,9 @@ class Decoder
       outputs = [nil] * types.size
       start_positions = [nil] * types.size + [data.size]
 
-      # TODO: refactor, a reverse iteration will be better
+      # TODO: refactor, a reverse iteration will be better - why? why not?
+      #   try to simplify / clean-up code - possible? why? why not?
+
       pos = 0
       types.each_with_index do |t, i|
         # If a type is static, grab the data directly, otherwise record its
@@ -29,7 +35,7 @@ class Decoder
             end
           end
 
-          start_positions[i] = big_endian_to_int(data[pos, 32])
+          start_positions[i] = decode_uint256(data[pos, 32])
 
           if start_positions[i]>data.size-1
             if raise_errors
@@ -50,7 +56,19 @@ class Decoder
         else
           ## puts "step 1 - decode item [#{i}] - #{t.format}  size: #{t.size} dynamic? #{t.dynamic?}"
 
-          outputs[i] = zero_padding( data, pos, t.size, start_positions )
+          count = t.size
+          ## was zero_padding( data, pos, t.size, start_positions )
+          ##   inline for now and clean-up later - why? why not?
+          outputs[i] = if pos >= data.size
+                          start_positions[start_positions.size-1] += count
+                          BYTE_ZERO*count
+                        elsif pos + count > data.size
+                          start_positions[start_positions.size-1] += ( count - (data.size-pos))
+                          data[pos,data.size-pos] + BYTE_ZERO*( count - (data.size-pos))
+                        else
+                          data[pos, count]
+                        end
+
           pos += t.size
         end
       end
@@ -83,7 +101,7 @@ class Decoder
         end
       end
 
-      if outputs.include?(nil)
+      if outputs.include?( nil )
         if raise_errors
           raise DecodingError, "Not all data can be parsed"
         else
@@ -101,106 +119,87 @@ class Decoder
 
 
 
-    def decode_type( type, arg )
-      return nil    if arg.nil? || arg.empty?
 
+    def decode_type( type, data )
+      return nil    if data.nil? || data.empty?
 
-      if type.is_a?( String ) || type.is_a?( Bytes )
-        l = big_endian_to_int( arg[0,32] )
-        data = arg[32..-1]
-        data[0, l]
-      elsif type.is_a?( Tuple )
-          arg ? decode(type.types, arg) : []
+      if type.is_a?( Tuple )   ## todo: support empty (unit) tuple - why? why not?
+          decode( type.types, data )
       elsif type.is_a?( FixedArray )   # static-sized arrays
         l       = type.dim
         subtype = type.subtype
         if subtype.dynamic?
-          start_positions = (0...l).map {|i| big_endian_to_int(arg[32*i, 32]) }
-          start_positions.push arg.size
+          start_positions = (0...l).map {|i| decode_uint256(data[32*i, 32]) }
+          start_positions.push( data.size )
 
-          outputs = (0...l).map {|i| arg[start_positions[i]...start_positions[i+1]] }
+          outputs = (0...l).map {|i| data[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]) }
+          (0...l).map {|i| decode_type(subtype, data[subtype.size*i, subtype.size]) }
         end
       elsif type.is_a?( Array )
-        l = big_endian_to_int( arg[0,32] )
+        l = decode_uint256( data[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
+          raise DecodingError, "Not enough data for head" unless data.size >= 32 + 32*l
 
-          start_positions = (1..l).map {|i| 32+big_endian_to_int(arg[32*i, 32]) }
-          start_positions.push arg.size
+          start_positions = (1..l).map {|i| 32+decode_uint256(data[32*i, 32]) }
+          start_positions.push( data.size )
 
-          outputs = (0...l).map {|i| arg[start_positions[i]...start_positions[i+1]] }
+          outputs = (0...l).map {|i| data[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]) }
+          (0...l).map {|i| decode_type(subtype, data[32 + subtype.size*i, subtype.size]) }
         end
       else
-        decode_primitive_type( type, arg )
+        decode_primitive_type( type, data )
       end
     end
 
 
     def decode_primitive_type(type, data)
       case type
-      when Address
-        encode_hex( data[12..-1] )
-      when String, Bytes
-          if data.length == 32
-            data[0..32]
-          else
-            size = big_endian_to_int( data[0,32] )
-            data[32..-1][0,size]
-          end
-      when FixedBytes
-          data[0, type.length]
       when Uint
-        big_endian_to_int( data )
+        decode_uint256( data )
       when Int
-        u = big_endian_to_int( data )
+        u = decode_uint256( data )
         u >= 2**(type.bits-1) ? (u - 2**type.bits) : u
       when Bool
         data[-1] == BYTE_ONE
+      when String
+        ## note: convert to a string (with UTF_8 encoding NOT BINARY!!!)
+        size = decode_uint256( data[0,32] )
+        data[32..-1][0,size].force_encoding( Encoding::UTF_8 )
+      when Bytes
+        size = decode_uint256( data[0,32] )
+        data[32..-1][0,size]
+      when FixedBytes
+        data[0, type.length]
+      when Address
+        ## note: convert to a hex string (with UTF_8 encoding NOT BINARY!!!)
+        data[12..-1].unpack("H*").first.force_encoding( Encoding::UTF_8 )
       else
         raise DecodingError, "Unknown primitive type: #{type.class.name} #{type.format}"
       end
     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
-
 
 ###########
 #  decoding helpers / utils
 
-def big_endian_to_int( bin )
-  bin = bin.sub( /\A(\x00)+/, '' )   ## keep "performance" shortcut - why? why not?
+def decode_uint256( bin )
+  # bin = bin.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
-  bin = bin || BYTE_ZERO
+  # bin = bin || BYTE_ZERO
   bin.unpack("H*").first.to_i(16)
 end
 
-def encode_hex( bin )   ## bin_to_hex
-  raise TypeError, "Value must be a String" unless bin.is_a?(::String)
-  bin.unpack("H*").first
-end
 
 
 end  # class Decoder

data/lib/abicoder/encoder.rb

@@ -18,11 +18,11 @@ class Encoder
 
     ##
     # Encodes multiple arguments using the head/tail mechanism.
+    #     returns binary string (with BINARY / ASCII_8BIT encoding)
     #
     def encode( types, args )
-
-      ## todo/fix:  enforce args.size and types.size must match!!
-      ##   raise ArgumentError - expected x arguments got y!!!
+      ## enforce args.size and types.size must match - why? why not?
+      raise ArgumentError, "Wrong number of args: found #{args.size}, expecting #{types.size}" unless args.size == types.size
 
 
       ## for convenience check if types is a String
@@ -35,7 +35,7 @@ class Encoder
                     .map {|type| type.size || 32 }
                     .sum
 
-      head, tail = '', ''
+      head, tail = ''.b, ''.b    ## note: use string buffer with BINARY / ASCII_8BIT encoding!!!
       types.each_with_index do |type, i|
         if type.dynamic?
           head += encode_uint256( head_size + tail.size )
@@ -57,10 +57,6 @@ class Encoder
     # @return [String] encoded bytes
     #
     def encode_type( type, arg )
-      ## case 1)  string or bytes (note:are dynamic too!!! most go first)
-      ##  use type == Type.new( 'string', nil, [] ) - same as Type.new('string'))
-      ##   or type == Type.new( 'bytes', nil, [] )  - same as Type.new('bytes')
-      ##   - why? why not?
       if type.is_a?( String )
         encode_string( arg )
       elsif type.is_a?( Bytes )
@@ -82,7 +78,7 @@ class Encoder
    def encode_dynamic_array( type, args )
     raise ArgumentError, "arg must be an array" unless args.is_a?(::Array)
 
-        head, tail = '', ''
+        head, tail = ''.b, ''.b    ## note: use string buffer with BINARY / ASCII_8BIT encoding!!!
 
         if type.is_a?( Array )  ## dynamic array
           head += encode_uint256( args.size )
@@ -123,7 +119,7 @@ class Encoder
                      .map {|type| type.size || 32 }
                      .sum
 
-        head, tail = '', ''
+        head, tail = ''.b, ''.b    ## note: use string buffer with BINARY / ASCII_8BIT encoding!!!
         tuple.types.each_with_index do |type, i|
           if type.dynamic?
             head += encode_uint256( head_size + tail.size )
@@ -164,19 +160,22 @@ class Encoder
 
 
     def encode_bool( arg )
+      ## raise EncodingError or ArgumentError - why? why not?
       raise ArgumentError, "arg is not bool: #{arg}" unless arg.is_a?(TrueClass) || arg.is_a?(FalseClass)
-      lpad_int( arg ? 1 : 0 )
+      lpad( arg ? BYTE_ONE : BYTE_ZERO )   ## was  lpad_int( arg ? 1 : 0 )
     end
 
 
     def encode_uint256( arg ) encode_uint( arg, 256 ); end
     def encode_uint( arg, bits )
+      ## raise EncodingError or ArgumentError - why? why not?
       raise ArgumentError, "arg is not integer: #{arg}" unless arg.is_a?(Integer)
       raise ValueOutOfBounds, arg   unless arg >= 0 && arg < 2**bits
       lpad_int( arg )
     end
 
     def encode_int( arg, bits )
+      ## raise EncodingError or ArgumentError - why? why not?
       raise ArgumentError, "arg is not integer: #{arg}" unless arg.is_a?(Integer)
       raise ValueOutOfBounds, arg   unless arg >= -2**(bits-1) && arg < 2**(bits-1)
       lpad_int( arg % 2**bits )
@@ -184,31 +183,21 @@ class Encoder
 
 
     def encode_string( arg )
-
-       ## todo/fix:  do NOT auto-unpack hexstring EVER!!!
-       ##                remove  arg.unpack('U*')
-
-      if arg.encoding == Encoding::UTF_8    ## was: name == 'UTF-8'
-        arg = arg.b
-      else
-        begin
-          arg.unpack('U*')
-        rescue ArgumentError
-          raise ValueError, "string must be UTF-8 encoded"
-        end
-      end
+      ## raise EncodingError or ArgumentError - why? why not?
+      raise EncodingError, "Expecting string: #{arg}" unless arg.is_a?(::String)
+      arg = arg.b   if arg.encoding != Encoding::BINARY    ## was: name == 'UTF-8'
 
       raise ValueOutOfBounds, "Integer invalid or out of range: #{arg.size}" if arg.size > UINT_MAX
       size  =  lpad_int( arg.size )
       value =  rpad( arg, ceil32(arg.size) )
-
       size + value
     end
 
 
     def encode_bytes( arg, length=nil )
+      ## raise EncodingError or ArgumentError - why? why not?
       raise EncodingError, "Expecting string: #{arg}" unless arg.is_a?(::String)
-      arg = arg.b
+      arg = arg.b    if arg.encoding != Encoding::BINARY
 
       if length # fixed length type
         raise ValueOutOfBounds, "invalid bytes length #{length}" if arg.size > length
@@ -227,6 +216,8 @@ class Encoder
       if arg.is_a?( Integer )
         lpad_int( arg )
       elsif arg.size == 20
+        ## note: make sure encoding is always binary!!!
+        arg = arg.b    if arg.encoding != Encoding::BINARY
         lpad( arg )
       elsif arg.size == 40
         lpad_hex( arg )
@@ -238,34 +229,42 @@ class Encoder
     end
 
 
+
 ###########
 #  encoding helpers / utils
+#    with "hard-coded" fill symbol as BYTE_ZERO
 
-def rpad( bin, l=32, symbol=BYTE_ZERO )    ## note: same as builtin String#ljust !!!
+def rpad( bin, l=32 )    ## note: same as builtin String#ljust !!!
+  # note: default l word is 32 bytes
   return bin  if bin.size >= l
-  bin + symbol * (l - bin.size)
+  bin + BYTE_ZERO * (l - bin.size)
 end
 
-def lpad( bin, l=32, symbol=BYTE_ZERO )    ## note: same as builtin String#rjust !!!
+
+## rename to lpad32 or such - why? why not?
+def lpad( bin )    ## note: same as builtin String#rjust !!!
+  l=32   # note: default l word is 32 bytes
   return bin  if bin.size >= l
-  symbol * (l - bin.size) + bin
+  BYTE_ZERO * (l - bin.size) + bin
 end
 
-def lpad_int( n, l=32, symbol=BYTE_ZERO )
+## rename to lpad32_int or such - why? why not?
+def lpad_int( n )
   raise ArgumentError, "Integer invalid or out of range: #{n}" unless n.is_a?(Integer) && n >= 0 && n <= UINT_MAX
   hex = n.to_s(16)
   hex = "0#{hex}"   if hex.size.odd?
   bin = [hex].pack("H*")
 
-  lpad( bin, l, symbol )
+  lpad( bin )
 end
 
-def lpad_hex( hex, l=32, symbol=BYTE_ZERO )
+## rename to lpad32_hex or such - why? why not?
+def lpad_hex( hex )
   raise TypeError, "Value must be a string"  unless hex.is_a?( ::String )
   raise TypeError, 'Non-hexadecimal digit found' unless hex =~ /\A[0-9a-fA-F]*\z/
   bin = [hex].pack("H*")
 
-  lpad( bin, l, symbol )
+  lpad( bin )
 end
 
 

data/lib/abicoder/version.rb

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

data/lib/abicoder.rb

@@ -13,7 +13,7 @@ module ABI
    ## 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_EMPTY = "".b.freeze
    BYTE_ZERO  = "\x00".b.freeze
    BYTE_ONE   = "\x01".b.freeze      ## note: used for encoding bool for now
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: abicoder
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-04 00:00:00.000000000 Z
+date: 2023-01-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdoc
@@ -45,8 +45,8 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.23'
 description: abicoder - 'lite' application binary interface (abi) encoding / decoding
-  machinery / helper for Ethereum & Co. (blockchain) contracts with zero-dependencies
-  for easy (re)use
+  machinery / helper (incl. nested arrays and/or tuples) for Ethereum & Co. (blockchain)
+  contracts with zero-dependencies for easy (re)use
 email: wwwmake@googlegroups.com
 executables: []
 extensions: []
@@ -90,6 +90,6 @@ rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: abicoder - 'lite' application binary interface (abi) encoding / decoding
-  machinery / helper for Ethereum & Co. (blockchain) contracts with zero-dependencies
-  for easy (re)use
+  machinery / helper (incl. nested arrays and/or tuples) for Ethereum & Co. (blockchain)
+  contracts with zero-dependencies for easy (re)use
 test_files: []