abi_coder_rb 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 72266c6750d4c8e137acebdc790350c7862d9c84453f1af99b1aaa9ee5e775f7
-  data.tar.gz: 045aa60cc688c8537290ffff047df35ceb17db5de978d8943d7db9b0725ca9af
+  metadata.gz: 603c8a3cab98c321861f9480f1f668ffdf3559553974d09bdcd46858d97a44ea
+  data.tar.gz: 036b109f1f9f53088d592aeac51a66a9147707ae74a93a431a9c2be65617e37a
 SHA512:
-  metadata.gz: 19822e060b76e17667c3deccf9ba9f2697b51b1ec0825fda594a6d4fcc3f3ed617ca15db6354b4e8702e994cadc58ee221b2b4823b5e93371bc2effd4858b3fc
-  data.tar.gz: 863775a35f5819bddee87bcfe0cbaafc0b59042c98eeff8c9ceaa254ae3e9543c2a8df95660a40e4ac25aa8902f04b50b8493762e729f8141bc35b216e3ea704
+  metadata.gz: 1d6358050ac16002065cb2b379bafa1ed85f3cacdcec82998c69408cbd22d46ce47e554a73f2ca1bae9edc9279505cd18d62412a87271503dcf1488ca97f3fe5
+  data.tar.gz: a4b083f13af344d38aea6acbc5b267f8c0763217ec98041cb8b12d88e2896c5e92df66b8911c6a7524c83f777af05932ebe10ac56bb20523dbacd9a86de52d91

data/Gemfile.lock

@@ -1,15 +1,37 @@
 PATH
   remote: .
   specs:
-    abi_coder_rb (0.1.0)
+    abi_coder_rb (0.2.1)
+      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)
@@ -46,6 +68,9 @@ GEM
     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
@@ -53,6 +78,7 @@ PLATFORMS
 
 DEPENDENCIES
   abi_coder_rb!
+  keccak (~> 1.3)
   rake (~> 13.0)
   rspec (~> 3.0)
   rubocop (~> 1.21)

data/README.md

@@ -4,7 +4,16 @@ modified from https://github.com/rubycocos/blockchain/blob/master/abicoder
 
 for better readability code and deep learning abi codec.
 
-The most significant difference from the original code is that '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.
+Changes compared to original code:
+
+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).
+
+Also, some code was modified to compile to wasm. Try it online: https://wuminzhe.github.io/abi.html
 
 ## Installation
 
@@ -18,7 +27,59 @@ If bundler is not being used to manage dependencies, install the gem by executin
 
 ## Usage
 
-See tests
+### Way 1: extend AbiCoderRb
+
+```ruby
+require 'abi_coder_rb'
+
+module ABI
+  extend AbiCoderRb
+end
+
+type = "(bytes4)"
+value = ["\x124Vx"] # or ABI.hex "0x12345678"
+data = ABI.hex "1234567800000000000000000000000000000000000000000000000000000000"
+ABI.decode(type, data) == value # => true
+ABI.encode(type, value) == data # => true
+```
+
+You can transform the value according to the type before encoding it. For example, you can convert the hex string to bytes before encoding it. Here is same example but the value for "bytes4" is a hex string. 
+```ruby
+require 'abi_coder_rb'
+
+module ABI
+  extend AbiCoderRb
+
+  before_encoding ->(type, value) { 
+    if type.start_with?("bytes")
+      hex(value)
+    else
+      value
+    end
+  }
+end
+
+type = "(bytes4)"
+value = ["0x12345678"]
+data = ABI.hex "1234567800000000000000000000000000000000000000000000000000000000"
+ABI.encode(type, value) == data # => true
+```
+
+### Way 2: include AbiCoderRb
+```ruby
+class Hello
+  include AbiCoderRb
+
+  def world
+    data = hex "0000000000000000000000000000000000000000000000000000000000000020" \
+               "000000000000000000000000000000000000000000000000000000000000000b" \
+               "48656c6c6f20576f726c64000000000000000000000000000000000000000000"
+    decode("(string)", data)
+  end
+end
+
+Hello.new.world # => ["Hello World"]
+```
 
 ## Development
 

data/flatten.rb

@@ -0,0 +1,8 @@
+content = "# Generated from https://github.com/wuminzhe/abi_coder_rb\n"
+Dir["./lib/**/*.rb"].each do |f|
+  File.open(f, "r").each_line do |line|
+    content += line unless line.include?("require") || line.strip.start_with?("#") || line.strip.empty?
+  end
+end
+
+puts content

data/lib/abi_coder_rb/decode/decode_array.rb

@@ -1,21 +1,21 @@
 module AbiCoderRb
   def decode_array(type, data)
-    l = decode_uint256(data[0, 32])
-    raise DecodingError, "Too long length: #{l}" if l > 100_000
+    size = decode_uint256(data[0, 32])
+    raise DecodingError, "Too many elements: #{size}" if size > 100_000
 
     subtype = type.subtype
 
     if subtype.dynamic?
-      raise DecodingError, "Not enough data for head" unless data.size >= 32 + 32 * l
+      raise DecodingError, "Not enough data for head" unless data.size >= 32 + 32 * size
 
-      start_positions = (1..l).map { |i| 32 + decode_uint256(data[32 * i, 32]) }
+      start_positions = (1..size).map { |i| 32 + 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 = (0...size).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, data[(32 + subtype.size * i)..]) }
+      (0...size).map { |i| decode_type(subtype, data[(32 + subtype.size * i)..]) }
     end
   end
 end

data/lib/abi_coder_rb/decode/decode_primitive_type.rb

@@ -1,26 +1,30 @@
 module AbiCoderRb
   def decode_primitive_type(type, data)
-    case type
-    when Uint
-      decode_uint256(data[0, 32])
-    when Int
-      u = decode_uint256(data[0, 32])
-      u >= 2**(type.bits - 1) ? (u - 2**type.bits) : u
-    when Bool
-      data[31] == BYTE_ONE
-    when String
-      size = decode_uint256(data[0, 32])
-      data[32...(32 + size)].force_encoding(Encoding::UTF_8)
-    when Bytes
-      size = decode_uint256(data[0, 32])
-      data[32...(32 + size)]
-    when FixedBytes
-      data[0, type.length]
-    when Address
-      data[12...32].unpack1("H*").force_encoding(Encoding::UTF_8)
-    else
-      raise DecodingError, "Unknown primitive type: #{type.class.name} #{type.format}"
-    end
+    result =
+      case type
+      when Uint
+        decode_uint256(data[0, 32])
+      when Int
+        abi_to_int_signed(bin_to_hex(data[0, 32]), type.bits)
+      when Bool
+        data[31] == BYTE_ONE
+      when String
+        size = decode_uint256(data[0, 32])
+        data[32...(32 + size)].force_encoding("UTF-8")
+      when Bytes
+        size = decode_uint256(data[0, 32])
+        data[32...(32 + size)]
+      when FixedBytes
+        data[0, type.length]
+      when Address
+        bin_to_hex(data[12...32]).force_encoding("UTF-8")
+      else
+        raise DecodingError, "Unknown primitive type: #{type.class.name} #{type.format}"
+      end
+
+    result = after_decoding_action.call(type.format, result) if after_decoding_action
+
+    result
   end
 
   private
@@ -30,6 +34,7 @@ module AbiCoderRb
     ### 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.unpack1("H*").to_i(16)
+    bin_to_hex(bin).to_i(16)
+    # bin.bytes.reduce { |acc, byte| (acc << 8) + byte }
   end
 end

data/lib/abi_coder_rb/decode/decode_tuple.rb

@@ -2,4 +2,33 @@ module AbiCoderRb
   def decode_tuple(type, data)
     decode_types(type.types, data)
   end
+
+  private
+
+  def decode_types(types, data)
+    start_positions = start_positions(types, data)
+
+    types.map.with_index do |type, index|
+      start_position = start_positions[index]
+      decode_type(type, data[start_position..])
+    end
+  end
+
+  def start_positions(types, data)
+    start_positions = ::Array.new(types.size)
+    offset = 0
+
+    types.each_with_index do |type, index|
+      if type.dynamic?
+        # 读取动态类型的偏移量
+        start_positions[index] = decode_uint256(data[offset, 32])
+        offset += 32
+      else
+        start_positions[index] = offset
+        offset += type.size
+      end
+    end
+
+    start_positions
+  end
 end

data/lib/abi_coder_rb/decode.rb

@@ -4,18 +4,15 @@ require_relative "decode/decode_array"
 require_relative "decode/decode_primitive_type"
 
 module AbiCoderRb
-  def decode(types, data)
-    # Convert types to ABI::Type if they are not already
-    types = types.map { |type| type.is_a?(Type) ? type : Type.parse(type) }
+  def decode(type_str, data)
+    raise DecodingError, "Empty data" if data.nil? || data.empty?
 
-    decode_types(types, data)
+    decode_type(Type.parse(type_str), data)
   end
 
   private
 
   def decode_type(type, data)
-    return nil if data.nil? || data.empty?
-
     case type
     when Tuple ## todo: support empty (unit) tuple - why? why not?
       decode_tuple(type, data)
@@ -27,31 +24,4 @@ module AbiCoderRb
       decode_primitive_type(type, data)
     end
   end
-
-  def decode_types(types, data)
-    start_positions = start_positions(types, data)
-
-    types.map.with_index do |type, index|
-      start_position = start_positions[index]
-      decode_type(type, data[start_position..])
-    end
-  end
-
-  def start_positions(types, data)
-    start_positions = ::Array.new(types.size)
-    offset = 0
-
-    types.each_with_index do |type, index|
-      if type.dynamic?
-        # 读取动态类型的偏移量
-        start_positions[index] = decode_uint256(data[offset, 32])
-        offset += 32
-      else
-        start_positions[index] = offset
-        offset += type.size
-      end
-    end
-
-    start_positions
-  end
 end

data/lib/abi_coder_rb/encode/encode_fixed_array.rb

@@ -3,6 +3,20 @@ module AbiCoderRb
     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
 
-    args.map { |arg| encode_type(type.subtype, arg) }.join
+    # fixed_array，是没有元素数量的编码de
+    # 如果内部类型是静态的，就是一个一个元素编码后加起来。
+    # 如果内部类型是动态的，先用位置一个一个编码加起来，然后是元素本体
+    subtype = type.subtype
+    if subtype.dynamic?
+      head = "".b
+      tail = "".b
+      args.each do |arg|
+        head += encode_uint256(32 * args.size + tail.size)
+        tail += encode_type(subtype, arg)
+      end
+      head + tail
+    else
+      args.map { |arg| encode_type(type.subtype, arg) }.join
+    end
   end
 end

data/lib/abi_coder_rb/encode/encode_primitive_type.rb

@@ -1,5 +1,6 @@
 module AbiCoderRb
   def encode_primitive_type(type, arg)
+    arg = before_encoding_action.call(type.format, arg) if before_encoding_action
     # 根据类型选择相应的编码方法
     case type
     when Uint
@@ -34,12 +35,11 @@ module AbiCoderRb
     encode_uint(arg, 256)
   end
 
-  def encode_int(arg, bits)
+  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)
+    hex_to_bin(int_to_abi_signed_256bit(arg))
   end
 
   def encode_bool(arg)
@@ -53,7 +53,7 @@ module AbiCoderRb
     ## 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'
+    arg = arg.b if arg.encoding != "BINARY" ## was: name == 'UTF-8', wasm
 
     raise ValueOutOfBounds, "Integer invalid or out of range: #{arg.size}" if arg.size > UINT_MAX
 
@@ -69,7 +69,7 @@ module AbiCoderRb
     arg = arg.b if arg.encoding != Encoding::BINARY
 
     if length # fixed length type
-      raise ValueOutOfBounds, "invalid bytes length #{length}" if arg.size > length
+      raise ValueOutOfBounds, "invalid bytes length #{arg.size}, should be #{length}" if arg.size > length
       raise ValueOutOfBounds, "invalid bytes length #{length}" if length < 0 || length > 32
 
       rpad(arg)
@@ -97,50 +97,4 @@ module AbiCoderRb
       raise EncodingError, "Could not parse address: #{arg}"
     end
   end
-
-  private
-
-  ###########
-  #  encoding helpers / utils
-  #    with "hard-coded" fill symbol as BYTE_ZERO
-
-  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 + BYTE_ZERO * (l - bin.size)
-  end
-
-  ## 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
-
-    BYTE_ZERO * (l - bin.size) + bin
-  end
-
-  ## 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)
-  end
-
-  ## 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)
-  end
-
-  def ceil32(x)
-    x % 32 == 0 ? x : (x + 32 - x % 32)
-  end
 end

data/lib/abi_coder_rb/encode/encode_tuple.rb

@@ -2,4 +2,36 @@ module AbiCoderRb
   def encode_tuple(tuple, args)
     encode_types(tuple.types, args)
   end
+
+  private
+
+  def encode_types(types, args)
+    raise ArgumentError, "args must be an array" unless args.is_a?(::Array)
+
+    unless args.size == types.size
+      raise ArgumentError,
+            "Wrong number of args: found #{args.size}, expecting #{types.size}"
+    end
+
+    # 计算头部大小
+    head_size = types.map { |type| type.size || 32 }.sum
+
+    # 初始化头部和尾部
+    head = "".b
+    tail = "".b # 使用二进制字符串
+
+    # 遍历类型并编码
+    types.each_with_index do |type, i|
+      if type.dynamic?
+        # 动态类型: 更新头部和尾部
+        head += encode_uint256(head_size + tail.size)
+        tail += encode_type(type, args[i])
+      else
+        # 静态类型: 只更新头部
+        head += encode_type(type, args[i])
+      end
+    end
+
+    head + tail
+  end
 end

data/lib/abi_coder_rb/encode.rb

@@ -4,56 +4,26 @@ require_relative "encode/encode_array"
 require_relative "encode/encode_primitive_type"
 
 module AbiCoderRb
-  ##
-  # Encodes multiple arguments using the head/tail mechanism.
-  #     returns binary string (with BINARY / ASCII_8BIT encoding)
-  #
-  def encode(types, args)
-    # 如果 types 是字符串，则转换为 ABI::Type 实例
-    types = types.map { |type| type.is_a?(Type) ? type : Type.parse(type) }
+  # returns byte array
+  def encode(type, value)
+    # TODO: more checks?
+    raise EncodingError, "Value can not be nil" if value.nil?
 
-    encode_types(types, args)
+    parsed = Type.parse(type)
+    encode_type(parsed, value)
   end
 
   private
 
-  def encode_type(type, arg)
+  def encode_type(type, value)
     if type.is_a?(Tuple)
-      encode_tuple(type, arg)
-    elsif type.is_a?(Array) || type.is_a?(FixedArray)
-      type.dynamic? ? encode_array(type, arg) : encode_fixed_array(type, arg)
+      encode_tuple(type, value)
+    elsif type.is_a?(Array)
+      encode_array(type, value)
+    elsif type.is_a?(FixedArray)
+      encode_fixed_array(type, value)
     else
-      encode_primitive_type(type, arg)
+      encode_primitive_type(type, value)
     end
   end
-
-  def encode_types(types, args)
-    raise ArgumentError, "args must be an array" unless args.is_a?(::Array)
-
-    unless args.size == types.size
-      raise ArgumentError,
-            "Wrong number of args: found #{args.size}, expecting #{types.size}"
-    end
-
-    # 计算头部大小
-    head_size = types.map { |type| type.size || 32 }.sum
-
-    # 初始化头部和尾部
-    head = "".b
-    tail = "".b # 使用二进制字符串
-
-    # 遍历类型并编码
-    types.each_with_index do |type, i|
-      if type.dynamic?
-        # 动态类型: 更新头部和尾部
-        head += encode_uint256(head_size + tail.size)
-        tail += encode_type(type, args[i])
-      else
-        # 静态类型: 只更新头部
-        head += encode_type(type, args[i])
-      end
-    end
-
-    head + tail
-  end
 end

data/lib/abi_coder_rb/parser.rb

@@ -9,6 +9,8 @@ module AbiCoderRb
                      /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))
@@ -18,8 +20,13 @@ module AbiCoderRb
           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
@@ -96,7 +103,7 @@ module AbiCoderRb
           # 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
+          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

data/lib/abi_coder_rb/types.rb

@@ -210,12 +210,19 @@ module AbiCoderRb
 
     def size
       s = 0
+      has_dynamic = false
       @types.each do |type|
         ts = type.size
-        return nil if ts.nil?
-
-        s += ts
+        if ts.nil?
+          # can not return nil here? if wasm
+          has_dynamic = true
+        else
+          s += ts
+        end
       end
+
+      return if has_dynamic
+
       s
     end
 

data/lib/abi_coder_rb/utils.rb

@@ -0,0 +1,105 @@
+module AbiCoderRb
+  def hex_to_bin(hex)
+    hex = hex[2..] if %w[0x 0X].include?(hex[0, 2]) ## cut-of leading 0x or 0X if present
+    hex.scan(/../).map { |x| x.hex.chr }.join
+  end
+  alias hex hex_to_bin
+
+  def bin_to_hex(bin)
+    bin.each_byte.map { |byte| "%02x" % byte }.join
+  end
+
+  def hex?(str)
+    str.start_with?("0x") && str.length.even? && str[2..].match?(/\A\b[0-9a-fA-F]+\b\z/)
+  end
+
+  ###########
+  #  encoding helpers / utils
+  #    with "hard-coded" fill symbol as BYTE_ZERO
+
+  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 + BYTE_ZERO * (l - bin.size)
+  end
+
+  ## rename to lpad32 or such - why? why not?
+  # example:
+  # lpad("hello", 'x', 10) => "xxxxxxhello"
+  def lpad(bin) ## note: same as builtin String#rjust !!!
+    l = 32 # NOTE: default l word is 32 bytes
+    return bin  if bin.size >= l
+
+    BYTE_ZERO * (l - bin.size) + bin
+  end
+
+  ## rename to lpad32_int or such - why? why not?
+  def lpad_int(n)
+    unless n.is_a?(Integer) && n >= 0 && n <= UINT_MAX
+      raise ArgumentError,
+            "Integer invalid or out of range: #{n}"
+    end
+
+    hex = n.to_s(16)
+    hex = "0#{hex}" if hex.length.odd? # wasm, no .odd?
+    bin = hex_to_bin(hex)
+
+    lpad(bin)
+  end
+
+  ## 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_to_bin(hex)
+
+    lpad(bin)
+  end
+
+  def ceil32(x)
+    x % 32 == 0 ? x : (x + 32 - x % 32)
+  end
+
+  def int_to_abi_signed_256bit(value)
+    # 确保值在256位有符号整数范围内
+    min = -2**255
+    max = 2**255 - 1
+    raise "Value out of range" if value < min || value > max
+
+    # 为负数计算补码
+    value = (1 << 256) + value if value < 0
+
+    # 转换为十六进制字符串
+    hex_str = value.to_s(16)
+
+    # 确保字符串长度为64字符（256位）
+    hex_str.rjust(64, "0")
+  end
+
+  def abi_to_int_signed(hex_str, bits)
+    hex_str = "0x#{hex_str}" if hex_str[0, 2] != "0x" || hex_str[0, 2] != "0X"
+
+    # 计算预期的十六进制字符串长度
+    expected_length = bits / 4
+    extended_hex_str = if hex_str.length < expected_length
+                         # 如果输入长度小于预期，根据首位字符扩展字符串
+                         extend_char = hex_str[0] == "f" ? "f" : "0"
+                         extend_char * (expected_length - hex_str.length) + hex_str
+                       else
+                         hex_str
+                       end
+
+    # 将十六进制字符串转换为二进制字符串
+    binary_str = extended_hex_str.to_i(16).to_s(2).rjust(bits, extended_hex_str[0])
+
+    # 检查符号位并转换为整数
+    if binary_str[0] == "1" # 负数
+      # 取反加一以计算补码，然后转换为负数
+      -((binary_str.tr("01", "10").to_i(2) + 1) & ((1 << bits) - 1))
+    else # 正数
+      binary_str.to_i(2)
+    end
+  end
+end

data/lib/abi_coder_rb/version.rb

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

data/lib/abi_coder_rb.rb

@@ -2,26 +2,22 @@
 
 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/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
 
-  ###################
-  ### 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_EMPTY = "".b.freeze
   BYTE_ZERO  = "\x00".b.freeze
   BYTE_ONE   = "\x01".b.freeze ## note: used for encoding bool for now
 
@@ -30,14 +26,13 @@ module AbiCoderRb
   INT_MAX  = 2**255 - 1   ## same as  57896044618658097711785492504343953926634992332820282019728792003956564819967
   INT_MIN  = -2**255      ## same as -57896044618658097711785492504343953926634992332820282019728792003956564819968
 
-  def hex_to_bin(hex) # convert hex(adecimal) string  to binary string
-    hex = hex[2..] if %w[0x 0X].include?(hex[0, 2]) ## cut-of leading 0x or 0X if present
-    [hex].pack("H*")
+  attr_accessor :before_encoding_action, :after_decoding_action
+
+  def before_encoding(action)
+    self.before_encoding_action = action
   end
-  alias hex hex_to_bin
 
-  def bin_to_hex(bin) # convert binary string to hex string
-    bin.unpack1("H*")
+  def after_decoding(action)
+    self.after_decoding_action = action
   end
-  alias bin bin_to_hex
 end

data/lib/periphery/event_decoder.rb

@@ -0,0 +1,177 @@
+require "active_support"
+require "active_support/core_ext/string"
+
+class EventDecoder
+  include AbiCoderRb
+
+  attr_reader :event_abi,
+              # indexed_topic_inputs
+              :indexed_topic_inputs, :indexed_topic_types,
+              # data_inputs
+              :data_inputs, :data_type_str, :data_field_names, :data_field_names_flattened
+
+  def initialize(event_abi)
+    @event_abi = event_abi
+    @indexed_topic_inputs, @data_inputs = event_abi["inputs"].partition { |input| input["indexed"] }
+
+    # indexed_topic_inputs:
+    @indexed_topic_types = @indexed_topic_inputs.map { |input| input["type"] }
+
+    # data_inputs:
+    @data_fields = fields_of(@data_inputs)
+
+    @data_type_str = fields_type_str(@data_fields)
+
+    @data_field_names = fields_names(@data_fields)
+    @data_field_names_flattened = fields_names_flatten(@data_fields)
+
+    # add after_decoding action
+    after_decoding lambda { |type, value|
+      if type == "address"
+        "0x#{value}"
+      elsif type.start_with?("bytes")
+        "0x#{bin_to_hex(value)}"
+      else
+        value
+      end
+    }
+  end
+
+  def decode_topics(topics, with_names: false)
+    topics = topics[1..] if topics.count == @indexed_topic_inputs.count + 1 && @event_abi["anonymous"] == false
+
+    raise "topics count not match" if topics.count != @indexed_topic_inputs.count
+
+    values = topics.each_with_index.map do |topic, i|
+      indexed_topic_type = @indexed_topic_types[i]
+      decode(indexed_topic_type, hex_to_bin(topic))
+    end
+
+    if with_names
+      combine(@indexed_topic_inputs.map { |input| input["name"].underscore }, values)
+    else
+      values
+    end
+  end
+
+  def decode_data(data, flatten: true, with_names: false)
+    data_values = decode(@data_type_str, hex_to_bin(data))
+
+    case flatten
+    when true
+      if with_names
+        combine(@data_field_names_flattened, data_values.flatten)
+      else
+        data_values.flatten
+      end
+    when false
+      if with_names
+        combine(@data_field_names, data_values)
+      else
+        data_values
+      end
+    end
+  end
+
+  private
+
+  # fields:
+  #   [
+  #     ["root", "bytes32"],
+  #     ["message", [["channel", "address"], ["index", "uint256"], ["fromChainId", "uint256"], ["from", "address"], ["toChainId", "uint256"], ["to", "address"], ["encoded", "bytes"]]]
+  #   ]
+  #
+  # returns:
+  #   '(bytes32,(address,uint256,uint256,address,uint256,address,bytes))'
+  def fields_type_str(fields)
+    "(#{
+      fields.map do |_name, type|
+        if type.is_a?(::Array)
+          fields_type_str(type)
+        else
+          type
+        end
+      end.join(",")
+    })"
+  end
+
+  # fields:
+  #   [
+  #     ["root", "bytes32"],
+  #     ["message", [["channel", "address"], ["index", "uint256"], ["fromChainId", "uint256"], ["from", "address"], ["toChainId", "uint256"], ["to", "address"], ["encoded", "bytes"]]]
+  #   ]
+  #
+  # returns:
+  #   ["root", {"message" => ["channel", "index", "fromChainId", "from", "toChainId", "to", "gasLimit", "encoded"]}
+  def fields_names(fields)
+    fields.map do |name, type|
+      name = name.underscore
+      if type.is_a?(::Array)
+        { name => fields_names(type) }
+      elsif type.is_a?(::String)
+        name
+      end
+    end
+  end
+
+  # fields:
+  #   [
+  #     ["root", "bytes32"],
+  #     ["message", [["channel", "address"], ["index", "uint256"], ["fromChainId", "uint256"], ["from", "address"], ["toChainId", "uint256"], ["to", "address"], ["encoded", "bytes"]]]
+  #   ]
+  #
+  # returns:
+  #   ["root", "message_channel", "message_index", "message_fromChainId", "message_from", "message_toChainId", "message_to", "message_gasLimit", "message_encoded"]
+  def fields_names_flatten(fields, prefix = nil)
+    fields.map do |name, type|
+      name = name.underscore
+      if type.is_a?(::Array)
+        fields_names_flatten(
+          type,
+          prefix.nil? ? name : "#{prefix}.#{name}"
+        )
+      elsif type.is_a?(::String)
+        prefix.nil? ? name : "#{prefix}.#{name}"
+      end
+    end.flatten
+  end
+
+  # returns:
+  #   [
+  #     ["root", "bytes32"],
+  #     ["message", [["channel", "address"], ["index", "uint256"], ["fromChainId", "uint256"], ["from", "address"], ["toChainId", "uint256"], ["to", "address"], ["encoded", "bytes"]]]
+  #   ]
+  def fields_of(inputs)
+    inputs.map do |input|
+      if input["type"] == "tuple"
+        [input["name"], fields_of(input["components"])]
+      elsif input["type"] == "enum"
+        [input["name"], "uint8"]
+      else
+        [input["name"], input["type"]]
+      end
+    end
+  end
+
+  # params:
+  #   keys = ['key1', 'key2' => ['key2_1', 'key2_2']]
+  #   values = [1, [2.1, 2.2]]
+  #
+  # returns:
+  #   {"key1"=>1, "key2"=>{"key2_1"=>2.1, "key2_2"=>2.2}}
+  def combine(keys, values)
+    result = {}
+
+    keys.each_with_index do |key, index|
+      if key.is_a?(Hash)
+        key.each do |k, v|
+          result[k] = combine(v, values[index])
+        end
+      else
+        result[key] = values[index]
+      end
+    end
+
+    result
+  end
+end

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: abi_coder_rb
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Aki Wu
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-11-13 00:00:00.000000000 Z
-dependencies: []
+date: 2023-11-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: keccak
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
 description: An EVM ABI encoding and decoding tool
 email:
 - wuminzhe@gmail.com
@@ -26,6 +54,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- flatten.rb
 - lib/.DS_Store
 - lib/abi_coder_rb.rb
 - lib/abi_coder_rb/.DS_Store
@@ -41,7 +70,9 @@ files:
 - lib/abi_coder_rb/encode/encode_tuple.rb
 - lib/abi_coder_rb/parser.rb
 - lib/abi_coder_rb/types.rb
+- lib/abi_coder_rb/utils.rb
 - lib/abi_coder_rb/version.rb
+- lib/periphery/event_decoder.rb
 - sig/abi_coder_rb.rbs
 homepage: https://github.com/wuminzhe/abi_coder_rb
 licenses: