abi_coder_rb 0.2.8 → 0.2.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2446e20c68206c39fddd2cc887136d0188a74283c82240f95d9fd3d7fce19d15
-  data.tar.gz: '0158a5505f945dc0655a1c80cf8722ff4d15610bf2e027fea15cd21de917aa1c'
+  metadata.gz: de0b1b60b90aa2361dc35e4511026c148913c1a1dffc976514c1f7b00eaa54ce
+  data.tar.gz: 95bfd4733c2e7590cecf11104462da65481c0c0168dea1d5c280e4167cfe4cdf
 SHA512:
-  metadata.gz: 26d7209d606865c01c539a3e5611e25477ce8ba3f2f1e9e54eb0c879ac510ca047979c066905a430fceab5f23f18b8c680b594341834a900d03e983d2241be03
-  data.tar.gz: cac0312067c262e52808ff92b7b36e9a85e87660e306f1e13205a19eb1107bb1a9fb423b2fd6641949c0e4e130b3bb20adb114c1d0fa83f00b5e81923173b2b3
+  metadata.gz: 83c52580ddf1abfba83900fe006c28ec647870d2fcc7618abafb50a5b3cc9190280124c45bd5941fa962292f13e37e02cff3b7550c6643ba63a9365df75cf043
+  data.tar.gz: 15285c84c9dac789f4274cc12d9ea93dd43f4be6e265402ef2efa63c592ad04ae847f9880eddd9c4684fb385f76e2f8ebf79dacca64c58254292117d2fae7120

data/README.md

@@ -1,19 +1,22 @@
 # AbiCoderRb
 
-modified from https://github.com/rubycocos/blockchain/blob/master/abicoder
+This is a ruby implementation of the Ethereum ABI codec. It passes all the codec tests in [web3.js].
 
-for better readability code and deep learning abi codec.
+## Why I write this gem
 
-Changes compared to original code:
+Originally, I just wanted to gain a deeper understanding of the Ethereum ABI codec by studying this [code](https://github.com/rubycocos/blockchain/blob/master/abicoder). 
 
-0. Adjusted files structure
-1. The biggest change for readability is that the 'data' to decode in every decode_* function is no longer exact but now includes both the data needed for decoding and the remaining data. This change means that in the entry point('AbiCoderRb.decode'), there's no longer a need to calculate the precise data required for decoding for each type. This simplification streamlines the code.
-2. Fixed some encoding end decoding bugs.
-3. Use string to describe any abi type. This is for compatibility with other abi libs.
-4. Added pre- encoding  and post- decoding callbacks to facilitate transforming data before encoding and after decoding. See [1](https://github.com/wuminzhe/abi_coder_rb/blob/main/spec/transform_before_encode_spec.rb#L4C1-L12C4) [2](https://github.com/wuminzhe/abi_coder_rb/blob/main/spec/web3_js_abitests_spec.rb#L27C1-L49C4)
-5. pass all web3.js tests in [encodeDecodeParams.test.ts](https://github.com/web3/web3.js/blob/c490c1814da646a83c6a5f7fee643e35507c9344/packages/web3-eth-abi/test/unit/encodeDecodeParams.test.ts). That is about 1024 unit tests from fixture [abitestsdata.json](https://github.com/web3/web3.js/blob/c490c1814da646a83c6a5f7fee643e35507c9344/packages/web3-eth-abi/test/fixtures/abitestsdata.json).
+When I read the code, I found that the code is not easy to read and understand. So I decided to rewrite it. This gem is the result.
 
-Also, some code was modified to compile to wasm. Try it online: https://wuminzhe.github.io/abi.html
+## Features
+
+1. Clear files and code structure.
+2. Use string to describe any abi type. This is for compatibility with other abi libs.
+3. Pre- encoding and post- decoding callbacks to facilitate transforming data before encoding and after decoding. See [1](https://github.com/wuminzhe/abi_coder_rb/blob/main/spec/transform_before_encode_spec.rb#L4C1-L12C4) [2](https://github.com/wuminzhe/abi_coder_rb/blob/main/spec/web3_js_abitests_spec.rb#L27C1-L49C4)
+4. Passed all web3.js tests in [encodeDecodeParams.test.ts](https://github.com/web3/web3.js/blob/c490c1814da646a83c6a5f7fee643e35507c9344/packages/web3-eth-abi/test/unit/encodeDecodeParams.test.ts). That is about 1024 unit tests from fixture [abitestsdata.json](https://github.com/web3/web3.js/blob/c490c1814da646a83c6a5f7fee643e35507c9344/packages/web3-eth-abi/test/fixtures/abitestsdata.json).
+5. support packed encoding similar to `abi.encodePacked`. See [test](./spec/packed_encoding_spec.rb)
+6. Clear and robust ABI parser which parses the ABI string to an AST tree. See [abi_parser](lib/abi_coder_rb/parser/abi_parser.rb)
+7. Can be compiled to wasm. Try it online: https://wuminzhe.github.io/abi.html
 
 ## Installation
 
@@ -81,6 +84,33 @@ end
 Hello.new.world # => ["Hello World"]
 ```
 
+### Encode packed
+
+```ruby
+# encodePacked
+type = "int64"
+value = 17
+
+encode(type, value, true) # => "0x0000000000000011"
+```
+
+### Encode values one by one
+
+It is similar to `abi.encode(v1, v2, ..)` or `abi.encodePacked(v1, v2, ..)` in solidity.
+
+```ruby
+types = ["int32", "uint64"]
+values = [17, 17]
+
+# abi.encode(v1, v2)
+encode(types, values) # => "0x00000000000000000000000000000000000000000000000000000000000000110000000000000000000000000000000000000000000000000000000000000011"
+
+# abi.encodePacked(v1, v2)
+encode(types, values, true) # => "0x000000110000000000000011"
+```
+
+
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/abi_coder_rb/decode/decode_array.rb

@@ -3,9 +3,9 @@ module AbiCoderRb
     size = decode_uint256(data[0, 32])
     raise DecodingError, "Too many elements: #{size}" if size > 100_000
 
-    subtype = type.subtype
+    inner_type = type.inner_type
 
-    if subtype.dynamic?
+    if inner_type.dynamic?
       raise DecodingError, "Not enough data for head" unless data.size >= 32 + 32 * size
 
       start_positions = (1..size).map { |i| 32 + decode_uint256(data[32 * i, 32]) }
@@ -13,9 +13,9 @@ module AbiCoderRb
 
       outputs = (0...size).map { |i| data[start_positions[i]...start_positions[i + 1]] }
 
-      outputs.map { |out| decode_type(subtype, out) }
+      outputs.map { |out| decode_type(inner_type, out) }
     else
-      (0...size).map { |i| decode_type(subtype, data[(32 + subtype.size * i)..]) }
+      (0...size).map { |i| decode_type(inner_type, data[(32 + inner_type.size * i)..]) }
     end
   end
 end

data/lib/abi_coder_rb/decode/decode_fixed_array.rb

@@ -1,16 +1,16 @@
 module AbiCoderRb
   def decode_fixed_array(type, data)
-    l = type.dim
-    subtype = type.subtype
-    if subtype.dynamic?
+    l = type.length
+    inner_type = type.inner_type
+    if inner_type.dynamic?
       start_positions = (0...l).map { |i| decode_uint256(data[32 * i, 32]) }
       start_positions.push(data.size)
 
       outputs = (0...l).map { |i| data[start_positions[i]...start_positions[i + 1]] }
 
-      outputs.map { |out| decode_type(subtype, out) }
+      outputs.map { |out| decode_type(inner_type, out) }
     else
-      (0...l).map { |i| decode_type(subtype, data[subtype.size * i, subtype.size]) }
+      (0...l).map { |i| decode_type(inner_type, data[inner_type.size * i, inner_type.size]) }
     end
   end
 end

data/lib/abi_coder_rb/decode/decode_tuple.rb

@@ -1,6 +1,6 @@
 module AbiCoderRb
   def decode_tuple(type, data)
-    decode_types(type.types, data)
+    decode_types(type.inner_types, data)
   end
 
   private

data/lib/abi_coder_rb/encode/encode_array.rb

@@ -1,6 +1,6 @@
 module AbiCoderRb
   def encode_array(type, args, packed = false)
-    raise ArgumentError, "arg must be an array" unless args.is_a?(::Array)
+    raise EncodingError, "args must be an array" unless args.is_a?(::Array)
 
     _encode_array(type: type, args: args, packed: packed)
   end
@@ -14,15 +14,14 @@ module AbiCoderRb
     # 数组长度
     head += encode_uint256(args.size) if type.is_a?(Array) && !packed
 
-    subtype = type.subtype
     args.each do |arg|
-      if subtype.dynamic?
-        raise "#{type.class} with dynamic inner type is not supported in packed mode" if packed
+      if type.inner_type.dynamic?
+        raise EncodingError, "#{type.class} with dynamic inner type is not supported in packed mode" if packed
 
         head += encode_uint256(32 * args.size + tail.size) # 当前数据的位置指针
-        tail += encode_type(subtype, arg)
+        tail += encode_type(type.inner_type, arg)
       else
-        head += encode_type(subtype, arg)
+        head += encode_type(type.inner_type, arg)
       end
     end
 

data/lib/abi_coder_rb/encode/encode_fixed_array.rb

@@ -1,7 +1,7 @@
 module AbiCoderRb
   def encode_fixed_array(type, args, packed = false)
-    raise ArgumentError, "arg must be an array" unless args.is_a?(::Array)
-    raise ArgumentError, "Wrong array size: found #{args.size}, expecting #{type.dim}" unless args.size == type.dim
+    raise EncodingError, "args must be an array" unless args.is_a?(::Array)
+    raise EncodingError, "Wrong array size: found #{args.size}, expecting #{type.length}" unless args.size == type.length
 
     # fixed_array，是没有元素数量的编码de
     # 如果内部类型是静态的，就是一个一个元素编码后加起来。

data/lib/abi_coder_rb/encode/encode_primitive_type.rb

@@ -25,7 +25,7 @@ module AbiCoderRb
   end
 
   def encode_uint(arg, bits, packed = false)
-    raise ArgumentError, "arg is not integer: #{arg}" unless arg.is_a?(Integer)
+    raise EncodingError, "arg is not integer: #{arg}" unless arg.is_a?(Integer)
     raise ValueOutOfBounds, arg unless arg >= 0 && arg < 2**bits
 
     if packed
@@ -51,8 +51,7 @@ module AbiCoderRb
   end
 
   def encode_bool(arg, packed = false)
-    ## raise EncodingError or ArgumentError - why? why not?
-    raise ArgumentError, "arg is not bool: #{arg}" unless arg.is_a?(TrueClass) || arg.is_a?(FalseClass)
+    raise EncodingError, "arg is not bool: #{arg}" unless arg.is_a?(TrueClass) || arg.is_a?(FalseClass)
 
     if packed
       arg ? BYTE_ONE : BYTE_ZERO
@@ -62,7 +61,6 @@ module AbiCoderRb
   end
 
   def encode_string(arg, packed = false)
-    ## raise EncodingError or ArgumentError - why? why not?
     raise EncodingError, "Expecting string: #{arg}" unless arg.is_a?(::String)
 
     arg = arg.b if arg.encoding != "BINARY" ## was: name == 'UTF-8', wasm
@@ -79,7 +77,6 @@ module AbiCoderRb
   end
 
   def encode_bytes(arg, length: nil, packed: false)
-    ## 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

data/lib/abi_coder_rb/encode/encode_tuple.rb

@@ -1,17 +1,17 @@
 module AbiCoderRb
   def encode_tuple(tuple, args, packed = false)
-    raise "#{tuple.class} with multi inner types is not supported in packed mode" if packed && tuple.types.size > 1
+    raise "#{tuple.class} with multi inner type is not supported in packed mode" if packed && tuple.inner_types.size > 1
 
-    encode_types(tuple.types, args, packed)
+    encode_types(tuple.inner_types, args, packed)
   end
 
   private
 
   def encode_types(types, args, packed = false)
-    raise ArgumentError, "args must be an array" unless args.is_a?(::Array)
+    raise EncodingError, "args must be an array" unless args.is_a?(::Array)
 
     unless args.size == types.size
-      raise ArgumentError,
+      raise EncodingError,
             "Wrong number of args: found #{args.size}, expecting #{types.size}"
     end
 

data/lib/abi_coder_rb/encode.rb

@@ -5,25 +5,14 @@ require_relative "encode/encode_primitive_type"
 
 module AbiCoderRb
   # returns byte array
-  def encode(typestr_or_typestrs, value_or_values, packed = false)
-    if typestr_or_typestrs.is_a?(::Array)
-      raise EncodingError, "values should be an array" unless value_or_values.is_a?(::Array)
+  def encode(str, value, packed = false)
+    return encode_type(Type.parse(str), value, packed) if str.is_a?(::String)
 
-      typestrs = typestr_or_typestrs
-      values = value_or_values
-      typestrs.map.with_index do |typestr, i|
-        value = values[i]
-        encode(typestr, value, packed)
-      end.join
-    else
-      typestr = typestr_or_typestrs
-      value = value_or_values
-      # TODO: more checks?
-      raise EncodingError, "Value can not be nil" if value.nil?
+    return str.map.with_index do |type, i|
+      encode(type, value[i], packed)
+    end.join("") if str.is_a?(::Array) && value.is_a?(::Array) && str.size == value.size
 
-      parsed = Type.parse(typestr)
-      encode_type(parsed, value, packed)
-    end
+    raise EncodingError, "There is something wrong with #{str.inspect}, #{value.inspect}"
   end
 
   private

data/lib/abi_coder_rb/parser/abi_parser.rb

@@ -0,0 +1,96 @@
+require_relative 'abi_tokenizer'
+
+module AbiCoderRb
+  class AbiParser
+    def initialize(abi)
+      @tokenizer = AbiTokenizer.new(abi)
+      @current_token = @tokenizer.next_token
+    end
+
+    def parse
+      element =
+        case @current_token
+        when "string", "address", "bool" then parse_simple_type
+        when "uint", "int" then parse_numeric_type
+        when "bytes" then parse_bytes
+        when "(" then parse_tuple
+        else
+          raise ParseError, "Unexpected token: #{@current_token}"
+        end
+
+      @current_token == "[" ? parse_array(element) : element
+    end
+
+    private
+
+    def parse_bytes
+      result =
+        if @tokenizer.peek_token =~ /^\d+$/
+          @current_token = @tokenizer.next_token
+          { type: 'bytes', length: @current_token.to_i }
+        else
+          { type: 'bytes' }
+        end
+      @current_token = @tokenizer.next_token
+      result
+    end
+
+    def parse_numeric_type
+      type = @current_token
+      result =
+        if @tokenizer.peek_token =~ /^\d+$/
+          @current_token = @tokenizer.next_token
+          { type: type, bits: @current_token.to_i }
+        else
+          { type: type, bits: 256 }
+        end
+      @current_token = @tokenizer.next_token
+      result
+    end
+
+    def parse_simple_type
+      type = @current_token
+      @current_token = @tokenizer.next_token
+      { type: type }
+    end
+
+    def parse_tuple
+      inner_types = []
+
+      expect("(")
+      until @current_token == ")"
+        inner_types << parse
+        expect(",") if @current_token != ")"
+      end
+      expect(")")
+
+      { type: "tuple", inner_types: inner_types }
+    end
+
+    def parse_array(element)
+      arr = { type: 'array', inner_type: element, length: parse_array_length }
+      @current_token == "[" ? parse_array(arr) : arr
+    end
+
+    def parse_array_length
+      expect("[")
+      if @current_token == "]"
+        length = nil
+      elsif @current_token =~ /^\d+$/
+        length = @current_token.to_i
+        @current_token = @tokenizer.next_token
+      else
+        raise ParseError, "Expected array length or closing ']'"
+      end
+      expect("]")
+
+      length
+    end
+
+    def expect(token)
+      raise "Expected #{token}, got #{@current_token}" unless @current_token == token
+
+      @current_token = @tokenizer.next_token
+    end
+  end
+end

data/lib/abi_coder_rb/parser/abi_tokenizer.rb

@@ -0,0 +1,57 @@
+module AbiCoderRb
+  class AbiTokenizer
+    def initialize(abi)
+      @abi = abi
+      @index = 0
+    end
+
+    def next_token
+      skip_whitespace
+
+      return nil if @index >= @abi.length
+
+      char = @abi[@index]
+
+      case char
+      when '(', ')', ',', '[', ']'
+        @index += 1
+        char
+      else
+        read_identifier
+      end
+    end
+
+    def peek_token
+      original_index = @index
+      token = next_token
+      @index = original_index
+      token
+    end
+
+    private
+
+    def skip_whitespace
+      while @index < @abi.length && @abi[@index].match?(/\s/)
+        @index += 1
+      end
+    end
+
+    def read_identifier
+      start_index = @index
+
+      # if the first character is a digit, read the whole number
+      if @abi[@index].match?(/\d/)
+        while @index < @abi.length && @abi[@index].match?(/\d/)
+          @index += 1
+        end
+      else
+        # Move the index until a non-identifier character or digit is found
+        while @index < @abi.length && !@abi[@index].match?(/[\(\),\[\]\s\d]/)
+          @index += 1
+        end
+      end
+      @abi[start_index...@index]
+    end
+
+  end
+end

data/lib/abi_coder_rb/type/parse.rb

@@ -0,0 +1,45 @@
+require_relative '../parser/abi_parser'
+
+module AbiCoderRb
+  class Type
+    class << self
+      def parse(str)
+        abi_type_element = AbiCoderRb::AbiParser.new(str).parse
+        create_type(abi_type_element)
+      end
+
+      private
+
+      def create_type(element)
+        case element[:type]
+        when 'string' then String.new
+        when 'address' then Address.new
+        when 'bool' then Bool.new
+        when 'uint', 'int' then create_numeric_type(element)
+        when 'bytes' then create_bytes_type(element)
+        when 'tuple' then create_tuple_type(element)
+        when 'array' then create_array_type(element)
+        else
+          raise ParseError, "Unknown type: #{element}"
+        end
+      end
+
+      def create_tuple_type(abi_type)
+        Tuple.new(abi_type[:inner_types].map { |t| create_type(t) })
+      end
+
+      def create_numeric_type(abi_type)
+        abi_type[:type] == 'uint' ? Uint.new(abi_type[:bits]) : Int.new(abi_type[:bits])
+      end
+
+      def create_bytes_type(abi_type)
+        abi_type[:length] ? FixedBytes.new(abi_type[:length]) : Bytes.new
+      end
+
+      def create_array_type(abi_type)
+        inner_type = create_type(abi_type[:inner_type])
+        abi_type[:length] ? FixedArray.new(inner_type, abi_type[:length]) : Array.new(inner_type)
+      end
+    end
+  end
+end

data/lib/abi_coder_rb/type/types.rb

@@ -0,0 +1,199 @@
+module AbiCoderRb
+  class Type
+    def size
+      raise NotImplementedError, "size method not defined for #{self.class.name}"
+    end
+
+    def dynamic?
+      size.nil?
+    end
+
+    def format
+      raise NotImplementedError, "format method not defined for #{self.class.name}"
+    end
+  end
+
+  class Address < Type
+    def size
+      32
+    end
+
+    def format
+      "address"
+    end
+
+    def ==(other)
+      other.is_a?(Address)
+    end
+  end
+
+  class Bytes < Type
+    def size
+      nil
+    end
+
+    def format
+      "bytes"
+    end
+
+    def ==(other)
+      other.is_a?(Bytes)
+    end
+  end
+
+  class FixedBytes < Type
+    attr_reader :length
+
+    def initialize(length)
+      @length = length
+    end
+
+    def size
+      32
+    end
+
+    def format
+      "bytes#{@length}"
+    end
+
+    def ==(other)
+      other.is_a?(FixedBytes) && @length == other.length
+    end
+  end
+
+  class Int < Type
+    attr_reader :bits
+
+    def initialize(bits = 256)
+      @bits = bits
+    end
+
+    def size
+      32
+    end
+
+    def format
+      "int#{@bits}"
+    end
+
+    def ==(other)
+      other.is_a?(Int) && @bits == other.bits
+    end
+  end
+
+  class Uint < Type
+    attr_reader :bits
+
+    def initialize(bits = 256)
+      @bits = bits
+    end
+
+    def size
+      32
+    end
+
+    def format
+      "uint#{@bits}"
+    end
+
+    def ==(other)
+      other.is_a?(Uint) && @bits == other.bits
+    end
+  end
+
+  class Bool < Type
+    def size
+      32
+    end
+
+    def format
+      "bool"
+    end
+
+    def ==(other)
+      other.is_a?(Bool)
+    end
+  end
+
+  class String < Type
+    def size
+      nil
+    end
+
+    def format
+      "string"
+    end
+
+    def ==(other)
+      other.is_a?(String)
+    end
+  end
+
+  class Array < Type
+    attr_reader :inner_type
+
+    def initialize(inner_type)
+      @inner_type = inner_type
+    end
+
+    def size
+      nil
+    end
+
+    def format
+      "#{@inner_type.format}[]"
+    end
+
+    def ==(other)
+      other.is_a?(Array) && @inner_type == other.inner_type
+    end
+  end
+
+  class FixedArray < Type
+    attr_reader :inner_type, :length
+
+    def initialize(inner_type, length)
+      @inner_type = inner_type
+      @length = length
+    end
+
+    def size
+      @inner_type.dynamic? ? nil : @length * inner_type.size
+    end
+
+    def format
+      "#{@inner_type.format}[#{@length}]"
+    end
+
+    def ==(other)
+      other.is_a?(FixedArray) && @length == other.length && @inner_type == other.inner_type
+    end
+  end
+
+  class Tuple < Type
+    attr_reader :inner_types
+
+    def initialize(inner_types)
+      @inner_types = inner_types
+    end
+
+    def size
+      s = 0
+      has_dynamic = false
+      @inner_types.each do |type|
+        ts = type.size
+        has_dynamic ||= ts.nil?
+        s += ts unless ts.nil?
+      end
+      has_dynamic ? nil : s
+    end
+
+    def format
+      "(#{@inner_types.map(&:format).join(",")})"
+    end
+
+    def ==(other)
+      other.is_a?(Tuple) && @inner_types == other.inner_types
+    end
+  end
+end

data/lib/abi_coder_rb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AbiCoderRb
-  VERSION = "0.2.8"
+  VERSION = "0.2.9"
 end

data/lib/abi_coder_rb.rb

@@ -4,18 +4,20 @@ require_relative "abi_coder_rb/version"
 
 require_relative "abi_coder_rb/utils"
 
-require_relative "abi_coder_rb/parser"
-require_relative "abi_coder_rb/types"
+require_relative "abi_coder_rb/type/types"
+require_relative "abi_coder_rb/type/parse"
 require_relative "abi_coder_rb/decode"
 require_relative "abi_coder_rb/encode"
 
 require_relative "periphery/event_decoder"
 
 module AbiCoderRb
-  class DecodingError < StandardError; end
-  class EncodingError < StandardError; end
-  class ValueError < StandardError; end
-  class ValueOutOfBounds < ValueError; end
+  class Error < StandardError; end
+  class DecodingError < Error; end
+  class EncodingError < Error; end
+  class ValueError < Error; end
+  class ValueOutOfBounds < Error; end
+  class ParseError < Error; end
 
   BYTE_EMPTY = "".b.freeze
   BYTE_ZERO  = "\x00".b.freeze

data/sig/abi_coder_rb/abi_parser.rbs

@@ -0,0 +1,37 @@
+module AbiCoderRb
+  class AbiParser
+    @tokenizer: AbiTokenizer
+    @current_token: String
+
+    def initialize: (AbiTokenizer) -> void
+    def parse: -> abi_type
+
+    private
+
+    def parse_bytes: -> bytes
+    def parse_numeric_type: -> numeric_type
+    def parse_simple_type: -> simple_type
+    def parse_tuple: -> tuple_type
+    def parse_array: -> array_type
+    def parse_array_length: -> Integer
+    def expect: -> void
+  end
+
+  type abi_type = bytes | numeric_type | simple_type | array_type | tuple_type
+
+  type bytes =
+      { type: "bytes", length?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 }
+
+  type numeric_type =
+      { type: "uint", bits: 8 | 16 | 24 | 32 | 40 | 48 | 56 | 64 | 72 | 80 | 88 | 96 | 104 | 112 | 120 | 128 | 136 | 144 | 152 | 160 | 168 | 176 | 184 | 192 | 200 | 208 | 216 | 224 | 232 | 240 | 248 | 256 } # uint will be parsed to uint256.
+    | { type: "int", bits: 8 | 16 | 24 | 32 | 40 | 48 | 56 | 64 | 72 | 80 | 88 | 96 | 104 | 112 | 120 | 128 | 136 | 144 | 152 | 160 | 168 | 176 | 184 | 192 | 200 | 208 | 216 | 224 | 232 | 240 | 248 | 256 } # int will be parsed to int256
+
+  type simple_type =
+      { type: "string" }
+    | { type: "address" }
+    | { type: "bool" }
+
+  type array_type = { type: "array", inner_type: abi_type, length: Integer? } # length is nil for dynamic array.
+
+  type tuple_type = { type: "tuple", inner_types: Array[abi_type] }
+end

data/sig/abi_coder_rb/abi_tokenizer.rbs

@@ -0,0 +1,15 @@
+module AbiCoderRb
+  class AbiTokenizer
+    @abi: String
+    @index: Integer
+
+    def initialize: (String) -> void
+    def next_token: -> String
+    def peek_token: -> String
+
+    private
+
+    def read_identifier: -> String
+    def skip_whitespace: -> void
+  end
+end

data/sig/abi_coder_rb/type.rbs

@@ -0,0 +1,5 @@
+module AbiCoderRb
+  class Type
+    def self.parse: -> untyped
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: abi_coder_rb
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 0.2.9
 platform: ruby
 authors:
 - Aki Wu
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-10 00:00:00.000000000 Z
+date: 2024-08-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -45,19 +45,15 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".DS_Store"
 - ".rspec"
 - ".rubocop.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
-- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
 - flatten.rb
-- lib/.DS_Store
 - lib/abi_coder_rb.rb
-- lib/abi_coder_rb/.DS_Store
 - lib/abi_coder_rb/decode.rb
 - lib/abi_coder_rb/decode/decode_array.rb
 - lib/abi_coder_rb/decode/decode_fixed_array.rb
@@ -68,12 +64,17 @@ files:
 - lib/abi_coder_rb/encode/encode_fixed_array.rb
 - lib/abi_coder_rb/encode/encode_primitive_type.rb
 - lib/abi_coder_rb/encode/encode_tuple.rb
-- lib/abi_coder_rb/parser.rb
-- lib/abi_coder_rb/types.rb
+- lib/abi_coder_rb/parser/abi_parser.rb
+- lib/abi_coder_rb/parser/abi_tokenizer.rb
+- lib/abi_coder_rb/type/parse.rb
+- lib/abi_coder_rb/type/types.rb
 - lib/abi_coder_rb/utils.rb
 - lib/abi_coder_rb/version.rb
 - lib/periphery/event_decoder.rb
 - sig/abi_coder_rb.rbs
+- sig/abi_coder_rb/abi_parser.rbs
+- sig/abi_coder_rb/abi_tokenizer.rbs
+- sig/abi_coder_rb/type.rbs
 - tea.yaml
 homepage: https://github.com/wuminzhe/abi_coder_rb
 licenses:

data/Gemfile.lock

@@ -1,87 +0,0 @@
-PATH
-  remote: .
-  specs:
-    abi_coder_rb (0.2.8)
-      activesupport
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    activesupport (7.1.1)
-      base64
-      bigdecimal
-      concurrent-ruby (~> 1.0, >= 1.0.2)
-      connection_pool (>= 2.2.5)
-      drb
-      i18n (>= 1.6, < 2)
-      minitest (>= 5.1)
-      mutex_m
-      tzinfo (~> 2.0)
-    ast (2.4.2)
-    base64 (0.1.1)
-    bigdecimal (3.1.4)
-    concurrent-ruby (1.2.2)
-    connection_pool (2.4.1)
-    diff-lcs (1.5.0)
-    drb (2.1.1)
-      ruby2_keywords
-    i18n (1.14.1)
-      concurrent-ruby (~> 1.0)
-    json (2.6.3)
-    keccak (1.3.1)
-    language_server-protocol (3.17.0.3)
-    minitest (5.20.0)
-    mutex_m (0.1.2)
-    parallel (1.23.0)
-    parser (3.2.2.4)
-      ast (~> 2.4.1)
-      racc
-    racc (1.7.3)
-    rainbow (3.1.1)
-    rake (13.1.0)
-    regexp_parser (2.8.2)
-    rexml (3.2.6)
-    rspec (3.12.0)
-      rspec-core (~> 3.12.0)
-      rspec-expectations (~> 3.12.0)
-      rspec-mocks (~> 3.12.0)
-    rspec-core (3.12.2)
-      rspec-support (~> 3.12.0)
-    rspec-expectations (3.12.3)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.12.0)
-    rspec-mocks (3.12.6)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.12.0)
-    rspec-support (3.12.1)
-    rubocop (1.57.2)
-      json (~> 2.3)
-      language_server-protocol (>= 3.17.0)
-      parallel (~> 1.10)
-      parser (>= 3.2.2.4)
-      rainbow (>= 2.2.2, < 4.0)
-      regexp_parser (>= 1.8, < 3.0)
-      rexml (>= 3.2.5, < 4.0)
-      rubocop-ast (>= 1.28.1, < 2.0)
-      ruby-progressbar (~> 1.7)
-      unicode-display_width (>= 2.4.0, < 3.0)
-    rubocop-ast (1.30.0)
-      parser (>= 3.2.1.0)
-    ruby-progressbar (1.13.0)
-    ruby2_keywords (0.0.5)
-    tzinfo (2.0.6)
-      concurrent-ruby (~> 1.0)
-    unicode-display_width (2.5.0)
-
-PLATFORMS
-  arm64-darwin-21
-
-DEPENDENCIES
-  abi_coder_rb!
-  keccak (~> 1.3)
-  rake (~> 13.0)
-  rspec (~> 3.0)
-  rubocop (~> 1.21)
-
-BUNDLED WITH
-   2.4.13

data/lib/abi_coder_rb/parser.rb

@@ -1,156 +0,0 @@
-module AbiCoderRb
-  class Type
-    class ParseError < StandardError; end
-
-    ## nested inside Type - why? why not?
-    class Parser
-      TUPLE_TYPE_RX = /^\((.*)\)
-                       ((\[[0-9]*\])*)
-                     /x
-
-      def self.parse(type)
-        type = type.strip
-
-        if type =~ TUPLE_TYPE_RX
-          types = _parse_tuple_type(::Regexp.last_match(1))
-          dims = _parse_dims(::Regexp.last_match(2))
-
-          parsed_types = types.map { |t| parse(t) }
-
-          return _parse_array_type(Tuple.new(parsed_types), dims)
-        end
-
-        # uint256 => uint, 256, nil
-        # uint256[2] => uint, 256, [2]
-        # uint256[] => uint, 256, [-1]
-        # bytes => bytes, nil, []
-        base, sub, dims = _parse_base_type(type)
-
-        sub ||= 256 if type.start_with?("uint") || type.start_with?("int") # default to 256 if no sub given
-        _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.map do |dim|
-          size = dim[1...-1]
-          size == "" ? -1 : size.to_i
-        end
-      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 ","
-            if depth == 0
-              collected << current
-              current = ""
-            else
-              current += c
-            end
-          when "("
-            depth += 1
-            current += c
-          when ")"
-            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/abi_coder_rb/types.rb

@@ -1,237 +0,0 @@
-module AbiCoderRb
-  #######
-  ## 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
-    ## note: address is always 20 bytes;  BUT uses 32 bytes (with padding)
-    def size
-      32
-    end
-
-    def format
-      "address"
-    end
-
-    def ==(other)
-      other.is_a?(Address)
-    end
-  end # class Address
-
-  class Bytes < Type
-    ## note: dynamic (not known at compile-time)
-    def size
-      nil
-    end
-
-    def format
-      "bytes"
-    end
-
-    def ==(other)
-      other.is_a?(Bytes)
-    end
-  end # class Bytes
-
-  class FixedBytes < Type
-    attr_reader :length
-
-    def initialize(length)
-      @length = length # in bytes (1,2,...32)
-    end
-
-    ## note: always uses 32 bytes (with padding)
-    def size
-      32
-    end
-
-    def format
-      "bytes#{@length}"
-    end
-
-    def ==(other)
-      other.is_a?(FixedBytes) && @length == other.length
-    end
-  end # class FixedBytes
-
-  class Int < Type
-    attr_reader :bits
-
-    def initialize(bits = 256)
-      @bits = bits # in bits (8,16,...256)
-    end
-
-    ## note: always uses 32 bytes (with padding)
-    def size
-      32
-    end
-
-    def format
-      "int#{@bits}"
-    end
-
-    def ==(other)
-      other.is_a?(Int) && @bits == other.bits
-    end
-  end # class Int
-
-  class Uint < Type
-    attr_reader :bits
-
-    def initialize(bits = 256)
-      @bits = bits # in bits (8,16,...256)
-    end
-
-    ## note: always uses 32 bytes (with padding)
-    def size
-      32
-    end
-
-    def format
-      "uint#{@bits}"
-    end
-
-    def ==(other)
-      other.is_a?(Uint) && @bits == other.bits
-    end
-  end # class  Uint
-
-  class Bool < Type
-    ## note: always uses 32 bytes (with padding)
-    def size
-      32
-    end
-
-    def format
-      "bool"
-    end
-
-    def ==(other)
-      other.is_a?(Bool)
-    end
-  end # class Bool
-
-  class String < Type
-    ## note: dynamic (not known at compile-time)
-    def size
-      nil
-    end
-
-    def format
-      "string"
-    end
-
-    def ==(other)
-      other.is_a?(String)
-    end
-  end # class String
-
-  class Array < Type
-    attr_reader :subtype
-
-    def initialize(subtype)
-      @subtype = subtype
-    end
-
-    ## note: dynamic (not known at compile-time)
-    def size
-      nil
-    end
-
-    def format
-      "#{@subtype.format}[]"
-    end
-
-    def ==(other)
-      other.is_a?(Array) && @subtype == other.subtype
-    end
-  end  # class Array
-
-  class FixedArray < Type
-    attr_reader :subtype, :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 ==(other)
-      other.is_a?(FixedArray) &&
-        @dim == other.dim &&
-        @subtype == other.subtype
-    end
-  end  # class FixedArray
-
-  class Tuple < Type
-    attr_reader :types
-
-    def initialize(types)
-      @types = types
-    end
-
-    def size
-      s = 0
-      has_dynamic = false
-      @types.each do |type|
-        ts = type.size
-        if ts.nil?
-          # can not return nil here? if wasm
-          has_dynamic = true
-        else
-          s += ts
-        end
-      end
-
-      return if has_dynamic
-
-      s
-    end
-
-    def format
-      "(#{@types.map { |t| t.format }.join(",")})" ## rebuild minimal string
-    end
-
-    def ==(other)
-      other.is_a?(Tuple) && @types == other.types
-    end
-  end # class Tuple
-end  # module ABI