scale_rb 0.4.1 → 0.5.0

data/lib/codec.rb

@@ -1,450 +0,0 @@
-# frozen_string_literal: true
-
-module ScaleRb
-  class Error < StandardError; end
-  class NotImplemented < Error; end
-  class NilTypeError < Error; end
-  class TypeParseError < Error; end
-  class NotEnoughBytesError < Error; end
-  class InvalidBytesError < Error; end
-  class Unreachable < Error; end
-  class IndexOutOfRangeError < Error; end
-  class LengthNotEqualErr < Error; end
-  class InvalidValueError < Error; end
-end
-
-# TODO: set, bitvec
-module ScaleRb
-  class << self
-    def type_def?(type)
-      type.instance_of?(String) && (
-        bytes?(type) ||
-        boolean?(type) ||
-        string?(type) ||
-        compact?(type) ||
-        int?(type) ||
-        uint?(type) ||
-        option?(type) ||
-        array?(type) ||
-        vec?(type) ||
-        tuple?(type)
-      ) ||
-        type.instance_of?(Hash)
-    end
-
-    def bytes?(type)
-      type.downcase == 'bytes'
-    end
-
-    def boolean?(type)
-      type.downcase == 'bool' || type.downcase == 'boolean'
-    end
-
-    def string?(type)
-      type.downcase == 'str' || type.downcase == 'string' || type.downcase == 'text' || type.downcase == 'type'
-    end
-
-    def compact?(type)
-      type.downcase == 'compact' ||
-        (type[0..7].downcase == 'compact<' && type[-1] == '>')
-    end
-
-    def int?(type)
-      type[0].downcase == 'i' && type[1..] =~ /\A(8|16|32|64|128|256|512)\z/
-    end
-
-    def uint?(type)
-      type[0].downcase == 'u' && type[1..] =~ /\A(8|16|32|64|128|256|512)\z/
-    end
-
-    def option?(type)
-      type[0..6].downcase == 'option<' && type[-1] == '>'
-    end
-
-    def array?(type)
-      type[0] == '[' && type[-1] == ']'
-    end
-
-    def vec?(type)
-      type[0..3].downcase == 'vec<' && type[-1] == '>'
-    end
-
-    def tuple?(type)
-      type[0] == '(' && type[-1] == ')'
-    end
-
-    def struct?(type)
-      type.instance_of?(Hash)
-    end
-
-    def enum?(type)
-      type.instance_of?(Hash) && type.key?(:_enum)
-    end
-  end
-end
-
-module ScaleRb
-  class << self
-    def parse_option(type)
-      type.scan(/\A[O|o]ption<(.+)>\z/).first.first
-    end
-
-    def parse_array(type)
-      scan_out = type.scan(/\A\[\s*(.+)\s*;\s*(\d+)\s*\]\z/)
-      raise ScaleRb::TypeParseError, type if scan_out.empty?
-      raise ScaleRb::TypeParseError, type if scan_out[0].length != 2
-
-      inner_type = scan_out[0][0]
-      length = scan_out[0][1].to_i
-      [inner_type, length]
-    end
-
-    def parse_vec(type)
-      type.scan(/\A[V|v]ec<(.+)>\z/).first.first
-    end
-
-    def parse_tuple(type)
-      type.scan(/\A\(\s*(.+)\s*\)\z/)[0][0].split(',').map(&:strip)
-    end
-  end
-end
-
-# Helper functions
-module ScaleRb
-  class << self
-    def _get_final_type_from_registry(registry, type)
-      raise "Wrong lookup type #{type.class}" if !type.instance_of?(String) && !type.instance_of?(Hash)
-
-      return if type.instance_of?(Hash)
-
-      mapped = registry._get(type) # mapped: String(name, type_def) | Hash(type_def: struct, enum) | nil
-
-      return if mapped.nil?
-      return mapped if type_def?(mapped)
-
-      _get_final_type_from_registry(registry, mapped)
-    end
-
-    def _decode_types(types, bytes, registry)
-      _decode_each(types, bytes) do |type, remaining_bytes|
-        decode(type, remaining_bytes, registry)
-      end
-    end
-
-    def _decode_each(types, bytes, &decode)
-      remaining_bytes = bytes
-      values = types.map do |type|
-        value, remaining_bytes = decode.call(type, remaining_bytes)
-        value
-      end
-      [values, remaining_bytes]
-    end
-
-    def _do_decode_compact(bytes)
-      case bytes[0] & 3
-      when 0
-        [bytes[0] >> 2, bytes[1..]]
-      when 1
-        [bytes[0..1]._flip._to_uint >> 2, bytes[2..]]
-      when 2
-        [bytes[0..3]._flip._to_uint >> 2, bytes[4..]]
-      when 3
-        length = 4 + (bytes[0] >> 2)
-        [bytes[1..length]._flip._to_uint, bytes[length + 1..]]
-      else
-        raise Unreachable, 'type: Compact'
-      end
-    end
-
-    def _encode_each(types, values, &encode)
-      _encode_each_without_merge(types, values, &encode).flatten
-    end
-
-    def _encode_each_without_merge(types, values, &encode)
-      raise LengthNotEqualErr, "types: #{types}, values: #{values.inspect}" if types.length != values.length
-
-      types.map.with_index do |type, i|
-        encode.call(type, values[i])
-      end
-    end
-
-    def _encode_types(types, values, registry = {})
-      _encode_each(types, values) do |type, value|
-        encode(type, value, registry)
-      end
-    end
-
-    def _encode_each_with_hashers(types, values, hashers, &encode)
-      if !hashers.nil? && hashers.length != types.length
-        raise ScaleRb::LengthNotEqualErr, "types length: #{types.length}, hashers length: #{hashers.length}"
-      end
-
-      bytes_array = ScaleRb._encode_each_without_merge(types, values, &encode)
-      bytes_array.each_with_index.reduce([]) do |memo, (bytes, i)|
-        memo + Hasher.apply_hasher(hashers[i], bytes)
-      end
-    end
-  end
-end
-
-module ScaleRb
-  # Decode
-  class << self
-    def decode(type, bytes, registry = {})
-      # logger.debug '--------------------------------------------------'
-      # debug 'decoding type', type
-      # debug 'bytes', bytes&.length
-
-      if type.instance_of?(String)
-        return decode_bytes(bytes) if bytes?(type) # Bytes
-        return decode_boolean(bytes) if boolean?(type) # Boolean
-        return decode_string(bytes) if string?(type) # String
-        return decode_int(type, bytes) if int?(type) # i8, i16...
-        return decode_uint(type, bytes) if uint?(type) # u8, u16...
-        return decode_compact(bytes) if compact?(type) # Compact<>
-        return decode_option(type, bytes, registry) if option?(type) # Option<>
-        return decode_array(type, bytes, registry) if array?(type) # [u8; 3]
-        return decode_vec(type, bytes, registry) if vec?(type) # Vec<u8>
-        return decode_tuple(type, bytes, registry) if tuple?(type) # (u8, u8)
-
-        # search the type from registry if not the types above
-        registry_type = _get_final_type_from_registry(registry, type)
-        return decode(registry_type, bytes, registry) if registry_type
-      elsif type.instance_of?(Hash)
-        return decode_enum(type, bytes, registry) if enum?(type)
-        return decode_struct(type, bytes, registry) if struct?(type)
-      end
-
-      raise NotImplemented, "type: #{type.inspect}"
-    end
-
-    def decode_bytes(bytes)
-      length, remaining_bytes = _do_decode_compact(bytes)
-      value = remaining_bytes[0...length]._to_hex
-      # debug 'length', length
-      # debug 'value', value
-      [
-        value,
-        remaining_bytes[length..]
-      ]
-    end
-
-    def decode_boolean(bytes)
-      value =
-        if bytes[0] == 0x00
-          false
-        elsif bytes[0] == 0x01
-          true
-        else
-          raise InvalidBytesError, 'type: Boolean'
-        end
-      # debug 'value', value
-      [value, bytes[1..]]
-    end
-
-    def decode_string(bytes)
-      length, remaining_bytes = _do_decode_compact(bytes)
-      raise NotEnoughBytesError, 'type: String' if remaining_bytes.length < length
-
-      value = remaining_bytes[0...length]._to_utf8
-      # debug 'byte length', length
-      # debug 'value', value.inspect
-      [
-        value,
-        remaining_bytes[length..]
-      ]
-    end
-
-    def decode_int(type, bytes)
-      bit_length = type[1..].to_i
-      byte_length = bit_length / 8
-      raise NotEnoughBytesError, "type: #{type}" if bytes.length < byte_length
-
-      value = bytes[0...byte_length]._flip._to_int(bit_length)
-      # debug 'value', value
-      [
-        value,
-        bytes[byte_length..]
-      ]
-    end
-
-    def decode_uint(type_def, bytes)
-      bit_length = type_def[1..].to_i
-      byte_length = bit_length / 8
-      raise NotEnoughBytesError, "type: #{type_def}" if bytes.length < byte_length
-
-      value = bytes[0...byte_length]._flip._to_uint
-      # debug 'value', value
-      [
-        value,
-        bytes[byte_length..]
-      ]
-    end
-
-    def decode_compact(bytes)
-      _do_decode_compact(bytes)
-      # debug 'value', result[0]
-    end
-
-    def decode_option(type_def, bytes, registry = {})
-      inner_type = parse_option(type_def)
-
-      return [nil, bytes[1..]] if bytes[0] == 0x00
-      return decode(inner_type, bytes[1..], registry) if bytes[0] == 0x01
-
-      raise InvalidBytesError, "type: #{type_def}"
-    end
-
-    def decode_array(type_def, bytes, registry = {})
-      inner_type, length = parse_array(type_def)
-      _decode_types([inner_type] * length, bytes, registry)
-    end
-
-    def decode_vec(type_def, bytes, registry = {})
-      inner_type = parse_vec(type_def)
-      length, remaining_bytes = _do_decode_compact(bytes)
-      # debug 'length', length
-      _decode_types([inner_type] * length, remaining_bytes, registry)
-    end
-
-    def decode_tuple(type_def, bytes, registry = {})
-      inner_types = parse_tuple(type_def)
-      _decode_types(inner_types, bytes, registry)
-    end
-
-    # TODO: custom index?
-    # {
-    #   _enum: {
-    #     name1: type1,
-    #     name2: type2
-    #   }
-    # }
-    # or
-    # {
-    #   _enum: ['name1', 'name2']
-    # }
-    def decode_enum(type_def, bytes, registry = {})
-      index = bytes[0]
-
-      items = type_def[:_enum]
-      raise IndexOutOfRangeError, "type: #{type_def}" if index > items.length - 1
-
-      item = items.to_a[index] # 'name' or [:name, inner_type]
-      # debug 'value', item.inspect
-      return [item, bytes[1..]] if item.instance_of?(String)
-
-      value, remaining_bytes = decode(item[1], bytes[1..], registry)
-      [
-        { item[0].to_sym => value },
-        remaining_bytes
-      ]
-    end
-
-    def decode_struct(struct, bytes, registry = {})
-      values, remaining_bytes = _decode_types(struct.values, bytes, registry)
-      [
-        [struct.keys, values].transpose.to_h,
-        remaining_bytes
-      ]
-    end
-  end
-
-  # Encode
-  class << self
-    def encode(type, value, registry = {})
-      # logger.debug '--------------------------------------------------'
-      # debug 'encoding type', type
-      # debug 'value', value
-
-      if type.instance_of?(String)
-        return encode_bytes(value) if bytes?(type)
-        return encode_boolean(value) if boolean?(type)
-        return encode_string(value) if string?(type)
-        return encode_compact(value) if compact?(type)
-        return encode_uint(type, value) if uint?(type)
-        return encode_option(type, value, registry) if option?(type)
-        return encode_array(type, value, registry) if array?(type)
-        return encode_vec(type, value, registry) if vec?(type)
-        return encode_tuple(type, value, registry) if tuple?(type)
-
-        registry_type = _get_final_type_from_registry(registry, type)
-        return encode(registry_type, value, registry) if registry_type
-      elsif type.instance_of?(Hash)
-        return encode_enum(type, value, registry) if enum?(type)
-        return encode_struct(type, value, registry) if struct?(type)
-      end
-
-      raise NotImplemented, "type: #{type}, value: #{value.inspect}"
-    end
-
-    def encode_bytes(value)
-      encode_compact(value.length) + value
-    end
-
-    def encode_boolean(value)
-      return [0x00] if value == false
-      return [0x01] if value == true
-
-      raise InvalidValueError, "type: Boolean, value: #{value.inspect}"
-    end
-
-    def encode_string(string)
-      body = string.unpack('C*')
-      prefix = encode_compact(body.length)
-      prefix + body
-    end
-
-    def encode_compact(value)
-      return [value << 2] if (value >= 0) && (value < 64)
-      return ((value << 2) + 1)._to_bytes._flip if value < 2**14
-      return ((value << 2) + 2)._to_bytes._flip if value < 2**30
-
-      bytes = value._to_bytes._flip
-      [(((bytes.length - 4) << 2) + 3)] + bytes
-    end
-
-    def encode_uint(type, value)
-      raise InvalidValueError, "type: #{type}, value: #{value.inspect}" unless value.instance_of?(Integer)
-
-      bit_length = type[1..].to_i
-      value._to_bytes(bit_length)._flip
-    end
-
-    def encode_option(type, value, registry = {})
-      return [0x00] if value.nil?
-
-      inner_type = type.scan(/\A[O|o]ption<(.+)>\z/).first.first
-      [0x01] + encode(inner_type, value, registry)
-    end
-
-    def encode_array(type, array, registry = {})
-      inner_type, length = parse_array(type)
-      raise LengthNotEqualErr, "type: #{type}, value: #{array.inspect}" if length != array.length
-
-      _encode_types([inner_type] * length, array, registry)
-    end
-
-    def encode_vec(type, array, registry = {})
-      inner_type = type.scan(/\A[V|v]ec<(.+)>\z/).first.first
-      length_bytes = encode_compact(array.length)
-      length_bytes + _encode_types([inner_type] * array.length, array, registry)
-    end
-
-    def encode_tuple(tuple_type, tuple, registry = {})
-      inner_types = tuple_type.scan(/\A\(\s*(.+)\s*\)\z/)[0][0].split(',').map(&:strip)
-      _encode_types(inner_types, tuple, registry)
-    end
-
-    def encode_enum(enum_type, enum, registry = {})
-      key = enum.keys.first
-      value = enum.values.first
-      value_type = enum_type[:_enum][key]
-      index = enum_type[:_enum].keys.index(key)
-      encode_uint('u8', index) + encode(value_type, value, registry)
-    end
-
-    def encode_struct(struct_type, struct, registry = {})
-      _encode_types(struct_type.values, struct.values, registry)
-    end
-  end
-end

data/lib/metadata/metadata.rb

@@ -1,137 +0,0 @@
-# frozen_string_literal: true
-
-module ScaleRb
-  module Metadata
-    class << self
-      def decode_metadata(bytes)
-        metadata, = ScaleRb.decode('MetadataTop', bytes, TYPES)
-        metadata
-      end
-
-      def build_registry(metadata)
-        raise ScaleRb::NotImplemented, metadata._get(:metadata).keys.first unless metadata._get(:metadata)._key?(:v14)
-
-        metadata_v14 = metadata._get(:metadata)._get(:v14)
-        MetadataV14.build_registry(metadata_v14)
-      end
-
-      def get_module(pallet_name, metadata)
-        version = metadata._get(:metadata).keys.first
-        raise ScaleRb::NotImplemented, metadata._get(:metadata).keys.first unless %w[v9 v10 v11 v12 v13
-                                                                                     v14].include?(version.to_s)
-
-        Metadata.const_get("Metadata#{version.upcase}").get_module(pallet_name, metadata)
-      end
-
-      def get_module_by_index(pallet_index, metadata)
-        version = metadata._get(:metadata).keys.first
-        raise ScaleRb::NotImplemented, metadata._get(:metadata).keys.first unless %w[v9 v10 v11 v12 v13
-                                                                                     v14].include?(version.to_s)
-
-        Metadata.const_get("Metadata#{version.upcase}").get_module_by_index(pallet_index, metadata)
-      end
-
-      def get_storage_item(pallet_name, item_name, metadata)
-        version = metadata._get(:metadata).keys.first
-        raise ScaleRb::NotImplemented, metadata._get(:metadata).keys.first unless %w[v9 v10 v11 v12 v13
-                                                                                     v14].include?(version.to_s)
-
-        Metadata.const_get("Metadata#{version.upcase}").get_storage_item(pallet_name, item_name, metadata)
-      end
-
-      def get_calls_type(pallet_name, metadata)
-        version = metadata._get(:metadata).keys.first
-        raise ScaleRb::NotImplemented, metadata._get(:metadata).keys.first unless %w[v9 v10 v11 v12 v13
-                                                                                     v14].include?(version.to_s)
-
-        Metadata.const_get("Metadata#{version.upcase}").get_calls_type(pallet_name, metadata)
-      end
-
-      def get_calls_type_id(pallet_name, metadata)
-        version = metadata._get(:metadata).keys.first
-        raise ScaleRb::NotImplemented, metadata._get(:metadata).keys.first unless %w[v9 v10 v11 v12 v13
-                                                                                     v14].include?(version.to_s)
-
-        Metadata.const_get("Metadata#{version.upcase}").get_calls_type_id(pallet_name, metadata)
-      end
-
-      def get_call_type(pallet_name, call_name, metadata)
-        version = metadata._get(:metadata).keys.first
-        raise ScaleRb::NotImplemented, metadata._get(:metadata).keys.first unless %w[v9 v10 v11 v12 v13
-                                                                                     v14].include?(version.to_s)
-
-        Metadata.const_get("Metadata#{version.upcase}").get_call_type(pallet_name, call_name, metadata)
-      end
-
-      # call examples:
-      #   {:pallet_name=>"Deposit", :call_name=>"Claim", :call=>["claim", []]}
-      #   {:pallet_name=>"Balances", :call_name=>"Transfer", :call=>[{:transfer=>{:dest=>[10, 18, 135, 151, 117, 120, 248, 136, 189, 193, 199, 98, 119, 129, 175, 28, 192, 0, 230, 171], :value=>11000000000000000000}}, []]}
-      def encode_call(call, metadata)
-        calls_type_id = get_calls_type_id(call[:pallet_name], metadata)
-        pallet_index = get_module(call[:pallet_name], metadata)._get(:index)
-        [pallet_index] + PortableCodec.encode(calls_type_id, call[:call].first, build_registry(metadata))
-      end
-
-      # callbytes's structure is: pallet_index + call_index + argsbytes
-      #
-      # callbytes examples:
-      #   "0x0901"._to_bytes
-      #   "0x05000a1287977578f888bdc1c7627781af1cc000e6ab1300004c31b8d9a798"._to_bytes
-      def decode_call(callbytes, metadata)
-        pallet_index = callbytes[0]
-        pallet = get_module_by_index(pallet_index, metadata)
-
-        pallet_name = pallet._get(:name)
-
-        # Remove the pallet_index
-        # The callbytes we used below should not contain the pallet index.
-        # This is because the pallet index is not part of the call type.
-        # Its structure is: call_index + call_args
-        callbytes_without_pallet_index = callbytes[1..]
-        calls_type_id = pallet._get(:calls)._get(:type)
-        decoded = PortableCodec.decode(
-          calls_type_id,
-          callbytes_without_pallet_index,
-          build_registry(metadata)
-        )
-
-        {
-          pallet_name: pallet_name,
-          call_name: decoded.first.is_a?(String) ? decoded.first._to_camel : decoded.first.keys.first.to_s._to_camel,
-          call: decoded
-        }
-      end
-    end
-
-    TYPES = {
-      'MetadataTop' => {
-        magicNumber: 'U32',
-        metadata: 'Metadata'
-      },
-      'Metadata' => {
-        _enum: {
-          v0: 'MetadataV0',
-          v1: 'MetadataV1',
-          v2: 'MetadataV2',
-          v3: 'MetadataV3',
-          v4: 'MetadataV4',
-          v5: 'MetadataV5',
-          v6: 'MetadataV6',
-          v7: 'MetadataV7',
-          v8: 'MetadataV8',
-          v9: 'MetadataV9',
-          v10: 'MetadataV10',
-          v11: 'MetadataV11',
-          v12: 'MetadataV12',
-          v13: 'MetadataV13',
-          v14: 'MetadataV14'
-        }
-      }
-    }.merge(MetadataV14::TYPES)
-            .merge(MetadataV13::TYPES)
-            .merge(MetadataV12::TYPES)
-            .merge(MetadataV11::TYPES)
-            .merge(MetadataV10::TYPES)
-            .merge(MetadataV9::TYPES)
-  end
-end

data/lib/monkey_patching.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-# https://www.rubyguides.com/2017/01/read-binary-data/
-class String
-  def _to_bytes
-    data = start_with?('0x') ? self[2..] : self
-    raise 'Not valid hex string' if data =~ /[^\da-f]+/i
-
-    data = "0#{data}" if data.length.odd?
-    data.scan(/../).map(&:hex)
-  end
-
-  def _to_camel
-    split('_').collect(&:capitalize).join
-  end
-
-  def _underscore
-    gsub(/::/, '/')
-      .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-      .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-      .tr('-', '_')
-      .downcase
-  end
-end
-
-class Integer
-  def _to_bytes(bit_length = nil)
-    return to_s(16)._to_bytes unless bit_length
-
-    hex = to_s(16).rjust(bit_length / 4, '0')
-    hex._to_bytes
-  end
-
-  # unsigned to signed
-  def _to_signed(bit_length)
-    unsigned_mid = 2**(bit_length - 1)
-    unsigned_ceiling = 2**bit_length
-    self >= unsigned_mid ? self - unsigned_ceiling : self
-  end
-
-  # signed to unsigned
-  def _to_unsigned(bit_length)
-    unsigned_mid = 2**(bit_length - 1)
-    unsigned_ceiling = 2**bit_length
-    raise 'out of scope' if self >= unsigned_mid || self <= -unsigned_mid
-
-    negative? ? unsigned_ceiling + self : self
-  end
-
-  # unix timestamp to utc
-  def _to_utc
-    Time.at(self).utc.asctime
-  end
-
-  # utc to unix timestamp
-  def _from_utc(utc_asctime)
-    Time.parse(utc_asctime)
-  end
-end
-
-class Array
-  def _to_hex
-    raise 'Not a byte array' unless _byte_array?
-
-    reduce('0x') { |hex, byte| hex + byte.to_s(16).rjust(2, '0') }
-  end
-
-  def _to_bin
-    raise 'Not a byte array' unless _byte_array?
-
-    reduce('0b') { |bin, byte| bin + byte.to_s(2).rjust(8, '0') }
-  end
-
-  def _to_utf8
-    raise 'Not a byte array' unless _byte_array?
-
-    pack('C*').force_encoding('utf-8')
-  end
-
-  def _to_uint
-    _to_hex.to_i(16)
-  end
-
-  def _to_int(bit_length)
-    _to_uint._to_signed(bit_length)
-  end
-
-  def _flip
-    reverse
-  end
-
-  def _byte_array?
-    all? { |e| e >= 0 and e <= 255 }
-  end
-end
-
-class Hash
-  def _key?(key)
-    if key.instance_of?(String)
-      key?(key) || key?(key.to_sym)
-    else
-      key?(key) || key?(key.to_s)
-    end
-  end
-
-  def _get(key)
-    if key.instance_of?(String)
-      self[key] || self[key.to_sym]
-    elsif key.instance_of?(Symbol)
-      self[key] || self[key.to_s]
-    else
-      self[key]
-    end
-  end
-end