abi_coder_rb 0.1.0 → 0.2.0

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
+        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
@@ -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(Utils.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)
@@ -100,6 +100,18 @@ module AbiCoderRb
 
   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
@@ -124,8 +136,8 @@ module AbiCoderRb
     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*")
+    hex = "0#{hex}" if hex.length.odd? # wasm, no .odd?
+    bin = hex_to_bin(hex)
 
     lpad(bin)
   end
@@ -135,7 +147,7 @@ module AbiCoderRb
     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*")
+    bin = hex_to_bin(hex)
 
     lpad(bin)
   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,111 @@
+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
+    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.0"
 end

data/lib/abi_coder_rb.rb

@@ -2,6 +2,8 @@
 
 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"
@@ -13,17 +15,10 @@ module AbiCoderRb
   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
+  BYTE_FF  = "\xff".b.freeze
 
   UINT_MAX = 2**256 - 1   ## same as 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
   UINT_MIN = 0
@@ -32,12 +27,25 @@ module AbiCoderRb
 
   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*")
+    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.unpack1("H*")
+    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
-  alias bin bin_to_hex
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: abi_coder_rb
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Aki Wu
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-11-13 00:00:00.000000000 Z
-dependencies: []
+date: 2023-11-25 00:00:00.000000000 Z
+dependencies:
+- !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 +40,8 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- flatten.rb
+- flattened_abi_coder.rb
 - lib/.DS_Store
 - lib/abi_coder_rb.rb
 - lib/abi_coder_rb/.DS_Store
@@ -41,6 +57,7 @@ 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
 - sig/abi_coder_rb.rbs
 homepage: https://github.com/wuminzhe/abi_coder_rb