scale.rb 0.2.18 → 0.3.2

data/lib/scale/block.rb

@@ -2,11 +2,11 @@ module Scale
   module Types
 
     class Extrinsic
-      include SingleValue
+      include Base
       # attr_accessor :address, :signature, :nonce, :era, :extrinsic_hash, :call_index, :params_raw, :params
 
-      def self.generate_hash(data)
-        Blake2b.hex data, Blake2b::Key.none, 32
+      def self.generate_hash(bytes)
+        Crypto.blake2_256 bytes
       end
 
       def self.decode(scale_bytes)
@@ -61,10 +61,10 @@ module Scale
 
           if contains_transaction
             result[:address] = Scale::Types.get("Address").decode(scale_bytes).value
-            result[:signature] = scale::types.get("MultiSignature").decode(scale_bytes).value
-            result[:era] = scale::types.get("era").decode(scale_bytes).value
-            result[:nonce] = scale::types.get("compact").decode(scale_bytes).value
-            result[:tip] = scale::types.get("compact").decode(scale_bytes).value
+            result[:signature] = Scale::Types.get("MultiSignature").decode(scale_bytes).value
+            result[:era] = Scale::Types.get("Era").decode(scale_bytes).value
+            result[:nonce] = Scale::Types.get("Compact").decode(scale_bytes).value
+            result[:tip] = Scale::Types.get("Compact").decode(scale_bytes).value
             result[:extrinsic_hash] = generate_hash(scale_bytes.bytes)
           end
           result[:call_index] = scale_bytes.get_next_bytes(2).bytes_to_hex[2..]
@@ -116,7 +116,7 @@ module Scale
     end
 
     class EventRecords
-      include SingleValue
+      include Base
       
       def self.decode(scale_bytes)
 
@@ -129,7 +129,7 @@ module Scale
     end
 
     class EventRecord
-      include SingleValue
+      include Base
 
       def self.decode(scale_bytes)
         metadata = Scale::TypeRegistry.instance.metadata.value
@@ -211,7 +211,7 @@ module Scale
 
     class LogDigest
       include Enum
-      items %w[Other AuthoritiesChange ChangesTrieRoot SealV0 Consensus Seal PreRuntime]
+      inner_types *%w[Other AuthoritiesChange ChangesTrieRoot SealV0 Consensus Seal PreRuntime]
     end
 
   end

data/lib/scale/trie.rb

@@ -2,7 +2,7 @@ module Scale
   module Types
     
     class TrieNode
-      include SingleValue
+      include Base
       EMPTY = 0
       NIBBLE_PER_BYTE = 2
       BITMAP_LENGTH = 2

data/lib/scale/types.rb

@@ -2,7 +2,7 @@ module Scale
   module Types
 
     class Bool
-      include SingleValue
+      include Base
       BYTES_LENGTH = 1
 
       def self.decode(scale_bytes)
@@ -10,10 +10,10 @@ module Scale
         bytes = scale_bytes.get_next_bytes(self::BYTES_LENGTH)
         if bytes == [0]
           puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
-          Bool.new(false)
+          new(false)
         elsif bytes == [1]
           puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
-          Bool.new(true)
+          new(true)
         else
           raise "Bad data"
         end
@@ -24,6 +24,35 @@ module Scale
       end
     end
 
+    class OptionBool
+      include Base
+      def self.decode(scale_bytes)
+        byte = scale_bytes.get_next_bytes(1)[0]
+        value = if byte == 0x00
+                  nil
+                elsif byte == 0x01
+                  true
+                elsif byte == 0x02
+                  false
+                else
+                  raise BadDataError.new("Bad scale data for OptionBool #{byte.to_s(16)}")
+                end
+        new(value)
+      end
+
+      def encode
+        if value.nil?
+          "00"
+        elsif value === true
+          "01"
+        elsif value === false
+          "02"
+        else
+          raise WrongValueError.new("OptionBool can not have value other than `nil`, `true`, `false`")
+        end
+      end
+    end
+
     class U8
       include FixedWidthUInt
       BYTE_LENGTH = 1
@@ -54,6 +83,11 @@ module Scale
       BYTE_LENGTH = 32
     end
 
+    class U512
+      include FixedWidthUInt
+      BYTE_LENGTH = 64
+    end
+
     class I8
       include FixedWidthInt
       BYTE_LENGTH = 1
@@ -80,7 +114,7 @@ module Scale
     end
 
     class Compact
-      include SingleValue
+      include Base
 
       def self.decode(scale_bytes)
         puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
@@ -118,7 +152,7 @@ module Scale
           end
 
         puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
-        Compact.new(value)
+        new(value)
       end
 
       def encode
@@ -143,7 +177,7 @@ module Scale
     end
 
     class Bytes
-      include SingleValue
+      include Base
 
       def self.decode(scale_bytes)
         puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
@@ -153,12 +187,13 @@ module Scale
         # [67, 97, 102, 195, 169].pack('C*').force_encoding('utf-8')
         # => "Café"
         str = bytes.pack("C*").force_encoding("utf-8")
-        if str.valid_encoding?
+        # TODO: ?
+        if (not str.include?("\u0000")) && str.valid_encoding?
           puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
-          Bytes.new str
+          new str
         else
           puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
-          Bytes.new bytes.bytes_to_hex
+          new bytes.bytes_to_hex
         end
       end
 
@@ -176,35 +211,40 @@ module Scale
     end
 
     class Hex
-      include SingleValue
+      include Base
 
       def self.decode(scale_bytes)
         puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
         length = Scale::Types::Compact.decode(scale_bytes).value
         hex_string = scale_bytes.get_next_bytes(length).bytes_to_hex
         puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
-        Hex.new(hex_string)
+        new(hex_string)
+      end
+
+      def encode
+        length = Compact.new((value.length - 2)/2).encode
+        "#{length}#{value[2..]}"
       end
     end
 
     class String
-      include SingleValue
+      include Base
       def self.decode(scale_bytes)
         puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
         length = Scale::Types::Compact.decode(scale_bytes).value
         bytes = scale_bytes.get_next_bytes(length)
         puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
-        String.new bytes.pack("C*").force_encoding("utf-8")
+        new bytes.pack("C*").force_encoding("utf-8")
       end
     end
 
     class H160
-      include SingleValue
+      include Base
       def self.decode(scale_bytes)
         puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
         bytes = scale_bytes.get_next_bytes(20)
         puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
-        H160.new(bytes.bytes_to_hex)
+        new(bytes.bytes_to_hex)
       end
 
       def encode
@@ -214,12 +254,12 @@ module Scale
     end
 
     class H256
-      include SingleValue
+      include Base
       def self.decode(scale_bytes)
         puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
         bytes = scale_bytes.get_next_bytes(32)
         puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
-        H256.new(bytes.bytes_to_hex)
+        new(bytes.bytes_to_hex)
       end
 
       def encode
@@ -229,12 +269,12 @@ module Scale
     end
 
     class H512
-      include SingleValue
+      include Base
       def self.decode(scale_bytes)
         puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
         bytes = scale_bytes.get_next_bytes(64)
         puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
-        H512.new(bytes.bytes_to_hex)
+        new(bytes.bytes_to_hex)
       end
 
       def encode
@@ -244,7 +284,7 @@ module Scale
     end
 
     class GenericAddress
-      include SingleValue
+      include Base
 
       # https://github.com/paritytech/substrate/wiki/External-Address-Format-(SS58)
       # base58encode ( concat ( <address-type>, <address>, <checksum> ) )
@@ -260,7 +300,7 @@ module Scale
           account_length = [account_length].bytes_to_hex
 
           puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
-          Address.new({
+          new({
             account_id: account_id,
             account_length: account_length
           })
@@ -279,7 +319,7 @@ module Scale
           account_length = [account_length].bytes_to_hex
 
           puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
-          Address.new({
+          new({
             account_index: account_index,
             account_length: account_length
           })
@@ -302,7 +342,7 @@ module Scale
     class AccountIdAddress < GenericAddress
       def self.decode(scale_bytes)
         puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
-        result = AccountIdAddress.new({
+        result = new({
           account_id: AccountId.decode(scale_bytes).value,
           account_length: "0xff"
         })
@@ -316,6 +356,17 @@ module Scale
       end
     end
 
+    class GenericMultiAddress
+      include Enum
+      items(
+        Id: "AccountId",
+        Index: "Compact",
+        Raw: "Hex",
+        Address32: "H256",
+        Address20: "H160"
+      )
+    end
+
     class AccountId < H256; end
 
     class Balance < U128; end
@@ -327,14 +378,14 @@ module Scale
     class AccountIndex < U32; end
 
     class Era
-      include SingleValue
+      include Base
       def self.decode(scale_bytes)
         puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
         byte = scale_bytes.get_next_bytes(1).bytes_to_hex
         result = if byte == "0x00"
-          Era.new byte
+          new byte
         else
-          Era.new byte + scale_bytes.get_next_bytes(1).bytes_to_hex()[2..]
+          new byte + scale_bytes.get_next_bytes(1).bytes_to_hex()[2..]
         end
         puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
         result
@@ -346,7 +397,7 @@ module Scale
     class Moment < U64; end
 
     class CompactMoment
-      include SingleValue
+      include Base
       def self.decode(scale_bytes)
         puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
         value = Compact.decode(scale_bytes).value
@@ -355,7 +406,7 @@ module Scale
         end
 
         puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
-        CompactMoment.new Time.at(value).strftime("%F %T")
+        new Time.at(value).strftime("%F %T")
       end
     end
 
@@ -459,9 +510,9 @@ module Scale
     end
 
     class Null
-      include SingleValue
+      include Base
       def self.decode(scale_bytes)
-        Null.new nil
+        new nil
       end
 
       def encode
@@ -652,20 +703,20 @@ module Scale
       include Struct
       items(
         id: "VecU8Length8",
-        amount: "Balance",
+        amount: "Scale::Types::Balance",
         until: "U32",
-        reasons: "WithdrawReasons"
+        reasons: "Scale::Types::WithdrawReasons"
       )
     end
 
     class EthereumAddress
-      include SingleValue
+      include Base
 
       def self.decode(scale_bytes)
         puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
         bytes = scale_bytes.get_next_bytes(20)
         puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
-        EthereumAddress.new(bytes.bytes_to_hex)
+        new(bytes.bytes_to_hex)
       end
 
       def encode
@@ -678,12 +729,12 @@ module Scale
     end
 
     class EcdsaSignature
-      include SingleValue
+      include Base
 
       def self.decode(scale_bytes)
         puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
         bytes = scale_bytes.get_next_bytes(65)
-        EcdsaSignature.new(bytes.bytes_to_hex)
+        new(bytes.bytes_to_hex)
         puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
       end
 
@@ -790,7 +841,7 @@ module Scale
     end
 
     class VoteOutcome
-      include SingleValue
+      include Base
       def self.decode(scale_bytes)
         puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
         result = new(scale_bytes.get_next_bytes(32))
@@ -834,7 +885,7 @@ module Scale
     end
 
     class BoxProposal
-      include SingleValue
+      include Base
 
       def self.decode(scale_bytes, metadata, chain_spec)
         puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
@@ -872,7 +923,7 @@ module Scale
     end
 
     class VecH512Length2
-      include SingleValue
+      include Base
 
       def self.decode(scale_bytes)
       end
@@ -885,7 +936,7 @@ module Scale
     end
 
     class GenericBlock
-      include SingleValue
+      include Base
 
       def self.decode(scale_bytes)
       end

data/lib/scale/version.rb

@@ -1,3 +1,3 @@
 module Scale
-  VERSION = "0.2.18".freeze
+  VERSION = "0.3.2".freeze
 end

data/lib/scale.rb

@@ -5,6 +5,11 @@ require "common"
 require "json"
 require "singleton"
 
+require "scale_bytes"
+
+require "type_registry"
+require "type_builder"
+
 require "scale/base"
 require "scale/types"
 require "scale/block"
@@ -24,399 +29,36 @@ require "metadata/metadata_v9"
 require "metadata/metadata_v10"
 require "metadata/metadata_v11"
 require "metadata/metadata_v12"
+require "metadata/metadata_v13"
 
 require "substrate_client"
 require "logger"
 require "helper"
 
-class String
-  def upcase_first
-    self.sub(/\S/, &:upcase)
-  end
-
-  def camelize2
-    self.split('_').collect(&:upcase_first).join
-  end
-
-  def underscore2
-    self.gsub(/::/, '/').
-    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-    gsub(/([a-z\d])([A-Z])/,'\1_\2').
-    tr("-", "_").
-    downcase
-  end
-end
-
 module Scale
-  class Error < StandardError; end
-
-  class TypeRegistry
-    include Singleton
-
-    # init by load, and will not change
-    attr_reader :spec_name, :types
-    attr_reader :versioning, :custom_types # optional
-
-    # will change by different spec version
-    attr_accessor :spec_version # optional
-    attr_accessor :metadata
-
-    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
-        begin
-          @spec_name = spec_name
-          spec_types, @versioning, @spec_version = load_chain_spec_types(spec_name)
-          @types = default_types.merge(spec_types)
-        rescue => ex
-          puts "There is no types json file named #{spec_name}"
-          @types = default_types
-        end
-      else
-        @spec_name = "default"
-        @types = default_types
-      end
-
-      self.custom_types = custom_types
-      true
-    end
-
-    def get(type_name)
-      raise "Types not loaded" if @types.nil?
-
-      all_types = {}.merge(@types)
-
-      if @spec_version && @versioning
-        @versioning.each do |item|
-          if @spec_version >= item["runtime_range"][0] && 
-              ( item["runtime_range"][1].nil? || @spec_version <= item["runtime_range"][1] )
-            all_types.merge!(item["types"])
-          end
-        end
-      end
-
-      all_types.merge!(@custom_types) if @custom_types
-
-      type = type_traverse(type_name, all_types)
-
-      Scale::Types.constantize(type)
-    end
-
-    def custom_types=(custom_types)
-      @custom_types = custom_types.stringify_keys if (not custom_types.nil?) && custom_types.class.name == "Hash"
-    end
-
-    private
-
-      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)
-
-        runtime_id = json["runtime_id"]
-
-        [json["types"], json["versioning"], runtime_id]
-      end
-
-      def type_traverse(type, types)
-        type = rename(type) if type.class == ::String
-        if types.has_key?(type) && types[type] != type
-          type_traverse(types[type], types)
-        else
-          type
-        end
-      end
-  end
-
-  # TODO: == implement
-
-  class Bytes
-    attr_reader :data, :bytes
-    attr_reader :offset
-
-    def initialize(data)
-      if (data.class == Array) && data.is_byte_array?
-        @bytes = data
-      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
-      @offset = 0
-    end
-
-    def reset_offset
-      @offset = 0
-    end
-
-    def get_next_bytes(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 += length
-      result
-    rescue RangeError => ex
-      puts "length: #{length}"
-      puts ex.message
-      puts ex.backtrace
-    end
-
-    def get_remaining_bytes
-      @bytes[offset..]
-    end
-
-    def to_hex_string
-      @bytes.bytes_to_hex
-    end
-
-    def to_bin_string
-      @bytes.bytes_to_bin
-    end
-
-    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
-
-  class TypesLoader
-    def self.load(filename)
-      path = File.join File.dirname(__FILE__), "types", filename
-      content = File.open(path).read
-      result = JSON.parse content
-
-      types = result["default"]
-      types.each do |name, body|
-        if body.class == String
-          target_type = "Scale::Types::#{body}"
-          klass = Class.new(target_type.constantize2) do
-          end
-        elsif body.class == Hash
-          if body["type"] == "struct"
-            struct_params = {}
-            body["type_mapping"].each do |mapping|
-              struct_params[mapping[0].to_sym] = mapping[1]
-            end
-            klass = Class.new do
-            end
-            klass.send(:include, Scale::Types::Struct)
-            klass.send(:items, struct_params)
-            Scale::Types.const_set name, klass
-          elsif body["type"] = "enum"
-            klass = Class.new do
-            end
-            klass.send(:include, Scale::Types::Enum)
-            if body["type_mapping"]
-              struct_params = {}
-              body["type_mapping"].each do |mapping|
-                struct_params[mapping[0].to_sym] = mapping[1]
-              end
-              klass.send(:items, struct_params)
-            else
-              klass.send(:values, body["value_list"])
-            end
-            Scale::Types.const_set name, klass
-          end
-        end
-      end
-    end
-  end
+  class ScaleError < StandardError; end
+  class TypeBuildError < ScaleError; end
+  class BadDataError < ScaleError; end
+  class TypeRegistryNotLoadYet < ScaleError; end
+  class StorageInputTypeError < ScaleError; end
 
   module Types
     class << self
-      attr_accessor :debug
-    end
-    
-    def self.list
-      TypeRegistry.instance.types
-    end
-
-    def self.get(type_name)
-      type = TypeRegistry.instance.get(type_name)
-      raise "Type '#{type_name}' not exist" if type.nil?
-      type
-    end
-
-    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
+      attr_accessor :debug, :logger
     end
 
-    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"
-          name = "#{type_str}<#{inner_type_str.camelize2}>"
-          name = fix(name)
-
-          if !Scale::Types.const_defined?(name)
-            klass = Class.new do
-              include Scale::Types::Vec
-              inner_type inner_type_str
-            end
-            Scale::Types.const_set name, klass
-          else
-            Scale::Types.const_get name
-          end
-        elsif type_str == "Option"
-          name = "#{type_str}<#{inner_type_str.camelize2}>"
-          name = fix(name)
-
-          if !Scale::Types.const_defined?(name)
-            klass = Class.new do
-              include Scale::Types::Option
-              inner_type inner_type_str
-            end
-            Scale::Types.const_set name, klass
-          else
-            Scale::Types.const_get name
-          end
-        else
-          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
-        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
-
-        name = "TupleOf#{type_strs.map(&:camelize2).join("")}"
-        name = fix(name)
-        if !Scale::Types.const_defined?(name)
-          klass = Class.new do
-            include Scale::Types::Tuple
-            inner_types *type_strs
-          end
-          Scale::Types.const_set name, klass
-        else
-          Scale::Types.const_get name
-        end
-      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(&:camelize2).join("_") : values.map(&:camelize2).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(&:camelize2).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(&:camelize2).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.constantize2
-          rescue NameError => e
-            puts "#{type_string} is not defined"
-          end
+    def self.check_types
+      TypeRegistry.instance.all_types.keys.each do |key|
+        begin
+          type = self.get(key)
+        rescue => ex
+          puts "[[ERROR]] #{key}: #{ex}"
         end
       end
+      true
     end
-  end
-
-end
-
-# def fix(name)
-#   name
-#     .gsub("<", "˂").gsub(">", "˃")
-#     .gsub("(", "⁽").gsub(")", "⁾")
-#     .gsub(" ", "").gsub(",", "‚")
-#     .gsub(":", "։")
-# end
-
-def fix(name)
-  name
-    .gsub("<", "").gsub(">", "")
-    .gsub("(", "").gsub(")", "")
-    .gsub(" ", "").gsub(",", "")
-    .gsub(":", "")
-end
 
-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>"
-  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 "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.to_i
-    return "VecU8Length#{byte_length}"
   end
-
-  type
 end
 
 def green(text)
@@ -427,6 +69,24 @@ def yellow(text)
   "\033[33m#{text}\033[0m"
 end
 
+class String
+  def upcase_first
+    self.sub(/\S/, &:upcase)
+  end
+
+  def camelize2
+    self.split('_').collect(&:upcase_first).join
+  end
+
+  def underscore2
+    self.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+end
+
 # https://www.ruby-forum.com/t/question-about-hex-signed-int/125510/4
 # machine bit length:
 #   machine_byte_length = ['foo'].pack('p').size
@@ -466,3 +126,4 @@ class ::Hash
 end
 
 Scale::Types.debug = false
+Scale::Types.logger = Logger.new(STDOUT)