scale.rb 0.2.12 → 0.2.17

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

@@ -1,14 +1,14 @@
 require "scale/version"
 
-require "substrate_common"
+require "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 +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)
@@ -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
@@ -175,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"
@@ -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.camelize2}>_#{klass.object_id}"
           Scale::Types.const_set fix(name), klass
         else
           raise "#{type_str} not support inner type: #{type_string}"
@@ -266,7 +299,7 @@ module Scale
           include Scale::Types::Tuple
           inner_types *type_strs
         end
-        name = "Tuple_Of_#{type_strs.map(&:camelize).join("_")}_#{klass.object_id}"
+        name = "Tuple_Of_#{type_strs.map(&:camelize2).join("_")}_#{klass.object_id}"
         Scale::Types.const_set fix(name), klass
       else
         if type_string == "Enum"
@@ -279,7 +312,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"
@@ -287,19 +320,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
@@ -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

@@ -313,7 +313,7 @@ module Scale
 
       module ClassMethods
         def decode(scale_bytes)
-          value = "Scale::Types::U#{self::BYTE_LENGTH * 8}".constantize.decode(scale_bytes).value
+          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
@@ -340,7 +340,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,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
@@ -155,9 +141,13 @@ module Scale
           result[:extrinsic_idx] = U32.decode(scale_bytes).value
         end
 
-        type = scale_bytes.get_next_bytes(2).bytes_to_hex[2..]
-        event = metadata.event_index[type][1]
-        # mod = metadata.event_index[type][0]
+        index = scale_bytes.get_next_bytes(2).bytes_to_hex[2..]
+        event = metadata.event_index[index][1]
+        the_module = metadata.event_index[index][0]
+
+        result[:event_index] = index
+        result[:event_metadata] = event
+        result[:module_metadata] = the_module
 
         result[:params] = []
         event[:args].each do |arg_type|
@@ -175,18 +165,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(

data/lib/scale/trie.rb

@@ -0,0 +1,171 @@
+module Scale
+  module Types
+    
+    class TrieNode
+      include SingleValue
+      EMPTY = 0
+      NIBBLE_PER_BYTE = 2
+      BITMAP_LENGTH = 2
+      NIBBLE_LENGTH = 16
+      NIBBLE_SIZE_BOUND = 65535
+
+      def self.decode(scale_bytes)
+        hash = "0x#{Crypto::blake2_256(scale_bytes.bytes)}"
+        first = scale_bytes.get_next_bytes(1).first
+        if first == EMPTY
+          TrieNode.new({})
+        else
+          v = first & (0b11 << 6)
+          decode_size = -> {
+            result = first & 255 >> 2
+            return result if result < 63
+            result -= 1
+            while result <= NIBBLE_SIZE_BOUND
+              n = scale_bytes.get_next_bytes(1).first
+              return (result + n + 1) if n < 255 
+              result += 255
+            end
+            return NIBBLE_SIZE_BOUND
+          }
+
+          if v == 0b01 << 6 # leaf
+            nibble_count = decode_size.call
+            # if nibble_count is odd, the half of first byte of partial is 0
+            padding = (nibble_count % NIBBLE_PER_BYTE) != 0 
+            first_byte_of_partial = scale_bytes.bytes[scale_bytes.offset]
+            if padding && (first_byte_of_partial & 0xf0) != 0
+              raise "bad format"
+            end
+
+            ### partial decoding
+            partial_bytes = scale_bytes.get_next_bytes((nibble_count + (NIBBLE_PER_BYTE - 1)) / NIBBLE_PER_BYTE)
+
+            ### value
+            count = Compact.decode(scale_bytes).value
+            value_bytes = scale_bytes.get_next_bytes(count)
+
+            return TrieNode.new({
+              hash: hash,
+              node_type: "leaf",
+              partial: {
+                hex: partial_bytes.bytes_to_hex, 
+                padding: padding
+              },
+              value: value_bytes.bytes_to_hex
+            })
+          elsif v == 0b10 << 6 || v == 0b11 << 6 # branch without mask || branch with mask
+            nibble_count = decode_size.call
+
+            ### check that the padding is valid (if any)
+            # if nibble_count is odd, the half of first byte of partial is 0
+            padding = nibble_count % NIBBLE_PER_BYTE != 0
+            first_byte_of_partial = scale_bytes.bytes[scale_bytes.offset]
+            if padding && (first_byte_of_partial & 0xf0) != 0 
+              raise "bad format"
+            end
+
+            ### partial decoding
+            partial_bytes = scale_bytes.get_next_bytes((nibble_count + (NIBBLE_PER_BYTE - 1)) / NIBBLE_PER_BYTE)
+
+            ### value decoding
+            if v == 0b11 << 6 # has value
+              count = Compact.decode(scale_bytes).value
+              value_bytes = scale_bytes.get_next_bytes(count)
+            end
+
+            ### children decoding
+            children = []
+            bitmap = U16.decode(scale_bytes).value
+            NIBBLE_LENGTH.times do |i|
+              has_child = (bitmap & (1 << i)) != 0
+              children[i] = nil
+              if has_child
+                count = Compact.decode(scale_bytes).value
+                if count == 32
+                  h = H256.decode(scale_bytes).value
+                  children[i] = h
+                else
+                  inline = scale_bytes.get_next_bytes count
+                  children[i] = inline.bytes_to_hex
+                end
+              end
+            end
+            # debug
+            # children.each_with_index do |child, i|
+            #   if child.nil?
+            #     puts "#{i}: NULL" 
+            #   else
+            #     puts "#{i}: #{child}"
+            #   end
+            # end
+
+            result = TrieNode.new({
+              hash: hash,
+              node_type: "branch",
+              partial: {
+                hex: partial_bytes.bytes_to_hex, 
+                padding: padding
+              },
+              children: children
+            })
+
+            result[:value] = value_bytes.bytes_to_hex if value_bytes
+
+            return result
+          else
+            puts "Not support"
+          end
+
+        end
+      end
+
+      def self.check(root, proof, key)
+        key = Key.new(key)
+
+        nodes = proof.map {|node_data| 
+          node = TrieNode::decode(Scale::Bytes.new(node_data)).value
+          [node[:hash], node]
+        }.to_h
+
+        self.do_check(root, nodes, key)
+      end
+
+      private
+      def self.do_check(hash, nodes, key)
+        if node = nodes[hash]
+          if node[:children]
+            position = key.next_nibble(node[:partial][:hex], node[:partial][:padding]).to_i(16)
+            child = node[:children][position]
+            return self.do_check(child, nodes, key)
+          else
+            return node[:value]
+          end
+        else
+          raise "Fail"
+        end
+      end
+    end
+
+  end
+end
+
+class Key
+  def initialize(value)
+    @value = value[2..] if value.start_with?("0x")
+    @offset = 0
+  end
+
+  def next_nibble(partial, padding)
+    partial = partial[2..] if partial.start_with?("0x")
+    partial = partial[1..] if padding
+
+    new_offset = @offset + partial.length
+    if partial == @value[@offset...new_offset]
+      nibble = @value[new_offset]
+      @offset = new_offset + 1
+      return nibble
+    else
+      raise "Fail"
+    end
+  end
+end