abicoder 0.1.0 → 0.1.1

data/lib/abicoder/parser.rb

@@ -0,0 +1,158 @@
+module ABI
+class Type
+
+class ParseError < StandardError; end
+
+
+## nested inside Type - why? why not?
+class Parser
+
+   TUPLE_TYPE_RX = /^\((.*)\)
+                    ((\[[0-9]*\])*)
+                  /x
+
+  def self.parse( type )
+        if type =~ TUPLE_TYPE_RX
+             types   = _parse_tuple_type( $1 )
+             dims    = _parse_dims( $2 )
+
+             parsed_types = types.map{ |t| parse( t ) }
+
+             return _parse_array_type( Tuple.new( parsed_types ), dims )
+        end
+
+       base, sub, dims = _parse_base_type( type )
+
+       _validate_base_type( base, sub )
+
+       subtype =  case base
+                  when 'string'  then   String.new
+                  when 'bytes'   then   sub ? FixedBytes.new( sub ) : Bytes.new
+                  when 'uint'    then   Uint.new( sub )
+                  when 'int'     then   Int.new( sub )
+                  when 'address' then   Address.new
+                  when 'bool'    then   Bool.new
+                  else
+                    ## puts "  type: >#{type}<"
+                    raise ParseError, "Unrecognized type base: #{base}"
+                  end
+
+       _parse_array_type( subtype, dims )
+  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, subscript, dimension = BASE_TYPE_RX.match( str ).to_a
+
+      ## note:  use [Integer,Integer] array in the future for sub
+      ##          for fixed  (e.g. 128x128 => [128,128]) or such
+      ##          for now always assume single integer (as string)
+    sub = subscript == '' ? nil : subscript.to_i
+
+    ## e.g. turn "[][1][2]" into [-1,1,2]
+    ##         or ""        into  []   -- that is, empty array
+    dims = _parse_dims( dimension )
+
+    [base, sub, dims]
+  end
+
+  def self._parse_dims( str )
+    dims = str.scan( /\[[0-9]*\]/ )
+
+    ## note: return -1 for dynamic array size e.g. []
+    ##        e.g. "[]"[1...-1]  => ""
+    ##             "[0]"[1...-1]  => "0"
+    ##             "[1]"[1...-1]  => "1"
+    dims = dims.map do |dim|
+                         size = dim[1...-1]
+                         size == '' ? -1 : size.to_i
+                    end
+    dims
+  end
+
+  def self._parse_array_type( subtype, dims )
+     ##
+     ## todo/check - double check if the order in reverse
+     ##                  in solidity / abi encoding / decoding?
+     ##
+    dims.each do |dim|
+      subtype = if dim == -1
+                     Array.new( subtype )
+                else
+                     FixedArray.new( subtype, dim )
+                end
+    end
+
+    subtype
+  end
+
+
+  def self._validate_base_type( base, sub )
+    case base
+    when 'string'
+      # note: string can not have any suffix
+      raise ParseError, "String cannot have suffix"  if sub
+    when 'bytes'
+      raise ParseError, "Maximum 32 bytes for fixed-length bytes"  if sub && sub > 32
+    when 'uint', 'int'
+      raise ParseError, "Integer type must have numerical suffix"  unless sub
+      raise ParseError, "Integer size out of bounds"    unless sub >= 8 && sub <= 256
+      raise ParseError, "Integer size must be multiple of 8"  unless sub % 8 == 0
+    when 'address'
+      raise ParseError, "Address cannot have suffix"  if sub
+    when 'bool'
+      raise ParseError, "Bool cannot have suffix"   if sub
+    else
+      ## puts "  type: >#{type}<"
+      raise ParseError, "Unrecognized type base: #{base}"
+    end
+  end
+
+
+
+    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
+
+end # class Parser
+end  #  class Type
+end  # module ABI
+

data/lib/abicoder/types.rb

@@ -0,0 +1,155 @@
+module ABI
+
+
+#######
+## for now use (get inspired)
+##    by the type names used by abi coder in rust
+##      see  https://github.com/rust-ethereum/ethabi/blob/master/ethabi/src/param_type/param_type.rs
+
+
+class Type
+
+  def self.parse( type )   ## convenience helper
+    Parser.parse( type )
+  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
+    ## check/todo: what error to raise for not implemented / method not defined???
+    raise ArgumentError, "no required size method defined for Type subclass #{self.class.name}; sorry"
+  end
+  def dynamic?() size.nil?; end
+
+  def format
+    ## check/todo: what error to raise for not implemented / method not defined???
+    raise ArgumentError, "no required format method defined for Type subclass #{self.class.name}; sorry"
+  end
+
+  ####
+  ##   default implementation
+  ##    assume equal if class match (e.g. Address == Address)
+  ##    - use format string for generic compare - why? why not?
+end
+
+
+
+class Address < Type
+   def size() 32; end  ## note: address is always 20 bytes;  BUT uses 32 bytes (with padding)
+   def format() 'address'; end
+   def ==(another_type)  another_type.kind_of?( Address ); end
+end  # class Address
+
+class Bytes < Type
+   def size() nil; end    ## note: dynamic (not known at compile-time)
+   def format() 'bytes'; end
+   def ==(another_type)  another_type.kind_of?( Bytes ); end
+end  # class Bytes
+
+class FixedBytes < Type
+  attr_reader :length
+  def initialize( length )
+    @length = length   # in bytes (1,2,...32)
+  end
+  def size()  32; end   ## note: always uses 32 bytes (with padding)
+  def format() "bytes#{@length}"; end
+  def ==(another_type)
+     another_type.kind_of?( FixedBytes ) && @length == another_type.length
+  end
+end  # class FixedBytes
+
+class Int < Type
+   attr_reader :bits
+   def initialize( bits=256 )
+     @bits = bits  # in bits (8,16,...256)
+   end
+   def size() 32;  end   ## note: always uses 32 bytes (with padding)
+   def format() "int#{@bits}"; end
+   def ==(another_type)
+      another_type.kind_of?( Int ) && @bits == another_type.bits
+   end
+end  # class Int
+
+class  Uint < Type
+  attr_reader :bits
+  def initialize( bits=256 )
+    @bits = bits  # in bits (8,16,...256)
+  end
+  def size() 32;  end   ## note: always uses 32 bytes (with padding)
+  def format() "uint#{@bits}"; end
+  def ==(another_type)
+      another_type.kind_of?( Uint ) && @bits == another_type.bits
+  end
+end  # class  Uint
+
+class Bool < Type
+  def size() 32;  end   ## note: always uses 32 bytes (with padding)
+  def format() 'bool'; end
+  def ==(another_type)  another_type.kind_of?( Bool ); end
+end  # class Bool
+
+class String < Type
+  def size() nil; end    ## note: dynamic (not known at compile-time)
+  def format() 'string'; end
+  def ==(another_type)  another_type.kind_of?( String ); end
+end  # class String
+
+class Array < Type
+  attr_reader :subtype
+  def initialize( subtype )
+    @subtype = subtype
+  end
+  def size() nil; end    ## note: dynamic (not known at compile-time)
+  def format() "#{@subtype.format}[]"; end
+  def ==(another_type)
+    another_type.kind_of?( Array ) && @subtype == another_type.subtype
+  end
+end  # class Array
+
+class FixedArray < Type
+  attr_reader :subtype
+  attr_reader :dim
+  def initialize( subtype, dim )
+    @subtype = subtype
+    @dim      = dim
+  end
+
+  def size
+     @subtype.dynamic? ? nil : @dim * subtype.size
+  end
+  def format() "#{@subtype.format}[#{@dim}]"; end
+  def ==(another_type)
+      another_type.kind_of?( FixedArray ) &&
+        @dim == another_type.dim &&
+        @subtype == another_type.subtype
+  end
+end  # class FixedArray
+
+class Tuple < Type
+  attr_reader :types
+
+  def initialize( types )
+    @types = types
+  end
+
+  def size
+    s = 0
+    @types.each do |type|
+      ts = type.size
+      return nil   if ts.nil?
+      s += ts
+    end
+    s
+  end
+  def format
+    "(#{@types.map {|t| t.format }.join(',')})"  ## rebuild minimal string
+  end
+  def ==(another_type)
+    another_type.kind_of?( Tuple ) && @types == another_type.types
+  end
+end  # class Tuple
+end  # module ABI
+

data/lib/abicoder/version.rb

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

data/lib/abicoder.rb

@@ -3,6 +3,7 @@
 ## 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?)
@@ -17,29 +18,50 @@ module ABI
    BYTE_ONE   = "\x01".b.freeze      ## note: used for encoding bool for now
 
 
-   UINT_MAX = 2**256 - 1
+   UINT_MAX = 2**256 - 1   ## same as 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
    UINT_MIN = 0
-   INT_MAX  = 2**255 - 1
-   INT_MIN  = -2**255
-
+   INT_MAX  = 2**255 - 1   ## same as  57896044618658097711785492504343953926634992332820282019728792003956564819967
+   INT_MIN  = -2**255      ## same as -57896044618658097711785492504343953926634992332820282019728792003956564819968
 
-    ### 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/types'
+require_relative 'abicoder/parser'
+
+
+require_relative 'abicoder/encoder'
+require_relative 'abicoder/decoder'
+
+
+module ABI
+  def self.encoder
+    @encoder ||= Encoder.new
+  end
+  def self.decoder
+    @decoder ||= Decoder.new
+  end
+
+
+  def self.encode( types, args )
+      encoder.encode( types, args )
+  end
 
-require_relative 'abicoder/type'
-require_relative 'abicoder/type_tuple'
+  def self.decode( types, data, raise_errors = false )
+      decoder.decode( types, data, raise_errors )
+  end
 
-require_relative 'abicoder/codec'
+  ## add alternate _abi names  - why? why not?
+  class << self
+     alias_method :encode_abi, :encode
+     alias_method :decode_abi, :decode
+  end
+end    ## module ABI
 
 
+################
+## add convenience alternate spellings - why? why not?
+Abi = ABI
 
 
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: abicoder
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-12-30 00:00:00.000000000 Z
+date: 2023-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdoc
@@ -60,10 +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/decoder.rb
+- lib/abicoder/encoder.rb
+- lib/abicoder/parser.rb
+- lib/abicoder/types.rb
 - lib/abicoder/version.rb
 homepage: https://github.com/rubycocos/blockchain
 licenses: