scale.rb 0.2.17 → 0.3.1

data/lib/metadata/metadata_v9.rb

@@ -1,7 +1,7 @@
 module Scale
   module Types
     class MetadataV9
-      include SingleValue
+      include Base
       attr_accessor :call_index, :event_index
 
       def initialize(value)
@@ -11,7 +11,7 @@ module Scale
       end
 
       def self.decode(scale_bytes)
-        modules = Scale::Types.type_of("Vec<MetadataV8Module>").decode(scale_bytes).value
+        modules = Scale::Types.get("Vec<MetadataV8Module>").decode(scale_bytes).value
 
         value = {
           magicNumber: 1_635_018_093,

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,361 +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
+  class ScaleError < StandardError; end
+  class TypeBuildError < ScaleError; end
+  class BadDataError < ScaleError; end
+  class TypeRegistryNotLoadYet < ScaleError; end
+  class StorageInputTypeError < ScaleError; end
 
-      default_types, _, _ = load_chain_spec_types("default")
+  module Types
+    class << self
+      attr_accessor :debug, :logger
+    end
 
-      if spec_name
+    def self.check_types
+      TypeRegistry.instance.all_types.keys.each do |key|
         begin
-          @spec_name = spec_name
-          spec_types, @versioning, @spec_version = load_chain_spec_types(spec_name)
-          @types = default_types.merge(spec_types)
+          type = self.get(key)
         rescue => ex
-          puts "There is no types json file named #{spec_name}"
-          @types = default_types
+          puts "[[ERROR]] #{key}: #{ex}"
         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
-
-  module Types
-    def self.list
-      TypeRegistry.instance.types
-    end
-
-    def self.get(type_name)
-      TypeRegistry.instance.get(type_name)
-    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
-    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" || type_str == "Option"
-          klass = Class.new do
-            include Scale::Types.type_of(type_str)
-            inner_type inner_type_str
-          end
-          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}"
-        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
-
-        klass = Class.new do
-          include Scale::Types::Tuple
-          inner_types *type_strs
-        end
-        name = "Tuple_Of_#{type_strs.map(&:camelize2).join("_")}_#{klass.object_id}"
-        Scale::Types.const_set fix(name), klass
-      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
-        end
-      end
-    end
-  end
-
-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)
@@ -389,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
@@ -426,3 +124,6 @@ class ::Hash
     Hash[h]
   end
 end
+
+Scale::Types.debug = false
+Scale::Types.logger = Logger.new(STDOUT)

data/lib/scale/base.rb

@@ -1,7 +1,7 @@
 module Scale
   module Types
 
-    module SingleValue
+    module Base
       attr_reader :value
 
       def initialize(value)
@@ -9,62 +9,74 @@ module Scale
       end
 
       def ==(other)
-        value == other.value
+        self.class == other.class && self.value == other.value
       end
 
       def to_human
         if @value.class == ::Hash
           @value.transform_values do |v|
-            if v.class.included_modules.include?(SingleValue)
+            if v.class.included_modules.include?(Base)
               v.to_human
             else
               v
             end
-          end
+          end.transform_keys(&:to_sym)
         elsif @value.class == ::Array
           @value.map do |v|
-            if v.class.included_modules.include?(SingleValue)
+            if v.class.included_modules.include?(Base)
               v.to_human
             else
               v
             end
           end
+        elsif @value.class.include?(Base)
+          @value.to_human
         else
           @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
+    # if value is bool, see type `OptionBool` in types.rb
     module Option
-      include SingleValue
+      include Base
 
       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"
-              new(false)
-            else
-              # big process
-              value = Scale::Types.get(self::INNER_TYPE_STR).decode(scale_bytes)
-              new(value)
-            end
-          elsif byte == [2]
-            if self::INNER_TYPE_STR == "boolean"
-              new(true)
-            else
-              raise "bad data"
-            end
+            # big process
+            type = 
+              if self::INNER_TYPE.class == ::String
+                Scale::Types.get(self::INNER_TYPE)
+              else
+                self::INNER_TYPE
+              end
+            value = type.decode(scale_bytes)
+            puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
+            new(value)
           else
-            raise "bad data"
+            raise BadDataError.new("Bad scale data for #{self::TYPE_NAME}")
           end
         end
 
-        def inner_type(type_str)
-          const_set(:INNER_TYPE_STR, type_str)
+        def inner_type(type)
+          const_set(:INNER_TYPE, type)
         end
       end
 
@@ -77,21 +89,21 @@ module Scale
         if value.nil?
           "00"
         else
-          return "02" if value.class == TrueClass && value === true
-          return "01" if value.class == FalseClass && value === false
           "01" + value.encode
         end
       end
     end
 
     module FixedWidthInt
-      include SingleValue
+      include Base
 
       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
@@ -111,16 +123,21 @@ module Scale
     end
 
     module FixedWidthUInt
-      include SingleValue
+      include Base
 
       module ClassMethods
         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
 
@@ -139,68 +156,85 @@ module Scale
     end
 
     module Struct
-      include SingleValue
+      include Base
       # new(1.to_u32, U32(69))
       module ClassMethods
+        def inherited(child)
+          child.const_set(:TYPE_NAME, child.name)
+        end
+
         def decode(scale_bytes)
-          item_values = self::ITEM_TYPE_STRS.map do |item_type_str|
-            type = Scale::TypeRegistry.instance.get(item_type_str)
-            type.decode(scale_bytes)
+          puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
+
+          # item_values: 
+          # {
+          #   a: ...,
+          #   b: ...
+          # }
+          item_values = {}
+          self::ITEMS.each_pair do |item_name, item_type|
+            if item_type.class == ::String
+              item_type = Scale::Types.get(item_type)
+            end
+            item_values[item_name] = item_type.decode(scale_bytes)
           end
 
-          value = {}
-          self::ITEM_NAMES.zip(item_values) do |attr, val|
-            value[attr] = val
-          end
+          # value = {}
+          # self::ITEM_NAMES.zip(item_values) do |attr, val|
+          #   value[attr] = val
+          # end
 
-          result = new(value)
-          value.each_pair do |attr, val|
-            result.send "#{attr}=", val
+          puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
+
+          result = new(item_values)
+          item_values.each_pair do |item_name, item_value|
+            result.send "#{item_name.to_s}=", item_value
           end
+
           result
         end
 
-        def items(items)
-          attr_names = []
-          attr_type_strs = []
-
-          items.each_pair do |attr_name, attr_type_str|
-            attr_names << attr_name.to_s.gsub("-", "")
-            attr_type_strs << attr_type_str
-          end
-
-          const_set(:ITEM_NAMES, attr_names)
-          const_set(:ITEM_TYPE_STRS, attr_type_strs)
-          attr_accessor *attr_names
+        # items(a: Scale::Types::Type1, b: "Type2")
+        def items(**items)
+          const_set(:ITEMS, items)
+          item_names = items.keys
+          attr_accessor *item_names
         end
       end
 
       def self.included(base)
         base.extend ClassMethods
+        base.const_set(:TYPE_NAME, base.name)
       end
 
       def encode
-        [].tap do |result|
-          value.each_pair do |attr_name, attr_value|
-            result << attr_value.encode
-          end
+        value.values.map do |item_value|
+          item_value.encode
         end.join
       end
     end
 
     module Tuple
-      include SingleValue
+      include Base
 
       module ClassMethods
         def decode(scale_bytes)
-          values = self::TYPE_STRS.map do |type_str|
-            Scale::Types.get(type_str).decode(scale_bytes)
+          puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
+
+          values = self::INNER_TYPES.map do |type|
+            if type.class == ::String
+              type = Scale::Types.get(type)
+            end
+            type.decode(scale_bytes)
           end
+
+          puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
           new(values)
         end
 
-        def inner_types(*type_strs)
-          const_set(:TYPE_STRS, type_strs)
+        # inner_types Scale::Types::U8, "U8"
+        def inner_types(*inner_types)
+          const_set(:INNER_TYPES, inner_types)
         end
       end
 
@@ -214,38 +248,46 @@ module Scale
     end
 
     module Enum
-      include SingleValue
+      include Base
+
+      attr_accessor :index
 
       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]
-            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)
-          else
+          if const_defined? "ITEMS"
+            type = self::ITEMS.values[index]
+            if type.class == ::String
+              type = Scale::Types.get(type)
+            end
+            value = type.decode(scale_bytes)
+          elsif const_defined? "INNER_TYPES"
+            type = self::INNER_TYPES[index]
+            if type.class == ::String
+              type = Scale::Types.get(type)
+            end
+            value = type.decode(scale_bytes)
+          else # VALUES
             value = self::VALUES[index]
           end
-          new(value)
+          puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
+          result = new(value)
+          result.index = index
+          result
         end
 
-        def items(items)
-          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
+        # inner_types(Scale::Types::Compact, "Hex")
+        def inner_types(*inner_types)
+          const_set(:INNER_TYPES, inner_types)
+        end
 
-            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
+        # items(Item1: Scale::Types::Compact, Item2: "Hex")
+        def items(**items)
+          const_set(:ITEMS, items)
         end
 
+        # [1, "hello"]
         def values(*values)
           const_set(:VALUES, values)
         end
@@ -256,17 +298,17 @@ module Scale
       end
 
       def encode
-        if self.class.const_defined? "ITEM_NAMES"
-          value_type_str = value.class.to_s.split("::").last.to_s
-          index = self.class::ITEM_TYPE_STRS.index(value_type_str).to_s(16).rjust(2, "0")
-          index + value.encode
+        if self.class.const_defined? "ITEMS"
+          index.to_s(16).rjust(2, "0") + value.encode
         else
           self.class::VALUES.index(value).to_s(16).rjust(2, "0")
         end
       end
 
       def to_human
-        if self.class.const_defined? "ITEM_TYPE_STRS"
+        if self.class.const_defined? "ITEMS"
+          @value.to_human
+        elsif self.class.const_defined? "INNER_TYPES"
           @value.to_human
         else
           @value
@@ -275,22 +317,23 @@ module Scale
     end
 
     module Vec
-      include SingleValue # value is an array
+      include Base # value is an array
 
       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
-            type = Scale::Types.get(self::INNER_TYPE_STR)
-            item = type.decode(scale_bytes)
+            item = self::INNER_TYPE.decode(scale_bytes)
             items << item
           end
+          puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
           raw ? items : new(items)
         end
 
-        def inner_type(type_str)
-          const_set(:INNER_TYPE_STR, type_str)
+        def inner_type(type)
+          const_set(:INNER_TYPE, type)
         end
       end
 
@@ -309,14 +352,16 @@ module Scale
     end
 
     module Set
-      include SingleValue
+      include Base
 
       module ClassMethods
         def decode(scale_bytes)
+          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
 
@@ -345,18 +390,21 @@ module Scale
     end
 
     module VecU8FixedLength
-      include SingleValue
+      include Base
 
       module ClassMethods
         def decode(scale_bytes)
+          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
@@ -379,5 +427,39 @@ module Scale
       end
     end
 
+    module Array
+      include Base
+
+      module ClassMethods
+        def decode(scale_bytes)
+          puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
+          items = (0 ... self::LENGTH).map do |_|
+            self::INNER_TYPE.decode(scale_bytes)
+          end
+          puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
+          new(items)
+        end
+
+        def inner_type(type)
+          const_set(:INNER_TYPE, type)
+        end
+
+        def length(len)
+          const_set(:LENGTH, len)
+        end
+      end
+
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      def encode
+        self.value.map do |item|
+          item.encode
+        end.join
+      end
+    end
+
+
   end
 end