abi_coder_rb 0.2.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1df03ba4a67d09da186cb3326798ef5f2bbbebb48dedb7fb3f30170eac01283e
-  data.tar.gz: 92cada88c754227fb404dc6ae6198be216eb1db19c39d47e69e15b210fd58095
+  metadata.gz: 0f20aa23f421459866cdbd1cd485027ec5fec4b52af891adc9c4025f247b42a9
+  data.tar.gz: 439e3e33e16d8cd9b20267f6e35218adb3c542f7aa6e80482c8d9aafee220bd3
 SHA512:
-  metadata.gz: 9d1621232bdabc3ee622786cafcef42260fac404df806b53a534791fed8a97884d3d0faca5ab153332b1b02665e95465667678e02d20098218178ef909f09f66
-  data.tar.gz: 93f19691b3d14cfeaac06b001f24e5910b4160acb90bc06df5066616666b7148701c8d62d5511bacfd716143f49299fc039b46c1896c61f84505cf8179deae01
+  metadata.gz: 6c423bbce7507e4dc2d79d73355c65b84c8ceff0bc4c9e89045e23a461084898c9b97e35225e6b0b8e0173ddb05d1dfd13c3df5e7071cfe05960254037e2a3f9
+  data.tar.gz: d2977279469c49bc63d67c360d12b281bb2442856dddc166ef784b1311198afb0dabbe19604160c53edd5c54047b031113a6ae18e5ef60b93611b68fa9f8b657

data/Gemfile.lock

@@ -1,16 +1,37 @@
 PATH
   remote: .
   specs:
-    abi_coder_rb (0.2.0)
+    abi_coder_rb (0.2.2)
+      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)
@@ -47,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

data/README.md

@@ -4,11 +4,14 @@ modified from https://github.com/rubycocos/blockchain/blob/master/abicoder
 
 for better readability code and deep learning abi codec.
 
-1. 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.
-
-2. Added type encoding pre- and type decoding post- callbacks to facilitate transforming before encoding and after decoding. See [test](./spec/web3_js_abitests_spec.rb)
-
-3. 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).
+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
 

data/lib/abi_coder_rb/decode/decode_primitive_type.rb

@@ -5,7 +5,7 @@ module AbiCoderRb
       when Uint
         decode_uint256(data[0, 32])
       when Int
-        Utils.abi_to_int_signed(bin_to_hex(data[0, 32]), type.bits)
+        abi_to_int_signed(bin_to_hex(data[0, 32]), type.bits)
       when Bool
         data[31] == BYTE_ONE
       when String

data/lib/abi_coder_rb/encode/encode_primitive_type.rb

@@ -39,7 +39,7 @@ module AbiCoderRb
     ## raise EncodingError or ArgumentError - why? why not?
     raise ArgumentError, "arg is not integer: #{arg}" unless arg.is_a?(Integer)
 
-    hex_to_bin(Utils.int_to_abi_signed_256bit(arg))
+    hex_to_bin(int_to_abi_signed_256bit(arg))
   end
 
   def encode_bool(arg)
@@ -97,62 +97,4 @@ module AbiCoderRb
       raise EncodingError, "Could not parse address: #{arg}"
     end
   end
-
-  private
-
-  def int_to_eth_abi(value, bits)
-    # 计算补码，如果是负数
-    value = 2**bits + value if value < 0
-
-    # 将值转换为十六进制字符串
-    hex = (value % 2**bits).to_s(16)
-    hex = "0#{hex}" if hex.length.odd?
-
-    # 确保字符串长度为16位（8个字节）
-    hex.rjust(bits / 4, "0")
-  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?
-  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.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
 end

data/lib/abi_coder_rb/utils.rb

@@ -1,111 +1,105 @@
 module AbiCoderRb
-  module Utils
-    class << self
-      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
-
-      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
-
-      # example:
-      #   lpad("hello", 'x', 10) => "xxxxxxhello"
-      def lpad(str, sym, len)
-        return str if str.size >= len
-
-        sym * (len - str.size) + str
-      end
-
-      def zpad(str, len)
-        lpad str, BYTE_ZERO, len
-      end
-
-      def ffpad(str, len)
-        lpad str, BYTE_FF, len
-      end
-
-      def uint_to_big_endian(num, size)
-        raise "Can only serialize integers" unless num.is_a?(Integer)
-        raise "Cannot serialize negative integers" if num.negative?
-        raise "Integer too large (does not fit in #{size} bytes)" if size && num >= 256**size
-
-        # Convert num into a binary string
-        s = if num.zero?
-              BYTE_EMPTY
-            else
-              hex = num.to_s(16)
-              hex = "0#{hex}" if hex.size.odd?
-              hex_to_bin hex
-            end
-
-        # Adjust the size of the binary string to match the specified `size` in bytes, if `size` is given.
-        s = size ? "#{BYTE_ZERO * [0, size - s.size].max}#{s}" : s
-
-        zpad s, size
-      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 int_to_abi_signed(value)
-        # 确保值在32位有符号整数范围内
-        raise "Value out of range" if value < -2**31 || value > 2**31 - 1
-
-        # 转换为32位有符号整数的二进制表示，然后转换为十六进制
-        hex_str = [value].pack("l>").unpack1("H*")
-
-        # 如果是正数，补齐前导零以达到64位长度
-        # 如果是负数，pack方法会产生正确的补码形式，但需要确保长度为64位
-        if value >= 0
-          hex_str.rjust(64, "0")
-        else
-          hex_str.rjust(64, "f")
-        end
-      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
+  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.2.0"
+  VERSION = "0.2.2"
 end

data/lib/abi_coder_rb.rb

@@ -9,6 +9,8 @@ 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
@@ -18,27 +20,12 @@ module AbiCoderRb
   BYTE_EMPTY = "".b.freeze
   BYTE_ZERO  = "\x00".b.freeze
   BYTE_ONE   = "\x01".b.freeze ## note: used for encoding bool for now
-  BYTE_FF  = "\xff".b.freeze
 
   UINT_MAX = 2**256 - 1   ## same as 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
   UINT_MIN = 0
   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.scan(/../).map { |x| x.hex.chr }.join
-  end
-  alias hex hex_to_bin
-
-  def bin_to_hex(bin) # convert binary string to hex string
-    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
-
   attr_accessor :before_encoding_action, :after_decoding_action
 
   def before_encoding(action)

data/lib/periphery/event_decoder.rb

@@ -0,0 +1,179 @@
+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)
+    return with_names ? {} : [] if @data_type_str == "()"
+
+    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,29 @@
 --- !ruby/object:Gem::Specification
 name: abi_coder_rb
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.2
 platform: ruby
 authors:
 - Aki Wu
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-11-25 00:00:00.000000000 Z
+date: 2023-11-30 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
@@ -41,7 +55,6 @@ files:
 - README.md
 - Rakefile
 - flatten.rb
-- flattened_abi_coder.rb
 - lib/.DS_Store
 - lib/abi_coder_rb.rb
 - lib/abi_coder_rb/.DS_Store
@@ -59,6 +72,7 @@ files:
 - 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:

data/flattened_abi_coder.rb

@@ -1,669 +0,0 @@
-# Generated from https://github.com/wuminzhe/abi_coder_rb
-module AbiCoderRb
-  def decode_array(type, data)
-    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 * size
-      start_positions = (1..size).map { |i| 32 + decode_uint256(data[32 * i, 32]) }
-      start_positions.push(data.size)
-      outputs = (0...size).map { |i| data[start_positions[i]...start_positions[i + 1]] }
-      outputs.map { |out| decode_type(subtype, out) }
-    else
-      (0...size).map { |i| decode_type(subtype, data[(32 + subtype.size * i)..]) }
-    end
-  end
-end
-module AbiCoderRb
-  def decode_fixed_array(type, data)
-    l = type.dim
-    subtype = type.subtype
-    if subtype.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) }
-    else
-      (0...l).map { |i| decode_type(subtype, data[subtype.size * i, subtype.size]) }
-    end
-  end
-end
-module AbiCoderRb
-  def decode_primitive_type(type, data)
-    result =
-      case type
-      when Uint
-        decode_uint256(data[0, 32])
-      when Int
-        Utils.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
-  def decode_uint256(bin)
-    bin_to_hex(bin).to_i(16)
-  end
-end
-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
-module AbiCoderRb
-  def decode(type_str, data)
-    raise DecodingError, "Empty data" if data.nil? || data.empty?
-    decode_type(Type.parse(type_str), data)
-  end
-  private
-  def decode_type(type, data)
-    case type
-    when Tuple ## todo: support empty (unit) tuple - why? why not?
-      decode_tuple(type, data)
-    when FixedArray # static-sized arrays
-      decode_fixed_array(type, data)
-    when Array
-      decode_array(type, data)
-    else
-      decode_primitive_type(type, data)
-    end
-  end
-end
-module AbiCoderRb
-  def encode_array(type, args)
-    raise ArgumentError, "arg must be an array" unless args.is_a?(::Array)
-    head = "".b
-    tail = "".b # 使用二进制字符串
-    head += encode_uint256(args.size)
-    subtype = type.subtype
-    args.each do |arg|
-      if subtype.dynamic?
-        head += encode_uint256(32 * args.size + tail.size)
-        tail += encode_type(subtype, arg)
-      else
-        head += encode_type(subtype, arg)
-      end
-    end
-    head + tail
-  end
-end
-module AbiCoderRb
-  def encode_fixed_array(type, args)
-    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
-    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
-module AbiCoderRb
-  def encode_primitive_type(type, arg)
-    arg = before_encoding_action.call(type.format, arg) if before_encoding_action
-    case type
-    when Uint
-      encode_uint(arg, type.bits)
-    when Int
-      encode_int(arg, type.bits)
-    when Bool
-      encode_bool(arg)
-    when String
-      encode_string(arg)
-    when FixedBytes
-      encode_bytes(arg, type.length)
-    when Bytes
-      encode_bytes(arg)
-    when Address
-      encode_address(arg)
-    else
-      raise EncodingError, "Unknown type: #{type}"
-    end
-  end
-  def encode_uint(arg, bits)
-    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_uint256(arg)
-    encode_uint(arg, 256)
-  end
-  def encode_int(arg, _bits)
-    raise ArgumentError, "arg is not integer: #{arg}" unless arg.is_a?(Integer)
-    hex_to_bin(Utils.int_to_abi_signed_256bit(arg))
-  end
-  def encode_bool(arg)
-    raise ArgumentError, "arg is not bool: #{arg}" unless arg.is_a?(TrueClass) || arg.is_a?(FalseClass)
-    lpad(arg ? BYTE_ONE : BYTE_ZERO) ## was  lpad_int( arg ? 1 : 0 )
-  end
-  def encode_string(arg)
-    raise EncodingError, "Expecting string: #{arg}" unless arg.is_a?(::String)
-    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
-    size  =  lpad_int(arg.size)
-    value =  rpad(arg, ceil32(arg.size))
-    size + value
-  end
-  def encode_bytes(arg, length = nil)
-    raise EncodingError, "Expecting string: #{arg}" unless arg.is_a?(::String)
-    arg = arg.b if arg.encoding != Encoding::BINARY
-    if length # fixed length type
-      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)
-    else # variable length type  (if length is nil)
-      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
-  end
-  def encode_address(arg)
-    if arg.is_a?(Integer)
-      lpad_int(arg)
-    elsif arg.size == 20
-      arg = arg.b if arg.encoding != Encoding::BINARY
-      lpad(arg)
-    elsif arg.size == 40
-      lpad_hex(arg)
-    elsif arg.size == 42 && arg[0, 2] == "0x" ## todo/fix: allow 0X too - why? why not?
-      lpad_hex(arg[2..-1])
-    else
-      raise EncodingError, "Could not parse address: #{arg}"
-    end
-  end
-  private
-  def int_to_eth_abi(value, bits)
-    value = 2**bits + value if value < 0
-    hex = (value % 2**bits).to_s(16)
-    hex = "0#{hex}" if hex.length.odd?
-    hex.rjust(bits / 4, "0")
-  end
-  def rpad(bin, l = 32) ## note: same as builtin String#ljust !!!
-    return bin if bin.size >= l
-    bin + BYTE_ZERO * (l - bin.size)
-  end
-  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
-  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.length.odd? # wasm, no .odd?
-    bin = hex_to_bin(hex)
-    lpad(bin)
-  end
-  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
-end
-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
-module AbiCoderRb
-  def encode(type, value)
-    raise EncodingError, "Value can not be nil" if value.nil?
-    parsed = Type.parse(type)
-    encode_type(parsed, value)
-  end
-  private
-  def encode_type(type, value)
-    if type.is_a?(Tuple)
-      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, value)
-    end
-  end
-end
-module AbiCoderRb
-  class Type
-    class ParseError < StandardError; end
-    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
-        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
-                     raise ParseError, "Unrecognized type base: #{base}"
-                   end
-        _parse_array_type(subtype, dims)
-      end
-      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
-        sub = subscript == "" ? nil : subscript.to_i
-        dims = _parse_dims(dimension)
-        [base, sub, dims]
-      end
-      def self._parse_dims(str)
-        dims = str.scan(/\[[0-9]*\]/)
-        dims.map do |dim|
-          size = dim[1...-1]
-          size == "" ? -1 : size.to_i
-        end
-      end
-      def self._parse_array_type(subtype, dims)
-        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"
-          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
-          raise ParseError, "Unrecognized type base: #{base}"
-        end
-      end
-      def self._parse_tuple_type(str)
-        depth     = 0
-        collected = []
-        current   = ""
-        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
-module AbiCoderRb
-  class Type
-    def self.parse(type) ## convenience helper
-      Parser.parse(type)
-    end
-    def size
-    end
-    def dynamic?
-      size.nil?
-    end
-    def format
-    end
-  end
-  class Address < Type
-    def size
-      32
-    end
-    def format
-      "address"
-    end
-    def ==(other)
-      other.is_a?(Address)
-    end
-  end # class Address
-  class Bytes < Type
-    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
-    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
-    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
-    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
-    def size
-      32
-    end
-    def format
-      "bool"
-    end
-    def ==(other)
-      other.is_a?(Bool)
-    end
-  end # class Bool
-  class String < Type
-    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
-    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?
-          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
-module AbiCoderRb
-  module Utils
-    class << self
-      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
-      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
-      def lpad(str, sym, len)
-        return str if str.size >= len
-        sym * (len - str.size) + str
-      end
-      def zpad(str, len)
-        lpad str, BYTE_ZERO, len
-      end
-      def ffpad(str, len)
-        lpad str, BYTE_FF, len
-      end
-      def uint_to_big_endian(num, size)
-        raise "Can only serialize integers" unless num.is_a?(Integer)
-        raise "Cannot serialize negative integers" if num.negative?
-        raise "Integer too large (does not fit in #{size} bytes)" if size && num >= 256**size
-        s = if num.zero?
-              BYTE_EMPTY
-            else
-              hex = num.to_s(16)
-              hex = "0#{hex}" if hex.size.odd?
-              hex_to_bin hex
-            end
-        s = size ? "#{BYTE_ZERO * [0, size - s.size].max}#{s}" : s
-        zpad s, size
-      end
-      def int_to_abi_signed_256bit(value)
-        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)
-        hex_str.rjust(64, "0")
-      end
-      def int_to_abi_signed(value)
-        raise "Value out of range" if value < -2**31 || value > 2**31 - 1
-        hex_str = [value].pack("l>").unpack1("H*")
-        if value >= 0
-          hex_str.rjust(64, "0")
-        else
-          hex_str.rjust(64, "f")
-        end
-      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
-  end
-end
-module AbiCoderRb
-  VERSION = "0.1.0"
-end
-module AbiCoderRb
-  class DecodingError < StandardError; end
-  class EncodingError < StandardError; end
-  class ValueError < StandardError; end
-  class ValueOutOfBounds < ValueError; end
-  BYTE_EMPTY = "".b.freeze
-  BYTE_ZERO  = "\x00".b.freeze
-  BYTE_ONE   = "\x01".b.freeze ## note: used for encoding bool for now
-  BYTE_FF  = "\xff".b.freeze
-  UINT_MAX = 2**256 - 1   ## same as 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-  UINT_MIN = 0
-  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.scan(/../).map { |x| x.hex.chr }.join
-  end
-  alias hex hex_to_bin
-  def bin_to_hex(bin) # convert binary string to hex string
-    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
-  attr_accessor :before_encoding_action, :after_decoding_action
-  def before_encoding(action)
-    self.before_encoding_action = action
-  end
-  def after_decoding(action)
-    self.after_decoding_action = action
-  end
-end