scale.rb 0.2.13 → 0.2.18

data/lib/helper.rb

@@ -0,0 +1,128 @@
+
+class SubstrateClient::Helper
+  class << self
+    def generate_storage_key_from_metadata(metadata, module_name, storage_name, params = nil)
+      # find the storage item from metadata
+      metadata_modules = metadata.value.value[:metadata][:modules]
+      metadata_module = metadata_modules.detect { |mm| mm[:name] == module_name }
+      raise "Module '#{module_name}' not exist" unless metadata_module
+      storage_item = metadata_module[:storage][:items].detect { |item| item[:name] == storage_name }
+      raise "Storage item '#{storage_name}' not exist. \n#{metadata_module.inspect}" unless storage_item
+
+      if storage_item[:type][:Plain]
+        return_type = storage_item[:type][:Plain]
+      elsif map = storage_item[:type][:Map]
+        raise "Storage call of type \"Map\" requires 1 parameter" if params.nil? || params.length != 1
+
+        hasher = map[:hasher]
+        return_type = map[:value]
+        # TODO: decode to account id if param is address
+        # params[0] = decode(params[0]) if map[:key] == "AccountId"
+        type = Scale::Types.get(map[:key])
+        params[0] = type.new(params[0]).encode
+      elsif map = storage_item[:type][:DoubleMap]
+        raise "Storage call of type \"DoubleMapType\" requires 2 parameters" if params.nil? || params.length != 2
+
+        hasher = map[:hasher]
+        hasher2 = map[:key2Hasher]
+        return_type = map[:value]
+        params[0] = Scale::Types.get(map[:key1]).new(params[0]).encode
+        params[1] = Scale::Types.get(map[:key2]).new(params[1]).encode
+      else
+        raise NotImplementedError
+      end
+
+      storage_prefix = metadata_module[:storage][:prefix]
+      storage_key = generate_storage_key(
+        storage_prefix.nil? ? module_name : storage_prefix,
+        storage_name,
+        params,
+        hasher,
+        hasher2,
+        metadata.value.value[:metadata][:version]
+      )
+      [storage_key, return_type]
+    end
+
+    def generate_storage_key(module_name, storage_name, params = nil, hasher = nil, hasher2 = nil, metadata_version = nil)
+      metadata_version = 12 if metadata_version.nil?
+      if metadata_version and metadata_version >= 9
+        storage_key = Crypto.twox128(module_name) + Crypto.twox128(storage_name)
+
+        params&.each_with_index do |param, index|
+          if index == 0
+            param_hasher = hasher
+          elsif index == 1
+            param_hasher = hasher2
+          else
+            raise "Unexpected third parameter for storage call"
+          end
+
+          param_key = if param.class == String && param.start_with?("0x")
+            param.hex_to_bytes
+          else
+            param.encode().hex_to_bytes
+          end
+          param_hasher = "Twox128" if param_hasher.nil?
+          storage_key += Crypto.send(param_hasher.underscore2, param_key)
+        end
+
+        "0x#{storage_key}"
+      else
+        # TODO: add test
+        storage_key = module_name + " " + storage_name
+
+        unless params.nil?
+          params = [params] if params.class != ::Array
+          params_key = params.join("")
+          hasher = "Twox128" if hasher.nil?
+          storage_key += params_key.hex_to_bytes.bytes_to_utf8 
+        end
+
+        "0x#{Crypto.send( hasher.underscore2, storage_key )}"
+      end
+    end
+
+    def compose_call_from_metadata(metadata, module_name, call_name, params)
+      call = metadata.get_module_call(module_name, call_name)
+
+      value = {
+        call_index: call[:lookup],
+        module_name: module_name,
+        call_name: call_name,
+        params: []
+      }
+
+      params.keys.each_with_index do |call_param_name, i|
+        param_value = params[call_param_name]
+        value[:params] << {
+          name: call_param_name.to_s,
+          type: call[:args][i][:type],
+          value: param_value
+        }
+      end
+
+      Scale::Types::Extrinsic.new(value).encode
+    end
+
+    def decode_block(block)
+      block["block"]["header"]["number"] = block["block"]["header"]["number"].to_i(16)
+
+      block["block"]["extrinsics_decoded"] = []
+      block["block"]["extrinsics"].each_with_index do |hex, i|
+        scale_bytes = Scale::Bytes.new(hex)
+        block["block"]["extrinsics_decoded"][i] = Scale::Types::Extrinsic.decode(scale_bytes).to_human
+      end
+
+      block['block']['header']["digest"]["logs_decoded"] = []
+      block['block']['header']["digest"]["logs"].each_with_index do |hex, i|
+        scale_bytes = Scale::Bytes.new(hex)
+        log = Scale::Types::LogDigest.decode(scale_bytes).to_human
+        block['block']['header']["digest"]["logs_decoded"][i] = log
+      end
+
+      block
+    end
+
+  end
+end

data/lib/metadata/metadata.rb

@@ -7,7 +7,7 @@ module Scale
         bytes = scale_bytes.get_next_bytes(4)
         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 MetadataV12]).decode(scale_bytes).value
-          metadata = Metadata.new "Scale::Types::#{metadata_version}".constantize.decode(scale_bytes)
+          metadata = Metadata.new "Scale::Types::#{metadata_version}".constantize2.decode(scale_bytes)
           metadata.version = metadata_version[9..].to_i
         else
           scale_bytes.reset_offset
@@ -35,6 +35,16 @@ module Scale
           end
         end
       end
+
+      def get_module_storage(module_name, storage_name)
+        the_module = get_module(module_name)
+        if the_module[:storage].class == Array
+          storages = the_module[:storage]
+        else
+          storages = the_module[:storage][:items]
+        end
+        storages.find {|storage| storage[:name] == storage_name}
+      end
     end
 
     class MetadataModule
@@ -68,6 +78,10 @@ module Scale
 
         MetadataModule.new(result)
       end
+
+      def get_storage(storage_name)
+        self.value[:storage].find { |storage| storage[:name].downcase == storage_name.downcase }
+      end
     end
 
     class MetadataModuleStorage

data/lib/scale.rb

@@ -1,9 +1,8 @@
 require "scale/version"
 
-require "substrate_common"
+require "common"
+
 require "json"
-require "active_support"
-require "active_support/core_ext/string"
 require "singleton"
 
 require "scale/base"
@@ -26,13 +25,40 @@ require "metadata/metadata_v10"
 require "metadata/metadata_v11"
 require "metadata/metadata_v12"
 
+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
-    attr_reader :spec_name, :types, :versioning, :custom_types
-    attr_accessor :spec_version
+
+    # 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)
@@ -43,13 +69,18 @@ module Scale
 
       default_types, _, _ = load_chain_spec_types("default")
 
-      if spec_name.nil? || spec_name == "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
-      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
@@ -63,7 +94,8 @@ module Scale
 
       if @spec_version && @versioning
         @versioning.each do |item|
-          if @spec_version >= item["runtime_range"][0] && @spec_version <= (item["runtime_range"][1] || 1073741823)
+          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
@@ -176,7 +208,7 @@ module Scale
       types.each do |name, body|
         if body.class == String
           target_type = "Scale::Types::#{body}"
-          klass = Class.new(target_type.constantize) do
+          klass = Class.new(target_type.constantize2) do
           end
         elsif body.class == Hash
           if body["type"] == "struct"
@@ -210,12 +242,18 @@ module Scale
   end
 
   module Types
+    class << self
+      attr_accessor :debug
+    end
+    
     def self.list
       TypeRegistry.instance.types
     end
 
     def self.get(type_name)
-      TypeRegistry.instance.get(type_name)
+      type = TypeRegistry.instance.get(type_name)
+      raise "Type '#{type_name}' not exist" if type.nil?
+      type
     end
 
     def self.constantize(type)
@@ -240,13 +278,32 @@ module Scale
         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
+        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
-          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: #{type_string}"
         end
@@ -263,12 +320,17 @@ module Scale
           type_str.strip.tr(";", ",")
         end
 
-        klass = Class.new do
-          include Scale::Types::Tuple
-          inner_types *type_strs
+        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
-        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
@@ -280,7 +342,7 @@ module Scale
               values(*values)
             end
           end
-          name = values.class == ::Hash ? values.values.map(&:camelize).join("_") : values.map(&:camelize).join("_")
+          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"
@@ -288,19 +350,19 @@ module Scale
             include Scale::Types::Struct
             items values
           end
-          name = "Struct_Of_#{values.values.map(&:camelize).join("_")}_#{klass.object_id}"
+          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(&:camelize).join("_")}_#{klass.object_id}"
+          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.constantize
+            type_name.constantize2
           rescue NameError => e
             puts "#{type_string} is not defined"
           end
@@ -311,12 +373,20 @@ module Scale
 
 end
 
+# def fix(name)
+#   name
+#     .gsub("<", "˂").gsub(">", "˃")
+#     .gsub("(", "⁽").gsub(")", "⁾")
+#     .gsub(" ", "").gsub(",", "‚")
+#     .gsub(":", "։")
+# end
+
 def fix(name)
   name
-    .gsub("<", "˂").gsub(">", "˃")
-    .gsub("(", "⁽").gsub(")", "⁾")
-    .gsub(" ", "").gsub(",", "‚")
-    .gsub(":", "։")
+    .gsub("<", "").gsub(">", "")
+    .gsub("(", "").gsub(")", "")
+    .gsub(" ", "").gsub(",", "")
+    .gsub(":", "")
 end
 
 def rename(type)
@@ -342,7 +412,7 @@ def rename(type)
   return "AccountData" if type == "AccountData<Balance>"
 
   if type =~ /\[U\d+; \d+\]/
-    byte_length = type.scan(/\[U\d+; (\d+)\]/).first.first
+    byte_length = type.scan(/\[U\d+; (\d+)\]/).first.first.to_i
     return "VecU8Length#{byte_length}"
   end
 
@@ -394,3 +464,5 @@ class ::Hash
     Hash[h]
   end
 end
+
+Scale::Types.debug = false

data/lib/scale/base.rb

@@ -33,6 +33,17 @@ module Scale
           @value
         end
       end
+
+      module ClassMethods
+        def inherited(child)
+          child.const_set(:TYPE_NAME, child.name)
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.const_set(:TYPE_NAME, base.name)
+      end
     end
 
     # value: one of nil, false, true, scale object
@@ -41,19 +52,24 @@ module Scale
 
       module ClassMethods
         def decode(scale_bytes)
+          puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
           byte = scale_bytes.get_next_bytes(1)
           if byte == [0]
+            puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
             new(nil)
           elsif byte == [1]
             if self::INNER_TYPE_STR == "boolean"
+              puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
               new(false)
             else
               # big process
               value = Scale::Types.get(self::INNER_TYPE_STR).decode(scale_bytes)
+              puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
               new(value)
             end
           elsif byte == [2]
             if self::INNER_TYPE_STR == "boolean"
+              puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
               new(true)
             else
               raise "bad data"
@@ -89,9 +105,11 @@ module Scale
 
       module ClassMethods
         def decode(scale_bytes)
+          puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
           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)
+          puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
           new(value)
         end
       end
@@ -117,10 +135,15 @@ module Scale
         attr_accessor :byte_length
 
         def decode(scale_bytes)
+          puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
           bytes = scale_bytes.get_next_bytes self::BYTE_LENGTH
           bytes_reversed = bytes.reverse
           hex = bytes_reversed.reduce("0x") { |hex, byte| hex + byte.to_s(16).rjust(2, "0") }
-          new(hex.to_i(16))
+          result = new(hex.to_i(16))
+
+          puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
+
+          result
         end
       end
 
@@ -142,9 +165,14 @@ module Scale
       include SingleValue
       # new(1.to_u32, U32(69))
       module ClassMethods
+        def inherited(child)
+          child.const_set(:TYPE_NAME, child.name)
+        end
+
         def decode(scale_bytes)
+          puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
           item_values = self::ITEM_TYPE_STRS.map do |item_type_str|
-            type = Scale::TypeRegistry.instance.get(item_type_str)
+            type = Scale::Types.get(item_type_str)
             type.decode(scale_bytes)
           end
 
@@ -157,6 +185,7 @@ module Scale
           value.each_pair do |attr, val|
             result.send "#{attr}=", val
           end
+          puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
           result
         end
 
@@ -177,6 +206,7 @@ module Scale
 
       def self.included(base)
         base.extend ClassMethods
+        base.const_set(:TYPE_NAME, base.name)
       end
 
       def encode
@@ -193,9 +223,11 @@ module Scale
 
       module ClassMethods
         def decode(scale_bytes)
+          puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
           values = self::TYPE_STRS.map do |type_str|
             Scale::Types.get(type_str).decode(scale_bytes)
           end
+          puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
           new(values)
         end
 
@@ -218,6 +250,7 @@ module Scale
 
       module ClassMethods
         def decode(scale_bytes)
+          puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
           index = scale_bytes.get_next_bytes(1)[0]
           if const_defined? "ITEM_TYPE_STRS"
             item_type_str = self::ITEM_TYPE_STRS[index]
@@ -226,7 +259,9 @@ module Scale
           else
             value = self::VALUES[index]
           end
-          new(value)
+          result = new(value)
+          puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
+          result
         end
 
         def items(items)
@@ -279,6 +314,7 @@ module Scale
 
       module ClassMethods
         def decode(scale_bytes, raw = false)
+          puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
           number = Scale::Types::Compact.decode(scale_bytes).value
           items = []
           number.times do
@@ -286,6 +322,7 @@ module Scale
             item = type.decode(scale_bytes)
             items << item
           end
+          puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
           raw ? items : new(items)
         end
 
@@ -313,10 +350,12 @@ module Scale
 
       module ClassMethods
         def decode(scale_bytes)
-          value = "Scale::Types::U#{self::BYTE_LENGTH * 8}".constantize.decode(scale_bytes).value
+          puts "  BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
+          value = "Scale::Types::U#{self::BYTE_LENGTH * 8}".constantize2.decode(scale_bytes).value
           return new [] unless value || value <= 0
 
           result = self::ITEMS.select { |_, mask| value & mask > 0 }.keys
+          puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
           new result
         end
 
@@ -340,7 +379,7 @@ module Scale
 
       def encode
         value = self.class::ITEMS.select { |key, _| self.value.include?(key) }.values.sum
-        "Scale::Types::U#{self.class::BYTE_LENGTH * 8}".constantize.new(value).encode
+        "Scale::Types::U#{self.class::BYTE_LENGTH * 8}".constantize2.new(value).encode
       end
     end
 
@@ -349,15 +388,17 @@ module Scale
 
       module ClassMethods
         def decode(scale_bytes)
-          byte_length = name[25..]
-          raise "length is wrong: #{byte_length}" unless %w[2 3 4 8 16 20 32 64].include?(byte_length)
-          byte_length = byte_length.to_i
+          puts "  BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
+          byte_length = self::BYTE_LENGTH
+          raise "#{self.name} byte length is wrong: #{byte_length}" unless %w[2 3 4 8 16 20 32 64 128 256].include?(byte_length.to_s)
 
           bytes = scale_bytes.get_next_bytes(byte_length)
           str = bytes.pack("C*").force_encoding("utf-8")
           if str.valid_encoding?
+            puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
             new str
           else
+            puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
             new bytes.bytes_to_hex
           end
         end
@@ -368,12 +409,10 @@ module Scale
       end
 
       def encode
-        class_name = self.class.to_s
-        length = class_name[25..]
-        raise "length is wrong: #{length}" unless %w[2 3 4 8 16 20 32 64].include?(length)
-        length = length.to_i
+        byte_length = self.class::BYTE_LENGTH
+        raise "#{self.class.name}'s byte length is wrong: #{byte_length}" unless %w[2 3 4 8 16 20 32 64 128 256].include?(byte_length.to_s)
 
-        if value.start_with?("0x") && value.length == (length * 2 + 2)
+        if value.start_with?("0x") && value.length == (byte_length * 2 + 2)
           value[2..]
         else
           bytes = value.unpack("C*")