scale.rb 0.2.1 → 0.2.6

data/lib/metadata/metadata_v7.rb

@@ -37,7 +37,7 @@ module Scale
 
           if m[:events]
             m[:events].each_with_index do |event, index|
-              event[:lookup] = "%02x%02x" % [call_module_index, index]
+              event[:lookup] = "%02x%02x" % [event_module_index, index]
               result.event_index[event[:lookup]] = [m, event]
             end
             event_module_index += 1
@@ -106,14 +106,14 @@ module Scale
         storage_function_type = Scale::Types.type_of("Enum", %w[Plain Map DoubleMap]).decode(scale_bytes).value
         if storage_function_type == "Plain"
           result[:type] = {
-            Plain: adjust(String.decode(scale_bytes).value)
+            Plain: String.decode(scale_bytes).value
           }
         elsif storage_function_type == "Map"
           result[:type] = {
             Map: {
               hasher: StorageHasher.decode(scale_bytes).value,
-              key: adjust(String.decode(scale_bytes).value),
-              value: adjust(String.decode(scale_bytes).value),
+              key: String.decode(scale_bytes).value,
+              value: String.decode(scale_bytes).value,
               linked: Bool.decode(scale_bytes).value
             }
           }
@@ -121,16 +121,16 @@ module Scale
           result[:type] = {
             DoubleMap: {
               hasher: StorageHasher.decode(scale_bytes).value,
-              key1: adjust(String.decode(scale_bytes).value),
-              key2: adjust(String.decode(scale_bytes).value),
-              value: adjust(String.decode(scale_bytes).value),
+              key1: String.decode(scale_bytes).value,
+              key2: String.decode(scale_bytes).value,
+              value: String.decode(scale_bytes).value,
               key2Hasher: StorageHasher.decode(scale_bytes).value
             }
           }
         end
 
         result[:fallback] = Hex.decode(scale_bytes).value
-        result[:docs] = Scale::Types.type_of("Vec<String>").decode(scale_bytes).value.map(&:value)
+        result[:documentation] = Scale::Types.type_of("Vec<String>").decode(scale_bytes).value.map(&:value)
 
         MetadataV7ModuleStorageEntry.new(result)
       end
@@ -143,7 +143,7 @@ module Scale
           name: String.decode(scale_bytes).value,
           type: String.decode(scale_bytes).value, # convert
           value: Hex.decode(scale_bytes).value,
-          docs: Scale::Types.type_of("Vec<String>").decode(scale_bytes).value.map(&:value)
+          documentation: Scale::Types.type_of("Vec<String>").decode(scale_bytes).value.map(&:value)
         }
         MetadataV7ModuleConstants.new result
       end

data/lib/metadata/metadata_v8.rb

@@ -37,7 +37,7 @@ module Scale
 
           if m[:events]
             m[:events].each_with_index do |event, index|
-              event[:lookup] = "%02x%02x" % [call_module_index, index]
+              event[:lookup] = "%02x%02x" % [event_module_index, index]
               result.event_index[event[:lookup]] = [m, event]
             end
             event_module_index += 1
@@ -88,7 +88,7 @@ module Scale
       def self.decode(scale_bytes)
         result = {
           name: String.decode(scale_bytes).value,
-          docs: Scale::Types.type_of("Vec<String>").decode(scale_bytes).value.map(&:value)
+          documentation: Scale::Types.type_of("Vec<String>").decode(scale_bytes).value.map(&:value)
         }
 
         MetadataModuleError.new(result)

data/lib/metadata/metadata_v9.rb

@@ -37,7 +37,7 @@ module Scale
 
           if m[:events]
             m[:events].each_with_index do |event, index|
-              event[:lookup] = "%02x%02x" % [call_module_index, index]
+              event[:lookup] = "%02x%02x" % [event_module_index, index]
               result.event_index[event[:lookup]] = [m, event]
             end
             event_module_index += 1

data/lib/scale.rb

@@ -29,89 +29,78 @@ module Scale
 
   class TypeRegistry
     include Singleton
-    attr_accessor :types
+    attr_reader :spec_name, :types, :versioning, :custom_types
+    attr_accessor :spec_version
+    attr_accessor :metadata
 
-    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)
+    def load(spec_name: nil, custom_types: nil)
+      @spec_name = nil
+      @types = nil
+      @versioning = nil
+      @custom_types = nil
 
+      default_types, _, _ = load_chain_spec_types("default")
+
+      if spec_name.nil? || spec_name == "default"
+        @spec_name = "default"
+        @types = default_types
+      else
+        @spec_name = spec_name
+        spec_types, @versioning, @spec_version = load_chain_spec_types(spec_name)
+        @types = default_types.merge(spec_types)
+      end
+
+      self.custom_types = custom_types
       true
     end
 
     def get(type_name)
-      type = @types[type_name]
-      return Scale::Types.type_of(type_name) if type.nil?
-      type
-    end
+      raise "Types not loaded" if @types.nil?
 
-    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)
+      all_types = {}.merge(@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)
+      if @spec_version && @versioning
+        @versioning.each do |item|
+          if @spec_version >= item["runtime_range"][0] && @spec_version <= (item["runtime_range"][1] || 1073741823)
+            all_types.merge!(item["types"])
+          end
         end
-        default_types.merge(spec_types)
-      else
-        default_types
       end
+
+      all_types.merge!(@custom_types) if @custom_types
+
+      type = type_traverse(type_name, all_types)
+
+      Scale::Types.constantize(type)
     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)
+    def custom_types=(custom_types)
+      @custom_types = custom_types.stringify_keys if (not custom_types.nil?) && custom_types.class.name == "Hash"
+    end
 
-      types = {}
-      runtime_id = json["runtime_id"]
-      versioning = json["versioning"] || []
+    private
 
-      if runtime_id.nil? || (spec_version && spec_version >= runtime_id)
-        types = json["types"]
-      end
+      def load_chain_spec_types(spec_name)
+        file = File.join File.expand_path("../..", __FILE__), "lib", "type_registry", "#{spec_name}.json"
+        json_string = File.open(file).read
+        json = JSON.parse(json_string)
 
-      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
+        runtime_id = json["runtime_id"]
+
+        [json["types"], json["versioning"], runtime_id]
       end
 
-      types.transform_values! do |type|
-        if type.class != ::String
-          Scale::Types.constantize(type)
+      def type_traverse(type, types)
+        if types.has_key?(type)
+          type_traverse(types[type], types)
         else
-          t = Scale::Types.type_convert(type, types)
-          if t.class == ::String
-            Scale::Types.constantize(t)
+          if type.class == ::String
+            rename(type)
           else
-            t
+            type
           end
         end
       end
-
-      types
-    end
-
   end
 
   # TODO: == implement
@@ -227,7 +216,6 @@ module Scale
     end
 
     def self.get(type_name)
-      type_name = adjust(type_name)
       TypeRegistry.instance.get(type_name)
     end
 
@@ -247,19 +235,6 @@ module Scale
       end
     end
 
-    def self.type_convert(type, types)
-      return type if type.class != ::String
-
-      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
-
     def self.type_of(type_string, values = nil)
       if type_string.end_with?(">")
         type_strs = type_string.scan(/^([^<]*)<(.+)>$/).first
@@ -274,7 +249,7 @@ module Scale
           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"
+          raise "#{type_str} not support inner type: #{type_string}"
         end
       elsif type_string.start_with?("(") && type_string.end_with?(")") # tuple
         # TODO: add nested tuple support
@@ -345,13 +320,14 @@ def fix(name)
     .gsub(":", "։")
 end
 
-def adjust(type)
+def rename(type)
   type = type.gsub("T::", "")
     .gsub("<T>", "")
     .gsub("<T as Trait>::", "")
     .delete("\n")
     .gsub("EventRecord<Event, Hash>", "EventRecord")
     .gsub(/(u)(\d+)/, 'U\2')
+  return "Bool" if type == "bool"
   return "Null" if type == "()"
   return "String" if type == "Vec<u8>"
   return "Compact" if type == "Compact<u32>" || type == "Compact<U32>"
@@ -360,9 +336,17 @@ def adjust(type)
   return "Compact" if type == "<Balance as HasCompact>::Type"
   return "Compact" if type == "<BlockNumber as HasCompact>::Type"
   return "Compact" if type == "Compact<Balance>"
+  return "Compact" if type == "Compact<BlockNumber>"
   return "CompactMoment" if type == "<Moment as HasCompact>::Type"
+  return "CompactMoment" if type == "Compact<Moment>"
   return "InherentOfflineReport" if type == "<InherentOfflineReport as InherentOfflineReport>::Inherent"
   return "AccountData" if type == "AccountData<Balance>"
+
+  if type =~ /\[U\d+; \d+\]/
+    byte_length = type.scan(/\[U\d+; (\d+)\]/).first.first
+    return "VecU8Length#{byte_length}"
+  end
+
   type
 end
 
@@ -395,3 +379,19 @@ class Integer
     self
   end
 end
+
+class ::Hash
+  # via https://stackoverflow.com/a/25835016/2257038
+  def stringify_keys
+    h = self.map do |k,v|
+      v_str = if v.instance_of? Hash
+                v.stringify_keys
+              else
+                v
+              end
+
+      [k.to_s, v_str]
+    end
+    Hash[h]
+  end
+end

data/lib/scale/base.rb

@@ -11,6 +11,28 @@ module Scale
       def ==(other)
         value == other.value
       end
+
+      def to_human
+        if @value.class == ::Hash
+          @value.transform_values do |v|
+            if v.class.included_modules.include?(SingleValue)
+              v.to_human
+            else
+              v
+            end
+          end
+        elsif @value.class == ::Array
+          @value.map do |v|
+            if v.class.included_modules.include?(SingleValue)
+              v.to_human
+            else
+              v
+            end
+          end
+        else
+          @value
+        end
+      end
     end
 
     # value: one of nil, false, true, scale object
@@ -67,9 +89,8 @@ module Scale
 
       module ClassMethods
         def decode(scale_bytes)
-          bit_length = to_s[15..].to_i
-          byte_length = bit_length / 8
-          bytes = scale_bytes.get_next_bytes byte_length
+          bytes = scale_bytes.get_next_bytes self::BYTE_LENGTH
+          bit_length = bytes.length.to_i * 8
           value = bytes.reverse.bytes_to_hex.to_i(16).to_signed(bit_length)
           new(value)
         end
@@ -83,7 +104,7 @@ module Scale
         if value.class != ::Integer
           raise "#{self.class}'s value must be integer"
         end
-        bit_length = self.class.name[15..].to_i
+        bit_length = self.class::BYTE_LENGTH * 8
         hex = value.to_unsigned(bit_length).to_s(16).hex_to_bytes.reverse.bytes_to_hex
         hex[2..]
       end
@@ -111,19 +132,20 @@ module Scale
         if value.class != ::Integer
           raise "#{self.class}'s value must be integer"
         end
-        bytes = value.to_s(16).rjust(self.class::BYTE_LENGTH * 2, "0").scan(/.{2}/).reverse.map {|hex| hex.to_i(16) }
+        byte_length = self.class::BYTE_LENGTH
+        bytes = value.to_s(16).rjust(byte_length * 2, "0").scan(/.{2}/).reverse.map {|hex| hex.to_i(16) }
         bytes.bytes_to_hex[2..]
       end
     end
 
-
     module Struct
       include SingleValue
       # new(1.to_u32, U32(69))
       module ClassMethods
         def decode(scale_bytes)
           item_values = self::ITEM_TYPE_STRS.map do |item_type_str|
-            Scale::Types.get(item_type_str).decode(scale_bytes)
+            type = Scale::TypeRegistry.instance.get(item_type_str)
+            type.decode(scale_bytes)
           end
 
           value = {}
@@ -197,7 +219,7 @@ module Scale
       module ClassMethods
         def decode(scale_bytes)
           index = scale_bytes.get_next_bytes(1)[0]
-          if const_defined? "ITEM_NAMES"
+          if const_defined? "ITEM_TYPE_STRS"
             item_type_str = self::ITEM_TYPE_STRS[index]
             raise "There is no such member with index #{index} for enum #{self}" if item_type_str.nil?
             value = Scale::Types.get(item_type_str).decode(scale_bytes)
@@ -208,16 +230,20 @@ module Scale
         end
 
         def items(items)
-          attr_names = []
-          attr_type_strs = []
+          if items.class == ::Hash
+            attr_names = []
+            attr_type_strs = []
 
-          items.each_pair do |attr_name, attr_type_str|
-            attr_names << attr_name
-            attr_type_strs << attr_type_str
-          end
+            items.each_pair do |attr_name, attr_type_str|
+              attr_names << attr_name
+              attr_type_strs << attr_type_str
+            end
 
-          const_set(:ITEM_NAMES, attr_names)
-          const_set(:ITEM_TYPE_STRS, attr_type_strs)
+            const_set(:ITEM_NAMES, attr_names)
+            const_set(:ITEM_TYPE_STRS, attr_type_strs)
+          elsif items.class == ::Array
+            const_set(:ITEM_TYPE_STRS, items)
+          end
         end
 
         def values(*values)
@@ -238,6 +264,14 @@ module Scale
           self.class::VALUES.index(value).to_s(16).rjust(2, "0")
         end
       end
+
+      def to_human
+        if self.class.const_defined? "ITEM_TYPE_STRS"
+          @value.to_human
+        else
+          @value
+        end
+      end
     end
 
     module Vec
@@ -248,7 +282,8 @@ module Scale
           number = Scale::Types::Compact.decode(scale_bytes).value
           items = []
           number.times do
-            item = Scale::Types.get(self::INNER_TYPE_STR).decode(scale_bytes)
+            type = Scale::Types.get(self::INNER_TYPE_STR)
+            item = type.decode(scale_bytes)
             items << item
           end
           raw ? items : new(items)
@@ -278,7 +313,7 @@ module Scale
 
       module ClassMethods
         def decode(scale_bytes)
-          value = "Scale::Types::U#{self::BYTES_LENGTH * 8}".constantize.decode(scale_bytes).value
+          value = "Scale::Types::U#{self::BYTE_LENGTH * 8}".constantize.decode(scale_bytes).value
           return new [] unless value || value <= 0
 
           result = self::ITEMS.select { |_, mask| value & mask > 0 }.keys
@@ -295,7 +330,7 @@ module Scale
         def items(items, bytes_length = 1)
           raise "byte length is wrong: #{bytes_length}" unless [1, 2, 4, 8, 16].include?(bytes_length)
           const_set(:ITEMS, items)
-          const_set(:BYTES_LENGTH, bytes_length)
+          const_set(:BYTE_LENGTH, bytes_length)
         end
       end
 
@@ -305,7 +340,7 @@ module Scale
 
       def encode
         value = self.class::ITEMS.select { |key, _| self.value.include?(key) }.values.sum
-        "Scale::Types::U#{self.class::BYTES_LENGTH * 8}".constantize.new(value).encode
+        "Scale::Types::U#{self.class::BYTE_LENGTH * 8}".constantize.new(value).encode
       end
     end