scale.rb 0.2.10 → 0.2.16

data/Cargo.toml

@@ -2,10 +2,17 @@
 name = "SCALE-testing-interface"
 version = "0.1.0"
 authors = ["Robert Hambrock <robert@web3.foundation>"]
+edition = "2018"
 
 [dependencies]
-parity-scale-codec = { version = "1.2.0" }
+parity-scale-codec = { version = "1.3.6" }
+sp-core = { version = "2.0.0", git = "https://github.com/paritytech/substrate.git", features = ["full_crypto"]}
+frame-support = { version = "2.0.0", git = "https://github.com/paritytech/substrate.git" }
 
 [lib]
 name = "scale_ffi"
-crate-type = ["dylib"]
+crate-type = ["dylib"]
+
+[[bin]]
+name = "storage_key"
+path = "src/storage_key.rs"

data/Gemfile.lock

@@ -1,32 +1,24 @@
 PATH
   remote: .
   specs:
-    scale.rb (0.2.10)
-      activesupport (>= 4.0.0)
+    scale.rb (0.2.16)
       json (~> 2.3.0)
-      substrate_common.rb (~> 0.1.9)
+      kontena-websocket-client (~> 0.1.1)
+      substrate_common.rb (~> 0.1.10)
       thor (~> 0.19.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (6.0.3.4)
-      concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (>= 0.7, < 2)
-      minitest (~> 5.1)
-      tzinfo (~> 1.1)
-      zeitwerk (~> 2.2, >= 2.2.2)
     base58 (0.2.3)
     blake2b (0.10.0)
     coderay (1.1.2)
-    concurrent-ruby (1.1.7)
     diff-lcs (1.3)
     ffi (1.12.2)
-    i18n (1.8.5)
-      concurrent-ruby (~> 1.0)
     json (2.3.1)
+    kontena-websocket-client (0.1.1)
+      websocket-driver (~> 0.6.5)
     method_source (0.9.2)
-    minitest (5.14.2)
     pry (0.12.2)
       coderay (~> 1.1.0)
       method_source (~> 0.9.0)
@@ -44,16 +36,15 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.9.0)
     rspec-support (3.9.0)
-    substrate_common.rb (0.1.9)
+    substrate_common.rb (0.1.10)
       base58
       blake2b
       xxhash
     thor (0.19.4)
-    thread_safe (0.3.6)
-    tzinfo (1.2.7)
-      thread_safe (~> 0.1)
+    websocket-driver (0.6.5)
+      websocket-extensions (>= 0.1.0)
+    websocket-extensions (0.1.5)
     xxhash (0.4.0)
-    zeitwerk (2.4.1)
 
 PLATFORMS
   ruby

data/exe/scale

@@ -75,6 +75,15 @@ class ScaleCli < Thor
     type = Scale::Types.get(type_name)
     p "0x" + type.new(value.to_i).encode
   end
+
+  desc "check_read_proof ROOT PROOF STORAGE_KEY", "check read proof and output leaf's value"
+  def check_read_proof(root, proof, storage_key)
+    Scale::TypeRegistry.instance.load
+    proof = proof.split(",").map(&:strip)
+    
+    value = Scale::Types::TrieNode::check(root, proof, storage_key)
+    p value
+  end
 end
 
 ScaleCli.start(ARGV)

data/lib/helper.rb

@@ -0,0 +1,126 @@
+
+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.underscore, 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.underscore, 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"].each_with_index do |hex, i|
+        scale_bytes = Scale::Bytes.new(hex)
+        block["block"]["extrinsics"][i] = Scale::Types::Extrinsic.decode(scale_bytes).to_human
+      end
+
+      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"][i] = log
+      end
+
+      block
+    end
+
+  end
+end

data/lib/metadata/metadata.rb

@@ -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/metadata/metadata_v12.rb

@@ -26,21 +26,19 @@ module Scale
         call_module_index = 0
         event_module_index = 0
 
-        modules.map(&:value).each do |m|
+        modules.map(&:value).each_with_index do |m, module_index|
           if m[:calls]
             m[:calls].each_with_index do |call, index|
-              call[:lookup] = "%02x%02x" % [call_module_index, index]
+              call[:lookup] = "%02x%02x" % [module_index, index]
               result.call_index[call[:lookup]] = [m, call]
             end
-            call_module_index += 1
           end
 
           if m[:events]
             m[:events].each_with_index do |event, index|
-              event[:lookup] = "%02x%02x" % [event_module_index, index]
+              event[:lookup] = "%02x%02x" % [module_index, index]
               result.event_index[event[:lookup]] = [m, event]
             end
-            event_module_index += 1
           end
         end
 

data/lib/scale.rb

@@ -2,13 +2,12 @@ require "scale/version"
 
 require "substrate_common"
 require "json"
-require "active_support"
-require "active_support/core_ext/string"
 require "singleton"
 
 require "scale/base"
 require "scale/types"
 require "scale/block"
+require "scale/trie"
 
 require "metadata/metadata"
 require "metadata/metadata_v0"
@@ -25,13 +24,41 @@ require "metadata/metadata_v10"
 require "metadata/metadata_v11"
 require "metadata/metadata_v12"
 
+require "substrate_client"
+require "logger"
+require "helper"
+require 'kontena-websocket-client'
+
+class String
+  def upcase_first
+    self.sub(/\S/, &:upcase)
+  end
+
+  def camelize
+    self.split('_').collect(&:upcase_first).join
+  end
+
+  def underscore
+    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)
@@ -42,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
@@ -62,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
@@ -244,7 +277,7 @@ module Scale
             include Scale::Types.type_of(type_str)
             inner_type inner_type_str
           end
-          name = "#{type_str}_Of_#{inner_type_str.camelize}_#{klass.object_id}"
+          name = "#{type_str}<#{inner_type_str.camelize}>_#{klass.object_id}"
           Scale::Types.const_set fix(name), klass
         else
           raise "#{type_str} not support inner type: #{type_string}"
@@ -341,7 +374,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
 

data/lib/scale/base.rb

@@ -349,9 +349,8 @@ 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
+          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")
@@ -368,12 +367,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*")

data/lib/scale/block.rb

@@ -10,7 +10,7 @@ module Scale
       end
 
       def self.decode(scale_bytes)
-        metadata = Scale::TypeRegistry.instance.metadata
+        metadata = Scale::TypeRegistry.instance.metadata.value
         result = {}
 
         extrinsic_length = Compact.decode(scale_bytes).value
@@ -24,9 +24,6 @@ module Scale
           if contains_transaction
             address = Scale::Types.get("Address").decode(scale_bytes)
             result[:address] = address.value
-            result[:account_length] = address.account_length
-            result[:account_id] = address.account_id
-            result[:account_index] = address.account_index
             result[:signature] = Scale::Types.get("Signature").decode(scale_bytes).value
             result[:nonce] = Scale::Types.get("Compact").decode(scale_bytes).value
             result[:era] = Scale::Types.get("Era").decode(scale_bytes).value
@@ -39,9 +36,6 @@ module Scale
           if contains_transaction
             address = Scale::Types.get("Address").decode(scale_bytes)
             result[:address] = address.value
-            result[:account_length] = address.account_length
-            result[:account_id] = address.account_id
-            result[:account_index] = address.account_index
             result[:signature] = Scale::Types.get("Signature").decode(scale_bytes).value
             result[:era] = Scale::Types.get("Era").decode(scale_bytes).value
             result[:nonce] = Scale::Types.get("Compact").decode(scale_bytes).value
@@ -55,9 +49,6 @@ module Scale
           if contains_transaction
             address = Scale::Types.get("Address").decode(scale_bytes)
             result[:address] = address.value
-            result[:account_length] = address.account_length
-            result[:account_id] = address.account_id
-            result[:account_index] = address.account_index
             result[:signature] = Scale::Types.get("Signature").decode(scale_bytes).value
             result[:era] = Scale::Types.get("Era").decode(scale_bytes).value
             result[:nonce] = Scale::Types.get("Compact").decode(scale_bytes).value
@@ -69,16 +60,11 @@ module Scale
         elsif version_info == "0x04" || version_info == "0x84"
 
           if contains_transaction
-            address = Scale::Types.get("Address").decode(scale_bytes)
-            result[:address] = address.value
-            result[:account_length] = address.account_length
-            result[:account_id] = address.account_id
-            result[:account_index] = address.account_index
-            result[:signature_version] = Scale::Types.get("U8").decode(scale_bytes).value
-            result[:signature] = Scale::Types.get("Signature").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[: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[:extrinsic_hash] = generate_hash(scale_bytes.bytes)
           end
           result[:call_index] = scale_bytes.get_next_bytes(2).bytes_to_hex[2..]
@@ -146,7 +132,7 @@ module Scale
       include SingleValue
 
       def self.decode(scale_bytes)
-        metadata = Scale::TypeRegistry.instance.metadata
+        metadata = Scale::TypeRegistry.instance.metadata.value
 
         result = {}
         phase = scale_bytes.get_next_bytes(1).first
@@ -175,18 +161,18 @@ module Scale
       end
     end
 
-    # log
-    class Other < Bytes; end
-
     class AuthoritiesChange 
       include Vec
       inner_type "AccountId"
     end
 
-    class ConsensusEngineId < VecU8Length4; end
+    class GenericConsensusEngineId < VecU8Length4; end
 
     class ChangesTrieRoot < Bytes; end
 
+    # log
+    class Other < Bytes; end
+
     class SealV0
       include Struct
       items(