scale.rb 0.2.4 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f8538580b5cc0d84add3684e3af10bbbba86bc741abb66bc5d38594c7de17894
-  data.tar.gz: a652f2dd8b436840f8b4e004fdf3fe81c699200fb68a11ea2ca52ae4a3e64062
+  metadata.gz: b6c01e31f2e50407197c68df2d81da349d5471d52ddcb1b17c1a30fcd5706eae
+  data.tar.gz: 5618f3aa22bcf94dc40a12bb15508cbe6dff74441879ffccdd8f2d6f626de992
 SHA512:
-  metadata.gz: a5a71617b20e22dc876b71414c6bdf78cfdc23b94444f010d902eb382bb8f26d92e06de9eedca805aca9ba408035a981a106fa1d944081a3426864d6351b6b58
-  data.tar.gz: 8a65c9e78531472b74f93eb48da5c0e54c7b05430342467afa03ead952643cc41901a4a8f6b908ba6e3e8721b9aa26e6e426d6664ffb8ab93390e7c0febfd74c
+  metadata.gz: c00a8b437a13ea3a795ac1dbdc4bbeda4442400cb0a8153ab0bc07e980f5c921091b54afffe28392646aa3fede9c7b8b96d1d74d1e4fb3a9e3cf5de0419c1bca
+  data.tar.gz: c449932d536db154cd4b6e3bbb9163bb6083494d69066e52b3e3fb856bdcc44944e9d102835f1c702c024667a32ae8c1baa0719fc1d6e0815fc90dbbbf92b956

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    scale.rb (0.2.4)
+    scale.rb (0.2.5)
       activesupport (>= 4.0.0)
       json (~> 2.3.0)
       substrate_common.rb (~> 0.1.8)

data/README.md

@@ -79,10 +79,13 @@ examples in `exec/scale`
 rspec
 ```
 
-To run only low level format tests, call
+To run single test file:
 
-```
-rspec spec/low_level_spec.rb
+```bash
+rspec spec/types_spec.rb
+rspec spec/extrinsic_spec.rb
+rspec spec/metadata_spec.rb
+rspec spec/types_ffi_spec.rb
 ```
 
 

data/lib/metadata/metadata.rb

@@ -5,21 +5,8 @@ module Scale
       attr_accessor :version
       def self.decode(scale_bytes)
         bytes = scale_bytes.get_next_bytes(4)
-        if bytes.bytes_to_utf8 == 'meta'
-          metadata_version = Scale::Types.type_of('Enum', [
-                                      'MetadataV0',
-                                      'MetadataV1',
-                                      'MetadataV2',
-                                      'MetadataV3',
-                                      'MetadataV4',
-                                      'MetadataV5',
-                                      'MetadataV6',
-                                      'MetadataV7',
-                                      'MetadataV8',
-                                      'MetadataV9',
-                                      'MetadataV10',
-                                      'MetadataV11'
-                                    ]).decode(scale_bytes).value
+        if bytes.bytes_to_utf8 == "meta"
+          metadata_version = Scale::Types.type_of("Enum", %w[MetadataV0 MetadataV1 MetadataV2 MetadataV3 MetadataV4 MetadataV5 MetadataV6 MetadataV7 MetadataV8 MetadataV9 MetadataV10 MetadataV11]).decode(scale_bytes).value
           metadata = Metadata.new "Scale::Types::#{metadata_version}".constantize.decode(scale_bytes)
           metadata.version = metadata_version[9..].to_i
         else
@@ -30,6 +17,24 @@ module Scale
         end
         metadata
       end
+
+      def get_module(module_name)
+        modules = self.value.value[:metadata][:modules]
+        modules.each do |m|
+          if m[:name].downcase == module_name.downcase
+            return m
+          end
+        end
+      end
+
+      def get_module_call(module_name, call_name)
+        the_module = get_module(module_name)
+        the_module[:calls].each do |call|
+          if call[:name].downcase == call_name.downcase
+            return call
+          end
+        end
+      end
     end
 
     class MetadataModule
@@ -45,19 +50,19 @@ module Scale
 
         has_storage = Bool.decode(scale_bytes).value
         if has_storage
-          storages = Scale::Types.type_of('Vec<MetadataModuleStorage>').decode(scale_bytes).value
+          storages = Scale::Types.type_of("Vec<MetadataModuleStorage>").decode(scale_bytes).value
           result[:storage] = storages.map(&:value)
         end
 
         has_calls = Bool.decode(scale_bytes).value
         if has_calls
-          calls = Scale::Types.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 = Scale::Types.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
 
@@ -70,26 +75,26 @@ module Scale
       def self.decode(scale_bytes)
         result = {
           name: String.decode(scale_bytes).value,
-          modifier: Scale::Types.type_of('Enum', %w[Optional Default]).decode(scale_bytes).value
+          modifier: Scale::Types.type_of("Enum", %w[Optional Default]).decode(scale_bytes).value
         }
 
         is_key_value = Bool.decode(scale_bytes).value
         result[:type] = if is_key_value
                           {
                             Map: {
-                              key: adjust(String.decode(scale_bytes).value),
-                              value: adjust(String.decode(scale_bytes).value),
+                              key: rename(String.decode(scale_bytes).value),
+                              value: rename(String.decode(scale_bytes).value),
                               linked: Bool.decode(scale_bytes).value
                             }
                           }
                         else
                           {
-                            Plain: adjust(String.decode(scale_bytes).value)
+                            Plain: rename(String.decode(scale_bytes).value)
                           }
                         end
 
         result[:fallback] = Hex.decode(scale_bytes).value
-        result[:documentation] = 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)
 
         MetadataModuleStorage.new(result)
       end
@@ -100,8 +105,8 @@ module Scale
       def self.decode(scale_bytes)
         result = {}
         result[:name] = String.decode(scale_bytes).value
-        result[:args] = Scale::Types.type_of('Vec<MetadataModuleCallArgument>').decode(scale_bytes).value.map(&:value)
-        result[:documentation] = Scale::Types.type_of('Vec<String>').decode(scale_bytes).value.map(&:value)
+        result[:args] = Scale::Types.type_of("Vec<MetadataModuleCallArgument>").decode(scale_bytes).value.map(&:value)
+        result[:documentation] = Scale::Types.type_of("Vec<String>").decode(scale_bytes).value.map(&:value)
         MetadataModuleCall.new(result)
       end
     end
@@ -111,7 +116,7 @@ module Scale
       def self.decode(scale_bytes)
         result = {}
         result[:name] = String.decode(scale_bytes).value
-        result[:type] = adjust(String.decode(scale_bytes).value)
+        result[:type] = rename(String.decode(scale_bytes).value)
 
         MetadataModuleCallArgument.new(result)
       end
@@ -122,8 +127,8 @@ module Scale
       def self.decode(scale_bytes)
         result = {}
         result[:name] = String.decode(scale_bytes).value
-        result[:args] = 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)
+        result[:args] = 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)
 
         MetadataModuleEvent.new(result)
       end

data/lib/metadata/metadata_v1.rb

@@ -93,13 +93,13 @@ module Scale
         if is_key_value
           type = {
             MapType: {
-              key: adjust(Bytes.decode(scale_bytes).value),
-              value: adjust(Bytes.decode(scale_bytes).value)
+              key: rename(Bytes.decode(scale_bytes).value),
+              value: rename(Bytes.decode(scale_bytes).value)
             }
           }
         else
           type = {
-            PlainType: adjust(Bytes.decode(scale_bytes).value)
+            PlainType: rename(Bytes.decode(scale_bytes).value)
           }
         end
 

data/lib/metadata/metadata_v4.rb

@@ -92,14 +92,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: rename(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: rename(String.decode(scale_bytes).value),
+              value: rename(String.decode(scale_bytes).value),
               linked: Bool.decode(scale_bytes).value
             }
           }
@@ -107,9 +107,9 @@ 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: rename(String.decode(scale_bytes).value),
+              key2: rename(String.decode(scale_bytes).value),
+              value: rename(String.decode(scale_bytes).value),
               key2Hasher: StorageHasher.decode(scale_bytes).value
             }
           }

data/lib/metadata/metadata_v5.rb

@@ -92,14 +92,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: rename(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: rename(String.decode(scale_bytes).value),
+              value: rename(String.decode(scale_bytes).value),
               linked: Bool.decode(scale_bytes).value
             }
           }
@@ -107,9 +107,9 @@ 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: rename(String.decode(scale_bytes).value),
+              key2: rename(String.decode(scale_bytes).value),
+              value: rename(String.decode(scale_bytes).value),
               key2Hasher: StorageHasher.decode(scale_bytes).value
             }
           }

data/lib/metadata/metadata_v7.rb

@@ -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: rename(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: rename(String.decode(scale_bytes).value),
+              value: rename(String.decode(scale_bytes).value),
               linked: Bool.decode(scale_bytes).value
             }
           }
@@ -121,9 +121,9 @@ 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: rename(String.decode(scale_bytes).value),
+              key2: rename(String.decode(scale_bytes).value),
+              value: rename(String.decode(scale_bytes).value),
               key2Hasher: StorageHasher.decode(scale_bytes).value
             }
           }

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
 

data/lib/scale/block.rb

@@ -9,7 +9,8 @@ module Scale
         Blake2b.hex data, Blake2b::Key.none, 32
       end
 
-      def self.decode(scale_bytes, metadata)
+      def self.decode(scale_bytes)
+        metadata = Scale::TypeRegistry.instance.metadata
         result = {}
 
         extrinsic_length = Compact.decode(scale_bytes).value
@@ -83,11 +84,11 @@ module Scale
           result[:call_index] = scale_bytes.get_next_bytes(2).bytes_to_hex[2..]
 
         else
-          raise "Extrinsics version #{version_info} is not implemented"
+          raise "Extrinsic version #{version_info} is not implemented"
         end
 
         if result[:call_index]
-          call_module, call = metadata.value.call_index[result[:call_index]]
+          call_module, call = metadata.call_index[result[:call_index]]
 
           result[:call_function] = call[:name].downcase
           result[:call_module] = call_module[:name].downcase
@@ -97,7 +98,7 @@ module Scale
           result[:params] = call[:args].map do |arg|
             type = Scale::Types.get(arg[:type])
             arg_obj = type.decode(scale_bytes)
-            {name: arg[:name], type: type.name, value: arg_obj.value, value_raw: "0x#{arg_obj.encode}" }
+            {name: arg[:name], type: arg[:type], scale_type: type, value: arg_obj.value }
           end
         end
 
@@ -107,24 +108,24 @@ module Scale
         Extrinsic.new result
       end
 
-      def encode(metadata)
-        puts metadata.value.value["modules"]
+      def encode
         result = "04" + self.value[:call_index]
 
-        result = result +
-          self.value[:params].map do |param|
-            param[:type].constantize.new(param[:value]).encode
-          end.join
+        result += self.value[:params].map do |param|
+          Scale::Types.get(param[:type]).new(param[:value]).encode
+        end.join
 
-        result = "0x" + Compact.new(result.length / 2).encode + result
-        return result
+        "0x" + Compact.new(result.length / 2).encode + result
+      end
+
+      def to_human
+        @value
       end
     end
 
     class EventRecord
       include SingleValue
 
-      # 0x0c000000000000001027000001010000010000000400be07e2c28688db5368445c33d32b3c7bcad15dab1ec802ba8cccc1c22b86574f6992da89ff412eaf9bafac4024
       def self.decode(scale_bytes)
         metadata = Scale::TypeRegistry.instance.metadata
 
@@ -137,22 +138,72 @@ module Scale
 
         type = scale_bytes.get_next_bytes(2).bytes_to_hex[2..]
         event = metadata.event_index[type][1]
-        mod = metadata.event_index[type][0]
+        # mod = metadata.event_index[type][0]
 
         result[:params] = []
         event[:args].each do |arg_type|
-          value = Scale::Types.get(arg_type).decode(scale_bytes).value
+          value = Scale::Types.get(arg_type).decode(scale_bytes).to_human
           result[:params] << {
+            name: event[:name],
             type: arg_type,
             value: value
           }
         end
 
-        result[:topics] = Scale::Types.get('Vec<Hash>').decode(scale_bytes).value.map(&:value)
+        result[:topics] = Scale::Types.get("Vec<Hash>").decode(scale_bytes).value.map(&:value)
 
         EventRecord.new(result)
       end
     end
 
+    # log
+    class Other < Bytes; end
+
+    class AuthoritiesChange 
+      include Vec
+      inner_type "AccountId"
+    end
+
+    class ConsensusEngineId < VecU8Length4; end
+
+    class ChangesTrieRoot < Bytes; end
+
+    class SealV0
+      include Struct
+      items(
+        slot: "U64",
+        signature: "Signature"
+      )
+    end
+
+    class Consensus
+      include Struct
+      items(
+        engine: "ConsensusEngineId",
+        data: "Hex"
+      )
+    end
+
+    class Seal
+      include Struct
+      items(
+        engine: "ConsensusEngineId",
+        data: "Hex"
+      )
+    end
+
+    class PreRuntime
+      include Struct
+      items(
+        engine: "ConsensusEngineId",
+        data: "Hex"
+      )
+    end
+
+    class LogDigest
+      include Enum
+      items %w[Other AuthoritiesChange ChangesTrieRoot SealV0 Consensus Seal PreRuntime]
+    end
+
   end
 end

data/lib/scale/types.rb

@@ -46,24 +46,34 @@ module Scale
       BYTE_LENGTH = 16
     end
 
+    class U256
+      include FixedWidthUInt
+      BYTE_LENGTH = 32
+    end
+
     class I8
       include FixedWidthInt
+      BYTE_LENGTH = 1
     end
 
     class I16
       include FixedWidthInt
+      BYTE_LENGTH = 2
     end
 
     class I32
       include FixedWidthInt
+      BYTE_LENGTH = 4
     end
 
     class I64
       include FixedWidthInt
+      BYTE_LENGTH = 8
     end
 
     class I128
       include FixedWidthInt
+      BYTE_LENGTH = 16
     end
 
     class Compact
@@ -303,7 +313,7 @@ module Scale
           value /= 1000
         end
 
-        CompactMoment.new Time.at(seconds_since_epoch_integer).to_datetime
+        CompactMoment.new Time.at(value).to_datetime.strftime("%F %T")
       end
     end
 
@@ -791,5 +801,19 @@ module Scale
       )
     end
 
+    class VecH512Length2
+      include SingleValue
+
+      def self.decode(scale_bytes)
+      end
+
+      def encode
+        "0x" + self.value.map do |item|
+          item[2..]
+        end.join
+      end
+    end
+
+
   end
 end

data/lib/scale/version.rb

@@ -1,3 +1,3 @@
 module Scale
-  VERSION = "0.2.4".freeze
+  VERSION = "0.2.5".freeze
 end

data/lib/scale.rb

@@ -29,89 +29,65 @@ module Scale
 
   class TypeRegistry
     include Singleton
-    attr_accessor :types, :metadata
+    attr_accessor :types, :versioning
+    attr_accessor :spec_version, :metadata
+    attr_accessor :custom_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)
+    def load(spec_name = nil, custom_types = nil)
+      default_types, _ = load_chain_spec_types("default")
 
+      if spec_name.nil? || spec_name == "default"
+        @types = default_types
+      else
+        spec_types, @versioning = load_chain_spec_types(spec_name)
+        @types = default_types.merge(spec_types)
+      end
+
+      @custom_types = custom_types.stringify_keys if custom_types.nil? && custom_types.class.name == "Hash"
       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)
+    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)
 
-      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
+      [json["types"], json["versioning"]]
+    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
+        if type.class == ::String
+          rename(type)
         else
-          t = Scale::Types.type_convert(type, types)
-          if t.class == ::String
-            Scale::Types.constantize(t)
-          else
-            t
-          end
+          type
         end
       end
-
-      types
     end
-
   end
 
   # TODO: == implement
@@ -227,7 +203,6 @@ module Scale
     end
 
     def self.get(type_name)
-      type_name = adjust(type_name)
       TypeRegistry.instance.get(type_name)
     end
 
@@ -247,19 +222,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 +236,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 +307,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>"
@@ -361,8 +324,15 @@ def adjust(type)
   return "Compact" if type == "<BlockNumber as HasCompact>::Type"
   return "Compact" if type == "Compact<Balance>"
   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 +365,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/type_registry/darwinia.json

@@ -107,6 +107,13 @@
          ["ktoner", "TokenBalance"],
          ["lottery", "TokenBalance"]
       ]
+    },
+    "DoubleNodeWithMerkleProof": {
+      "type": "struct",
+      "type_mapping": [
+        ["dag_nodes", "VecH512Length2"],
+        ["proof", "Vec<H128>"]
+      ]
     }
   }
 }

data/lib/type_registry/default.json

@@ -35,13 +35,6 @@
          ["balance", "Balance"]
       ]
     },
-    "ReferendumInfo<BlockNumber, Hash, Balance>": {
-      "type": "enum",
-      "type_mapping": [
-        ["Ongoing", "ReferendumStatus"],
-        ["Finished", "ReferendumInfoFinished"]
-      ]
-    },
     "ReferendumInfoFinished": {
       "type": "struct",
       "type_mapping": [
@@ -67,6 +60,13 @@
          ["tally", "Tally"]
       ]
     },
+    "ReferendumInfo": {
+      "type": "enum",
+      "type_mapping": [
+        ["Ongoing", "ReferendumStatus"],
+        ["Finished", "ReferendumInfoFinished"]
+      ]
+    },
     "VotingDirectVote": {
       "type": "struct",
       "type_mapping": [
@@ -247,7 +247,8 @@
       "type": "enum",
       "value_list": [
         "Normal",
-        "Operational"
+        "Operational",
+        "Mandatory"
       ]
     },
     "DispatchInfo": {
@@ -338,6 +339,7 @@
     "MomentOf": "Moment",
     "MoreAttestations": "Null",
     "Multiplier": "u64",
+    "CallHash": "H256",
     "Timepoint": {
       "type": "struct",
       "type_mapping": [
@@ -364,7 +366,7 @@
     "PhantomData": "Null",
     "sp_std::marker::PhantomData<(AccountId, Event)>": "PhantomData",
     "Reporter": "AccountId",
-    "OffenceDetails<AccountId, IdentificationTuple>": {
+    "OffenceDetails": {
       "type": "struct",
       "type_mapping": [
          ["offender", "Offender"],
@@ -543,17 +545,6 @@
       ]
     },
     "WinningData": "Vec<WinningDataEntry>",
-    "WithdrawReasons": {
-      "type": "set",
-      "value_type": "u64",
-      "value_list": {
-        "TransactionPayment": 1,
-        "Transfer": 2,
-        "Reserve": 4,
-        "Fee": 8,
-        "Tip": 16
-      }
-    },
     "Index": "U32",
     "Kind": "[u8; 16]",
     "Nominations": {
@@ -583,7 +574,8 @@
          ["blockNumber", "BlockNumber"],
          ["networkState", "OpaqueNetworkState"],
          ["sessionIndex", "SessionIndex"],
-         ["authorityIndex", "AuthIndex"]
+         ["authorityIndex", "AuthIndex"],
+         ["validatorsLen", "u32"]
       ]
     },
     "RewardDestination": {
@@ -837,6 +829,164 @@
         ["perBlock", "Balance"],
         ["startingBlock", "BlockNumber"]
       ]
+    },
+    "NominatorIndex": "u32",
+    "ValidatorIndex": "u16",
+    "PerU16": "u16",
+    "OffchainAccuracy": "PerU16",
+    "CompactScore": {
+      "type": "struct",
+        "type_mapping": [
+          ["validatorIndex", "ValidatorIndex"],
+          ["offchainAccuracy", "OffchainAccuracy"]
+        ]
+    },
+    "CompactAssignments": {
+      "type": "struct",
+        "type_mapping": [
+          ["votes1", "Vec<(NominatorIndex, ValidatorIndex)>"],
+          ["votes2", "Vec<(NominatorIndex, [CompactScore; 1], ValidatorIndex)>"],
+          ["votes3", "Vec<(NominatorIndex, [CompactScore; 2], ValidatorIndex)>"],
+          ["votes4", "Vec<(NominatorIndex, [CompactScore; 3], ValidatorIndex)>"],
+          ["votes5", "Vec<(NominatorIndex, [CompactScore; 4], ValidatorIndex)>"],
+          ["votes6", "Vec<(NominatorIndex, [CompactScore; 5], ValidatorIndex)>"],
+          ["votes7", "Vec<(NominatorIndex, [CompactScore; 6], ValidatorIndex)>"],
+          ["votes8", "Vec<(NominatorIndex, [CompactScore; 7], ValidatorIndex)>"],
+          ["votes9", "Vec<(NominatorIndex, [CompactScore; 8], ValidatorIndex)>"],
+          ["votes10", "Vec<(NominatorIndex, [CompactScore; 9], ValidatorIndex)>"],
+          ["votes11", "Vec<(NominatorIndex, [CompactScore; 10], ValidatorIndex)>"],
+          ["votes12", "Vec<(NominatorIndex, [CompactScore; 11], ValidatorIndex)>"],
+          ["votes13", "Vec<(NominatorIndex, [CompactScore; 12], ValidatorIndex)>"],
+          ["votes14", "Vec<(NominatorIndex, [CompactScore; 13], ValidatorIndex)>"],
+          ["votes15", "Vec<(NominatorIndex, [CompactScore; 14], ValidatorIndex)>"],
+          ["votes16", "Vec<(NominatorIndex, [CompactScore; 15], ValidatorIndex)>"]
+        ]
+    },
+    "DeferredOffenceOf": {
+      "type": "struct",
+        "type_mapping": [
+          ["offences", "Vec<OffenceDetails>"],
+          ["perc", "Vec<Perbill>"],
+          ["session", "SessionIndex"]
+        ]
+    },
+    "Statement": {
+      "type": "enum",
+      "type_mapping": [
+        ["Never", "Null"],
+        ["Candidate", "Hash"],
+        ["Valid", "Hash"],
+        ["Invalid", "Hash"]
+      ]
+    },
+    "ValidatorSignature": "Signature",
+    "DoubleVoteReportStatement": {
+      "type": "struct",
+      "type_mapping": [
+        ["statement", "Statement"],
+        ["signature", "ValidatorSignature"]
+      ]
+    },
+    "DoubleVoteReportProof": {
+      "type": "struct",
+      "type_mapping": [
+        ["session", "SessionIndex"],
+        ["trieNodes", "Vec<Bytes>"]
+      ]
+    },
+    "SigningContext": {
+      "type": "struct",
+      "type_mapping": [
+        ["sessionIndex", "SessionIndex"],
+        ["parentHash", "Hash"]
+      ]
+    },
+    "DoubleVoteReport": {
+      "type": "struct",
+      "type_mapping": [
+        ["identity", "ValidatorId"],
+        ["first", "DoubleVoteReportStatement"],
+        ["second", "DoubleVoteReportStatement"],
+        ["proof", "DoubleVoteReportProof"],
+        ["signingContext", "SigningContext"]
+      ]
+    },
+    "ElectionCompute": {
+      "type": "enum",
+        "value_list": [
+          "OnChain",
+          "Signed",
+          "Authority"
+        ]
+    },
+    "ElectionResult": {
+      "type": "struct",
+      "type_mapping": [
+        ["compute", "ElectionCompute"],
+        ["slotStake", "Balance"],
+        ["electedStashes", "Vec<AccountId>"],
+        ["exposures", "Vec<(AccountId, Exposure)>"]
+      ]
+    },
+    "ElectionStatus": {
+      "type": "enum",
+      "type_mapping": [
+        ["Close", "Null"],
+        ["Open", "BlockNumber"]
+      ]
+    },
+    "Phase": {
+      "type": "enum",
+      "type_mapping": [
+        ["ApplyExtrinsic", "u32"],
+        ["Finalization", "Null"],
+        ["Initialization", "Null"]
+      ]
+    },
+    "PhragmenScore": "[u128; 3]",
+    "PreimageStatusAvailable": {
+      "type": "struct",
+      "type_mapping": [
+        ["data", "Bytes"],
+        ["provider", "AccountId"],
+        ["deposit", "Balance"],
+        ["since", "BlockNumber"],
+        ["expiry", "Option<BlockNumber>"]
+      ]
+    },
+    "PreimageStatus": {
+      "type": "enum",
+      "type_mapping": [
+        ["Missing", "BlockNumber"],
+        ["Available", "PreimageStatusAvailable"]
+      ]
+    },
+    "Randomness": "Hash",
+    "MaybeRandomness": "Option<Randomness>",
+    "schnorrkel::Randomness": "Hash",
+    "schnorrkel::RawVRFOutput": "[u8; 32]",
+    "TaskAddress": {
+      "type": "struct",
+      "type_mapping": [
+        ["blockNumber", "BlockNumber"],
+        ["index", "u32"]
+      ]
+    },
+    "ValidationCode": "Bytes",
+    "ParaPastCodeMeta": {
+      "type": "struct",
+      "type_mapping": [
+        ["upgrade_times", "Vec<BlockNumber>"],
+        ["last_pruned", "Option<BlockNumber>"]
+      ]
+    },
+    "ModuleId": "LockIdentifier",
+    "RuntimeDbWeight": {
+      "type": "struct",
+      "type_mapping": [
+        ["read", "Weight"],
+        ["write", "Weight"]
+      ]
     }
   }
 }

data/lib/type_registry/kulupu.json

@@ -1,6 +1,6 @@
 {
-  "runtime_id": 2,
+  "runtime_id": 3,
   "types": {
-    "Weight": "u16"
+    "Weight": "u64"
   }
 }

data/lib/type_registry/kusama.json

@@ -1,9 +1,10 @@
 {
-  "runtime_id": 1054,
+  "runtime_id": 1062,
   "types": {
     "Address": "AccountIdAddress",
     "BlockNumber": "U32",
     "LeasePeriod": "BlockNumber",
+    "Weight": "u64",
     "SessionKeysPolkadot": {
       "type": "struct",
       "type_mapping": [
@@ -180,7 +181,47 @@
           ]
         }
       }
+    },
+    {
+      "runtime_range": [1019, 1056],
+      "types": {
+        "Weight": "u32"
+      }
+    },
+    {
+      "runtime_range": [1057, null],
+      "types": {
+        "Weight": "u64"
+      }
+    },
+    {
+      "runtime_range": [1019, 1058],
+      "types": {
+        "Heartbeat": {
+          "type": "struct",
+          "type_mapping": [
+             ["blockNumber", "BlockNumber"],
+             ["networkState", "OpaqueNetworkState"],
+             ["sessionIndex", "SessionIndex"],
+             ["authorityIndex", "AuthIndex"]
+          ]
+        }
+      }
+    },
+    {
+      "runtime_range": [1062, null],
+      "types": {
+        "Heartbeat": {
+          "type": "struct",
+          "type_mapping": [
+             ["blockNumber", "BlockNumber"],
+             ["networkState", "OpaqueNetworkState"],
+             ["sessionIndex", "SessionIndex"],
+             ["authorityIndex", "AuthIndex"],
+             ["validatorsLen", "u32"]
+          ]
+        }
+      }
     }
-
   ]
 }

data/lib/type_registry/westend.json

@@ -1,6 +1,7 @@
 {
-  "runtime_id": 1000,
+  "runtime_id": 1006,
   "types": {
+    "Address": "AccountIdAddress",
     "BlockNumber": "U32",
     "LeasePeriod": "BlockNumber",
     "SessionKeysPolkadot": {

data/scripts/block_events.rb

@@ -0,0 +1,34 @@
+require "scale"
+
+
+client = SubstrateClient.new("ws://127.0.0.1:9944/")
+client.init
+metadata = client.get_metadata nil
+
+the_module = metadata.get_module("CertificateModule")
+puts ""
+puts "CertificateModule calls:"
+puts "---------------------------------------"
+puts the_module[:calls]
+
+the_call = metadata.get_module_call("CertificateModule", "create_entity")
+puts ""
+puts "create_entity call:"
+puts "---------------------------------------"
+puts the_call
+
+
+puts ""
+puts "CertificateModule storages:"
+puts "---------------------------------------"
+puts the_module[:storage][:items]
+
+# Scale::TypeRegistry.instance.metadata = metadata.value
+# puts metadata.value.event_index["0400"][1]
+# puts metadata.value.event_index["0401"][1]
+# puts metadata.value.event_index["0402"][1]
+# hex_events = "0x0c000000000000001027000001010000010000000400be07e2c28688db5368445c33d32b3c7bcad15dab1ec802ba8cccc1c22b86574f6992da89ff412eaf9bafac4024ca23eea8c988a437fc96a1c6445148a8ebb4d2000001000000000010270000000100"
+# scale_bytes = Scale::Bytes.new(hex_events)
+# Scale::Types.get("Vec<EventRecord>").decode(scale_bytes).value.each do |er|
+#   puts er.value
+# end

data/scripts/example.rb

@@ -0,0 +1,4 @@
+require "scale"
+
+client = SubstrateClient.new("wss://kusama-rpc.polkadot.io/")
+client.init

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scale.rb
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.5
 platform: ruby
 authors:
 - Wu Minzhe
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-04-15 00:00:00.000000000 Z
+date: 2020-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: substrate_common.rb
@@ -189,6 +189,8 @@ files:
 - lib/type_registry/test.json
 - lib/type_registry/westend.json
 - scale.gemspec
+- scripts/block_events.rb
+- scripts/example.rb
 - src/lib.rs
 homepage: https://github.com/itering/scale.rb
 licenses: