scale.rb 0.1.0 → 0.2.0

data/lib/metadata/metadata_v8.rb

@@ -1,20 +1,50 @@
 module Scale
   module Types
-
     class MetadataV8
       include SingleValue
+      attr_accessor :call_index, :event_index
+
+      def initialize(value)
+        @call_index = {}
+        @event_index = {}
+        super(value)
+      end
+
       def self.decode(scale_bytes)
-        modules = type_of("Vec<MetadataV8Module>").decode(scale_bytes).value;
-        result = {
-          magicNumber: 1635018093,
+        modules = Scale::Types.type_of("Vec<MetadataV8Module>").decode(scale_bytes).value
+
+        value = {
+          magicNumber: 1_635_018_093,
           metadata: {
-            V8: {
-              modules: modules.map(&:value)
-            }
+            version: 8,
+            modules: modules.map(&:value)
           }
         }
 
-        MetadataV8.new(result)
+        result = MetadataV8.new(value)
+
+        call_module_index = 0
+        event_module_index = 0
+
+        modules.map(&:value).each do |m|
+          if m[:calls]
+            m[:calls].each_with_index do |call, index|
+              call[:lookup] = "%02x%02x" % [call_module_index, index]
+              result.call_index[call[:lookup]] = [m, call]
+            end
+            call_module_index += 1
+          end
+
+          if m[:events]
+            m[:events].each_with_index do |event, index|
+              event[:lookup] = "%02x%02x" % [call_module_index, index]
+              result.event_index[event[:lookup]] = [m, event]
+            end
+            event_module_index += 1
+          end
+        end
+
+        result
       end
     end
 
@@ -24,7 +54,7 @@ module Scale
         name = String.decode(scale_bytes).value
 
         result = {
-          name: name,
+          name: name
         }
 
         has_storage = Bool.decode(scale_bytes).value
@@ -36,18 +66,18 @@ module Scale
 
         has_calls = Bool.decode(scale_bytes).value
         if has_calls
-          calls = type_of("Vec<MetadataModuleCall>").decode(scale_bytes).value
+          calls = Scale::Types.type_of("Vec<MetadataModuleCall>").decode(scale_bytes).value
           result[:calls] = calls.map(&:value)
         end
 
         has_events = Bool.decode(scale_bytes).value
         if has_events
-          events = type_of("Vec<MetadataModuleEvent>").decode(scale_bytes).value
+          events = Scale::Types.type_of("Vec<MetadataModuleEvent>").decode(scale_bytes).value
           result[:events] = events.map(&:value)
         end
 
-        result[:constants] = type_of("Vec<MetadataV7ModuleConstants>").decode(scale_bytes).value.map(&:value)
-        result[:errors] = type_of("Vec<MetadataModuleError>").decode(scale_bytes).value.map(&:value)
+        result[:constants] = Scale::Types.type_of("Vec<MetadataV7ModuleConstants>").decode(scale_bytes).value.map(&:value)
+        result[:errors] = Scale::Types.type_of("Vec<MetadataModuleError>").decode(scale_bytes).value.map(&:value)
 
         MetadataV8Module.new(result)
       end
@@ -58,12 +88,11 @@ module Scale
       def self.decode(scale_bytes)
         result = {
           name: String.decode(scale_bytes).value,
-          docs: type_of("Vec<String>").decode(scale_bytes).value.map(&:value)
+          docs: Scale::Types.type_of("Vec<String>").decode(scale_bytes).value.map(&:value)
         }
 
         MetadataModuleError.new(result)
       end
     end
-
   end
 end

data/lib/metadata/metadata_v9.rb

@@ -1,22 +1,51 @@
 module Scale
   module Types
-
     class MetadataV9
       include SingleValue
+      attr_accessor :call_index, :event_index
+
+      def initialize(value)
+        @call_index = {}
+        @event_index = {}
+        super(value)
+      end
+
       def self.decode(scale_bytes)
-        modules = type_of("Vec<MetadataV8Module>").decode(scale_bytes).value;
-        result = {
-          magicNumber: 1635018093,
+        modules = Scale::Types.type_of("Vec<MetadataV8Module>").decode(scale_bytes).value
+
+        value = {
+          magicNumber: 1_635_018_093,
           metadata: {
-            V9: {
-              modules: modules.map(&:value)
-            }
+            version: 9,
+            modules: modules.map(&:value)
           }
         }
 
-        MetadataV9.new(result)
+        result = MetadataV9.new(value)
+
+        call_module_index = 0
+        event_module_index = 0
+
+        modules.map(&:value).each do |m|
+          if m[:calls]
+            m[:calls].each_with_index do |call, index|
+              call[:lookup] = "%02x%02x" % [call_module_index, index]
+              result.call_index[call[:lookup]] = [m, call]
+            end
+            call_module_index += 1
+          end
+
+          if m[:events]
+            m[:events].each_with_index do |event, index|
+              event[:lookup] = "%02x%02x" % [call_module_index, index]
+              result.event_index[event[:lookup]] = [m, event]
+            end
+            event_module_index += 1
+          end
+        end
+
+        result
       end
     end
-
   end
 end

data/lib/scale.rb

@@ -1,19 +1,119 @@
 require "scale/version"
 
 require "substrate_common"
+require "json"
+require "active_support"
+require "active_support/core_ext/string"
+require "singleton"
 
 require "scale/base"
 require "scale/types"
+require "scale/block"
 
 require "metadata/metadata"
+require "metadata/metadata_v0"
+require "metadata/metadata_v1"
+require "metadata/metadata_v2"
 require "metadata/metadata_v3"
+require "metadata/metadata_v4"
+require "metadata/metadata_v5"
+require "metadata/metadata_v6"
 require "metadata/metadata_v7"
 require "metadata/metadata_v8"
 require "metadata/metadata_v9"
 require "metadata/metadata_v10"
+require "metadata/metadata_v11"
 
 module Scale
   class Error < StandardError; end
+
+  class TypeRegistry
+    include Singleton
+    attr_accessor :types
+
+    def load(spec_name = nil, spec_version = nil)
+      @spec_name = spec_name
+      @spec_version = spec_version
+      @types = load_types(spec_name, spec_version.nil? ? nil : spec_version.to_i)
+
+      true
+    end
+
+    def get(type_name)
+      type = @types[type_name]
+      return Scale::Types.type_of(type_name) if type.nil?
+      type
+    end
+
+    private 
+    def load_types(spec_name, spec_version)
+      # hard coded types
+      coded_types = Scale::Types
+        .constants
+        .select { |c| Scale::Types.const_get(c).is_a? Class }
+        .map { |type_name| [type_name.to_s, type_name.to_s] }
+        .to_h
+        .transform_values {|type| Scale::Types.constantize(type) }
+
+      return coded_types if spec_name.nil?
+
+      # default spec types
+      default_types = load_chain_spec_types("default", spec_version).transform_values do |type|
+        Scale::Types.type_convert(type, coded_types)
+      end
+      default_types = coded_types.merge(default_types)
+
+      # chain spec types
+      if spec_name != "default"
+        spec_types = load_chain_spec_types(spec_name, spec_version)
+        spec_types.transform_values do |type|
+          Scale::Types.type_convert(type, default_types)
+        end
+        default_types.merge(spec_types)
+      else
+        default_types
+      end
+    end
+
+    def load_chain_spec_types(spec_name, spec_version)
+      file = File.join File.expand_path("../..", __FILE__), "lib", "type_registry", "#{spec_name}.json"
+      json_string = File.open(file).read
+      json = JSON.parse(json_string)
+
+      types = {}
+      runtime_id = json["runtime_id"]
+      versioning = json["versioning"] || []
+
+      if runtime_id.nil? || (spec_version && spec_version >= runtime_id)
+        types = json["types"]
+      end
+
+      if spec_version
+        versioning.each do |item|
+          if spec_version >= item["runtime_range"][0] && spec_version <= (item["runtime_range"][1] || 1073741823)
+            types.merge!(item["types"])
+          end
+        end
+      end
+
+      types.transform_values! do |type|
+        if type.class != ::String
+          Scale::Types.constantize(type)
+        else
+          t = Scale::Types.type_convert(type, types)
+          if t.class == ::String
+            Scale::Types.constantize(t)
+          else
+            t
+          end
+        end
+      end
+
+      types
+    end
+
+  end
+
   # TODO: == implement
 
   class Bytes
@@ -21,16 +121,16 @@ module Scale
     attr_reader :offset
 
     def initialize(data)
-      if data.class == Array and data.is_byte_array?
+      if (data.class == Array) && data.is_byte_array?
         @bytes = data
-      elsif data.class == String and data.start_with?('0x') and data.length % 2 == 0
+      elsif (data.class == String) && data.start_with?("0x") && (data.length % 2 == 0)
         arr = data[2..].scan(/../).map(&:hex)
         @bytes = arr
       else
         raise "Provided data is not valid"
       end
 
-      @data   = data
+      @data = data
       @offset = 0
     end
 
@@ -39,20 +139,22 @@ module Scale
     end
 
     def get_next_bytes(length)
-      result = @bytes[@offset ... @offset + length]
+      result = @bytes[@offset...@offset + length]
       if result.length < length
         str = @data[(2 + @offset * 2)..]
         str = str.length > 40 ? (str[0...40]).to_s + "..." : str
         raise "No enough data: #{str}, expect length: #{length}, but #{result.length}" 
       end
-      @offset = @offset + length
+      @offset += length
       result
+    rescue RangeError => ex
+      puts "length: #{length}"
+      puts ex.message
+      puts ex.backtrace
     end
 
     def get_remaining_bytes
       @bytes[offset..]
-      @offset = @bytes.length
-      result
     end
 
     def to_hex_string
@@ -63,8 +165,16 @@ module Scale
       @bytes.bytes_to_bin
     end
 
-    def ==(another_object)
-      self.bytes == another_object.bytes && self.offset == another_object.offset
+    def to_ascii 
+      @bytes[0...offset].pack("C*") + "<================================>" + @bytes[offset..].pack("C*")
+    end
+
+    def ==(other)
+      bytes == other.bytes && offset == other.offset
+    end
+
+    def to_s
+      green(@bytes[0...offset].bytes_to_hex) + yellow(@bytes[offset..].bytes_to_hex[2..])
     end
   end
 
@@ -77,13 +187,13 @@ module Scale
       types = result["default"]
       types.each do |name, body|
         if body.class == String
-          target_type  = "Scale::Types::#{body}"
+          target_type = "Scale::Types::#{body}"
           klass = Class.new(target_type.constantize) do
           end
         elsif body.class == Hash
           if body["type"] == "struct"
             struct_params = {}
-            body['type_mapping'].each do |mapping|
+            body["type_mapping"].each do |mapping|
               struct_params[mapping[0].to_sym] = mapping[1]
             end
             klass = Class.new do
@@ -97,7 +207,7 @@ module Scale
             klass.send(:include, Scale::Types::Enum)
             if body["type_mapping"]
               struct_params = {}
-              body['type_mapping'].each do |mapping|
+              body["type_mapping"].each do |mapping|
                 struct_params[mapping[0].to_sym] = mapping[1]
               end
               klass.send(:items, struct_params)
@@ -111,77 +221,177 @@ module Scale
     end
   end
 
-end
+  module Types
+    def self.list
+      TypeRegistry.instance.types
+    end
 
-def type_of(type_string, enum_values: nil)
-  if type_string.end_with?(">")
-    type_strs = type_string.scan(/^([^<]*)<(.+)>$/).first
-    type_str       = type_strs.first
-    inner_type_str = type_strs.last
+    def self.get(type_name)
+      type_name = adjust(type_name)
+      TypeRegistry.instance.get(type_name)
+    end
 
-    if type_str == "Vec" || type_str == "Option"
-      klass = Class.new do
-        include type_of(type_str)
-        inner_type inner_type_str
-      end
-      name = "#{type_str}#{klass.object_id}"
-      Object.const_set name, klass
-      return name.constantize
-    else
-      raise "#{type_str} not support inner type"
-    end
-  elsif type_string.start_with?("(") && type_string.end_with?(")") # tuple
-    # TODO: add nested tuple support
-    types_with_inner_type = type_string[1...-1].scan(/([A-Za-z]+<[^>]*>)/).first
-
-    if not types_with_inner_type.nil?
-      types_with_inner_type.each do |type_str|
-        new_type_str = type_str.gsub(",", ";")
-        type_string = type_string.gsub(type_str, new_type_str)
+    def self.constantize(type)
+      if type.class == ::String
+        type_of(type.strip)
+      else
+        if type["type"] == "enum" && type.has_key?("type_mapping")
+          type_of("Enum", type["type_mapping"].to_h)
+        elsif type["type"] == "enum" && type.has_key?("value_list")
+          type_of("Enum", type["value_list"])
+        elsif type["type"] == "struct"
+          type_of("Struct", type["type_mapping"].to_h)
+        elsif type["type"] == "set"
+          type_of("Set", type["value_list"])
+        end
       end
     end
 
-    type_strs = type_string[1...-1].split(",").map do |type_str|
-      type_str.strip.gsub(";", ",")
-    end
+    def self.type_convert(type, types)
+      return type if type.class != ::String
 
-    klass = Class.new do
-      include Scale::Types::Tuple
-      inner_types *type_strs
+      if type =~ /\[u\d+; \d+\]/
+        byte_length = type.scan(/\[u\d+; (\d+)\]/).first.first
+        "VecU8Length#{byte_length}"
+      elsif types.has_key?(type) && types[type] != type
+        type_convert(types[type], types)
+      else
+        adjust(type)
+      end
     end
-    name = "Tuple#{klass.object_id}"
-    Object.const_set name, klass
-    return name.constantize
-  else
-    if type_string == 'Enum'
-      klass = Class.new do
-        include Scale::Types::Enum
-        values *enum_values
+
+    def self.type_of(type_string, values = nil)
+      if type_string.end_with?(">")
+        type_strs = type_string.scan(/^([^<]*)<(.+)>$/).first
+        type_str = type_strs.first
+        inner_type_str = type_strs.last
+
+        if type_str == "Vec" || type_str == "Option"
+          klass = Class.new do
+            include Scale::Types.type_of(type_str)
+            inner_type inner_type_str
+          end
+          name = "#{type_str}_Of_#{inner_type_str.camelize}_#{klass.object_id}"
+          Scale::Types.const_set fix(name), klass
+        else
+          raise "#{type_str} not support inner type"
+        end
+      elsif type_string.start_with?("(") && type_string.end_with?(")") # tuple
+        # TODO: add nested tuple support
+        types_with_inner_type = type_string[1...-1].scan(/([A-Za-z]+<[^>]*>)/).first
+
+        types_with_inner_type&.each do |type_str|
+          new_type_str = type_str.tr(",", ";")
+          type_string = type_string.gsub(type_str, new_type_str)
+        end
+
+        type_strs = type_string[1...-1].split(",").map do |type_str|
+          type_str.strip.tr(";", ",")
+        end
+
+        klass = Class.new do
+          include Scale::Types::Tuple
+          inner_types *type_strs
+        end
+        name = "Tuple_Of_#{type_strs.map(&:camelize).join("_")}_#{klass.object_id}"
+        Scale::Types.const_set fix(name), klass
+      else
+        if type_string == "Enum"
+          # TODO: combine values to items
+          klass = Class.new do
+            include Scale::Types::Enum
+            if values.class == ::Hash
+              items values
+            else
+              values(*values)
+            end
+          end
+          name = values.class == ::Hash ? values.values.map(&:camelize).join("_") : values.map(&:camelize).join("_")
+          name = "Enum_Of_#{name}_#{klass.object_id}"
+          Scale::Types.const_set fix(name), klass
+        elsif type_string == "Struct"
+          klass = Class.new do
+            include Scale::Types::Struct
+            items values
+          end
+          name = "Struct_Of_#{values.values.map(&:camelize).join("_")}_#{klass.object_id}"
+          Scale::Types.const_set fix(name), klass
+        elsif type_string == "Set"
+          klass = Class.new do
+            include Scale::Types::Set
+            items values, 1
+          end
+          name = "Set_Of_#{values.keys.map(&:camelize).join("_")}_#{klass.object_id}"
+          Scale::Types.const_set fix(name), klass
+        else
+          type_name = (type_string.start_with?("Scale::Types::") ? type_string : "Scale::Types::#{type_string}")
+          begin
+            type_name.constantize
+          rescue NameError => e
+            puts "#{type_string} is not defined"
+          end
+        end
       end
-      name = "Enum#{klass.object_id}"
-      Object.const_set name, klass
-      return name.constantize
-    else
-      type_string = (type_string.start_with?("Scale::Types::") ? type_string : "Scale::Types::#{type_string}")
-      type_string.constantize
     end
   end
+
+end
+
+def fix(name)
+  name
+    .gsub("<", "˂").gsub(">", "˃")
+    .gsub("(", "⁽").gsub(")", "⁾")
+    .gsub(" ", "").gsub(",", "‚")
+    .gsub(":", "։")
 end
 
 def adjust(type)
   type = type.gsub("T::", "")
-             .gsub("<T>", "")
-             .gsub("<T as Trait>::", "")
-             .gsub("\n", "")
-             .gsub("EventRecord<Event, Hash>", "EventRecord")
+    .gsub("<T>", "")
+    .gsub("<T as Trait>::", "")
+    .delete("\n")
+    .gsub("EventRecord<Event, Hash>", "EventRecord")
+    .gsub(/(u)(\d+)/, 'U\2')
   return "Null" if type == "()"
   return "String" if type == "Vec<u8>"
-  return "Address" if type == '<Lookup as StaticLookup>::Source'
-  return "Vec<Address>" if type == 'Vec<<Lookup as StaticLookup>::Source>'
-  return "CompactBalance" if type == '<Balance as HasCompact>::Type'
-  return 'CompactBlockNumber' if type == '<BlockNumber as HasCompact>::Type'
-  return 'CompactBalance' if type == '<Balance as HasCompact>::Type'
-  return 'CompactMoment' if type == '<Moment as HasCompact>::Type'
-  return 'InherentOfflineReport' if type == '<InherentOfflineReport as InherentOfflineReport>::Inherent'
-  return type
+  return "Compact" if type == "Compact<u32>" || type == "Compact<U32>"
+  return "Address" if type == "<Lookup as StaticLookup>::Source"
+  return "Vec<Address>" if type == "Vec<<Lookup as StaticLookup>::Source>"
+  return "Compact" if type == "<Balance as HasCompact>::Type"
+  return "Compact" if type == "<BlockNumber as HasCompact>::Type"
+  return "Compact" if type == "Compact<Balance>"
+  return "CompactMoment" if type == "<Moment as HasCompact>::Type"
+  return "InherentOfflineReport" if type == "<InherentOfflineReport as InherentOfflineReport>::Inherent"
+  return "AccountData" if type == "AccountData<Balance>"
+  type
+end
+
+def green(text)
+  "\033[32m#{text}\033[0m"
+end
+
+def yellow(text)
+  "\033[33m#{text}\033[0m"
+end
+
+# https://www.ruby-forum.com/t/question-about-hex-signed-int/125510/4
+# machine bit length:
+#   machine_byte_length = ['foo'].pack('p').size
+#   machine_bit_length = machine_byte_length * 8
+class Integer
+  def to_signed(bit_length)
+    unsigned_mid = 2 ** (bit_length - 1)
+    unsigned_ceiling = 2 ** bit_length
+    (self >= unsigned_mid) ? self - unsigned_ceiling : self
+  end
+
+  def to_unsigned(bit_length)
+    unsigned_mid = 2 ** (bit_length - 1)
+    unsigned_ceiling = 2 ** bit_length 
+    if self >= unsigned_mid || self <= -unsigned_mid
+      raise "out of scope"
+    end
+    return unsigned_ceiling + self if self < 0
+    self
+  end
 end