scale.rb 0.1.0 → 0.2.0

data/lib/metadata/metadata_v3.rb

@@ -1,22 +1,51 @@
 module Scale
   module Types
-
     class MetadataV3
       include SingleValue
+      attr_accessor :call_index, :event_index
+
+      def initialize(value)
+        @call_index = {}
+        @event_index = {}
+        super(value)
+      end
+
       def self.decode(scale_bytes)
-        modules = type_of("Vec<MetadataModule>").decode(scale_bytes).value;
-        result = {
-          magicNumber: 1635018093,
+        modules = Scale::Types.type_of("Vec<MetadataModule>").decode(scale_bytes).value
+
+        value = {
+          magicNumber: 1_635_018_093,
           metadata: {
-            V3: {
-              modules: modules.map(&:value)
-            }
+            version: 3,
+            modules: modules.map(&:value)
           }
         }
 
-        MetadataV3.new(result)
+        result = MetadataV3.new(value)
+
+        call_module_index = 0
+        event_module_index = 0
+
+        modules.map(&:value).each do |m|
+          if m[:calls]
+            m[:calls].each_with_index do |call, index|
+              call[:lookup] = "%02x%02x" % [call_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" % [call_module_index, index]
+              result.event_index[event[:lookup]] = [m, event]
+            end
+            event_module_index += 1
+          end
+        end
+
+        result
       end
     end
-
   end
 end

data/lib/metadata/metadata_v4.rb

@@ -0,0 +1,126 @@
+module Scale
+  module Types
+    class MetadataV4
+      include SingleValue
+      attr_accessor :call_index, :event_index
+
+      def initialize(value)
+        @call_index = {}
+        @event_index = {}
+        super(value)
+      end
+
+      def self.decode(scale_bytes)
+        modules = Scale::Types.type_of("Vec<MetadataV4Module>").decode(scale_bytes).value
+
+        value = {
+          magicNumber: 1_635_018_093,
+          metadata: {
+            version: 4,
+            modules: modules.map(&:value)
+          }
+        }
+
+        result = MetadataV4.new(value)
+
+        call_module_index = 0
+        event_module_index = 0
+
+        modules.map(&:value).each do |m|
+          if m[:calls]
+            m[:calls].each_with_index do |call, index|
+              call[:lookup] = "%02x%02x" % [call_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" % [call_module_index, index]
+              result.event_index[event[:lookup]] = [m, event]
+            end
+            event_module_index += 1
+          end
+        end
+
+        result
+      end
+    end
+
+    class MetadataV4Module
+      include SingleValue
+      def self.decode(scale_bytes)
+        name = String.decode(scale_bytes).value
+        prefix = String.decode(scale_bytes).value
+
+        result = {
+          name: name,
+          prefix: prefix
+        }
+
+        has_storage = Bool.decode(scale_bytes).value
+        if has_storage
+          storages = Scale::Types.type_of("Vec<MetadataV4ModuleStorage>").decode(scale_bytes).value
+          result[:storage] = storages.map(&:value)
+        end
+
+        has_calls = Bool.decode(scale_bytes).value
+        if has_calls
+          calls = Scale::Types.type_of("Vec<MetadataModuleCall>").decode(scale_bytes).value
+          result[:calls] = calls.map(&:value)
+        end
+
+        has_events = Bool.decode(scale_bytes).value
+        if has_events
+          events = Scale::Types.type_of("Vec<MetadataModuleEvent>").decode(scale_bytes).value
+          result[:events] = events.map(&:value)
+        end
+
+        MetadataV4Module.new(result)
+      end
+    end
+
+    class MetadataV4ModuleStorage
+      include SingleValue
+      def self.decode(scale_bytes)
+        result = {
+          name: String.decode(scale_bytes).value,
+          modifier: Scale::Types.type_of("Enum", %w[Optional Default]).decode(scale_bytes).value
+        }
+
+        storage_function_type = Scale::Types.type_of("Enum", %w[Plain Map DoubleMap]).decode(scale_bytes).value
+        if storage_function_type == "Plain"
+          result[:type] = {
+            Plain: adjust(String.decode(scale_bytes).value)
+          }
+        elsif storage_function_type == "Map"
+          result[:type] = {
+            Map: {
+              hasher: StorageHasher.decode(scale_bytes).value,
+              key: adjust(String.decode(scale_bytes).value),
+              value: adjust(String.decode(scale_bytes).value),
+              linked: Bool.decode(scale_bytes).value
+            }
+          }
+        elsif storage_function_type == "DoubleMap"
+          result[:type] = {
+            DoubleMap: {
+              hasher: StorageHasher.decode(scale_bytes).value,
+              key1: adjust(String.decode(scale_bytes).value),
+              key2: adjust(String.decode(scale_bytes).value),
+              value: adjust(String.decode(scale_bytes).value),
+              key2Hasher: StorageHasher.decode(scale_bytes).value
+            }
+          }
+        end
+
+        result[:fallback] = Hex.decode(scale_bytes).value
+        result[:documentation] = Scale::Types.type_of("Vec<String>").decode(scale_bytes).value.map(&:value)
+
+        MetadataV4ModuleStorage.new(result)
+      end
+    end
+
+  end
+end

data/lib/metadata/metadata_v5.rb

@@ -0,0 +1,126 @@
+module Scale
+  module Types
+    class MetadataV5
+      include SingleValue
+      attr_accessor :call_index, :event_index
+
+      def initialize(value)
+        @call_index = {}
+        @event_index = {}
+        super(value)
+      end
+
+      def self.decode(scale_bytes)
+        modules = Scale::Types.type_of("Vec<MetadataV5Module>").decode(scale_bytes).value
+
+        value = {
+          magicNumber: 1_635_018_093,
+          metadata: {
+            version: 5,
+            modules: modules.map(&:value)
+          }
+        }
+
+        result = MetadataV5.new(value)
+
+        call_module_index = 0
+        event_module_index = 0
+
+        modules.map(&:value).each do |m|
+          if m[:calls]
+            m[:calls].each_with_index do |call, index|
+              call[:lookup] = "%02x%02x" % [call_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" % [call_module_index, index]
+              result.event_index[event[:lookup]] = [m, event]
+            end
+            event_module_index += 1
+          end
+        end
+
+        result
+      end
+    end
+
+    class MetadataV5Module
+      include SingleValue
+      def self.decode(scale_bytes)
+        name = String.decode(scale_bytes).value
+        prefix = String.decode(scale_bytes).value
+
+        result = {
+          name: name,
+          prefix: prefix
+        }
+
+        has_storage = Bool.decode(scale_bytes).value
+        if has_storage
+          storages = Scale::Types.type_of("Vec<MetadataV5ModuleStorage>").decode(scale_bytes).value
+          result[:storage] = storages.map(&:value)
+        end
+
+        has_calls = Bool.decode(scale_bytes).value
+        if has_calls
+          calls = Scale::Types.type_of("Vec<MetadataModuleCall>").decode(scale_bytes).value
+          result[:calls] = calls.map(&:value)
+        end
+
+        has_events = Bool.decode(scale_bytes).value
+        if has_events
+          events = Scale::Types.type_of("Vec<MetadataModuleEvent>").decode(scale_bytes).value
+          result[:events] = events.map(&:value)
+        end
+
+        MetadataV5Module.new(result)
+      end
+    end
+
+    class MetadataV5ModuleStorage
+      include SingleValue
+      def self.decode(scale_bytes)
+        result = {
+          name: String.decode(scale_bytes).value,
+          modifier: Scale::Types.type_of("Enum", %w[Optional Default]).decode(scale_bytes).value
+        }
+
+        storage_function_type = Scale::Types.type_of("Enum", %w[Plain Map DoubleMap]).decode(scale_bytes).value
+        if storage_function_type == "Plain"
+          result[:type] = {
+            Plain: adjust(String.decode(scale_bytes).value)
+          }
+        elsif storage_function_type == "Map"
+          result[:type] = {
+            Map: {
+              hasher: StorageHasher.decode(scale_bytes).value,
+              key: adjust(String.decode(scale_bytes).value),
+              value: adjust(String.decode(scale_bytes).value),
+              linked: Bool.decode(scale_bytes).value
+            }
+          }
+        elsif storage_function_type == "DoubleMap"
+          result[:type] = {
+            DoubleMap: {
+              hasher: StorageHasher.decode(scale_bytes).value,
+              key1: adjust(String.decode(scale_bytes).value),
+              key2: adjust(String.decode(scale_bytes).value),
+              value: adjust(String.decode(scale_bytes).value),
+              key2Hasher: StorageHasher.decode(scale_bytes).value
+            }
+          }
+        end
+
+        result[:fallback] = Hex.decode(scale_bytes).value
+        result[:documentation] = Scale::Types.type_of("Vec<String>").decode(scale_bytes).value.map(&:value)
+
+        MetadataV5ModuleStorage.new(result)
+      end
+    end
+
+  end
+end

data/lib/metadata/metadata_v6.rb

@@ -0,0 +1,101 @@
+module Scale
+  module Types
+    class MetadataV6
+      include SingleValue
+      attr_accessor :call_index, :event_index
+
+      def initialize(value)
+        @call_index = {}
+        @event_index = {}
+        super(value)
+      end
+
+      def self.decode(scale_bytes)
+        modules = Scale::Types.type_of("Vec<MetadataV6Module>").decode(scale_bytes).value
+
+        value = {
+          magicNumber: 1_635_018_093,
+          metadata: {
+            version: 6,
+            modules: modules.map(&:value)
+          }
+        }
+
+        result = MetadataV6.new(value)
+
+        call_module_index = 0
+        event_module_index = 0
+
+        modules.map(&:value).each do |m|
+          if m[:calls]
+            m[:calls].each_with_index do |call, index|
+              call[:lookup] = "%02x%02x" % [call_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" % [call_module_index, index]
+              result.event_index[event[:lookup]] = [m, event]
+            end
+            event_module_index += 1
+          end
+        end
+
+        result
+      end
+    end
+
+    class MetadataV6Module
+      include SingleValue
+      def self.decode(scale_bytes)
+        name = String.decode(scale_bytes).value
+        prefix = String.decode(scale_bytes).value
+
+        result = {
+          name: name,
+          prefix: prefix
+        }
+
+        has_storage = Bool.decode(scale_bytes).value
+        if has_storage
+          storages = Scale::Types.type_of("Vec<MetadataV6ModuleStorage>").decode(scale_bytes).value
+          result[:storage] = storages.map(&:value)
+        end
+
+        has_calls = Bool.decode(scale_bytes).value
+        if has_calls
+          calls = Scale::Types.type_of("Vec<MetadataModuleCall>").decode(scale_bytes).value
+          result[:calls] = calls.map(&:value)
+        end
+
+        has_events = Bool.decode(scale_bytes).value
+        if has_events
+          events = Scale::Types.type_of("Vec<MetadataModuleEvent>").decode(scale_bytes).value
+          result[:events] = events.map(&:value)
+        end
+
+        result[:constants] = Scale::Types.type_of("Vec<MetadataV6ModuleConstants>").decode(scale_bytes).value.map(&:value)
+
+        MetadataV6Module.new(result)
+      end
+    end
+
+    class MetadataV6ModuleStorage < MetadataV5ModuleStorage; end
+
+    class MetadataV6ModuleConstants
+      include SingleValue
+      def self.decode(scale_bytes)
+        result = {
+          name: String.decode(scale_bytes).value,
+          type: String.decode(scale_bytes).value, # convert
+          value: Hex.decode(scale_bytes).value,
+          docs: Scale::Types.type_of("Vec<String>").decode(scale_bytes).value.map(&:value)
+        }
+        MetadataV6ModuleConstants.new result
+      end
+    end
+  end
+end

data/lib/metadata/metadata_v7.rb

@@ -1,20 +1,50 @@
 module Scale
   module Types
-
     class MetadataV7
       include SingleValue
+      attr_accessor :call_index, :event_index
+
+      def initialize(value)
+        @call_index = {}
+        @event_index = {}
+        super(value)
+      end
+
       def self.decode(scale_bytes)
-        modules = type_of("Vec<MetadataV7Module>").decode(scale_bytes).value;
-        result = {
-          magicNumber: 1635018093,
+        modules = Scale::Types.type_of("Vec<MetadataV7Module>").decode(scale_bytes).value
+
+        value = {
+          magicNumber: 1_635_018_093,
           metadata: {
-            V7: {
-              modules: modules.map(&:value)
-            }
+            version: 7,
+            modules: modules.map(&:value)
           }
         }
 
-        MetadataV7.new(result)
+        result = MetadataV7.new(value)
+
+        call_module_index = 0
+        event_module_index = 0
+
+        modules.map(&:value).each do |m|
+          if m[:calls]
+            m[:calls].each_with_index do |call, index|
+              call[:lookup] = "%02x%02x" % [call_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" % [call_module_index, index]
+              result.event_index[event[:lookup]] = [m, event]
+            end
+            event_module_index += 1
+          end
+        end
+
+        result
       end
     end
 
@@ -24,7 +54,7 @@ module Scale
         name = String.decode(scale_bytes).value
 
         result = {
-          name: name,
+          name: name
         }
 
         has_storage = Bool.decode(scale_bytes).value
@@ -36,17 +66,17 @@ module Scale
 
         has_calls = Bool.decode(scale_bytes).value
         if has_calls
-          calls = type_of("Vec<MetadataModuleCall>").decode(scale_bytes).value
+          calls = Scale::Types.type_of("Vec<MetadataModuleCall>").decode(scale_bytes).value
           result[:calls] = calls.map(&:value)
         end
 
         has_events = Bool.decode(scale_bytes).value
         if has_events
-          events = type_of("Vec<MetadataModuleEvent>").decode(scale_bytes).value
+          events = Scale::Types.type_of("Vec<MetadataModuleEvent>").decode(scale_bytes).value
           result[:events] = events.map(&:value)
         end
 
-        result[:constants] = type_of("Vec<MetadataV7ModuleConstants>").decode(scale_bytes).value.map(&:value)
+        result[:constants] = Scale::Types.type_of("Vec<MetadataV7ModuleConstants>").decode(scale_bytes).value.map(&:value)
 
         MetadataV7Module.new(result)
       end
@@ -56,7 +86,7 @@ module Scale
       include SingleValue
       def self.decode(scale_bytes)
         prefix = String.decode(scale_bytes).value
-        items = type_of("Vec<MetadataV7ModuleStorageEntry>").decode(scale_bytes).value.map(&:value)
+        items = Scale::Types.type_of("Vec<MetadataV7ModuleStorageEntry>").decode(scale_bytes).value.map(&:value)
         result = {
           prefix: prefix,
           items: items
@@ -71,9 +101,9 @@ module Scale
       def self.decode(scale_bytes)
         result = {
           name: String.decode(scale_bytes).value,
-          modifier: type_of("Enum", enum_values: ["Optional", "Default"]).decode(scale_bytes).value
+          modifier: Scale::Types.type_of("Enum", %w[Optional Default]).decode(scale_bytes).value
         }
-        storage_function_type = type_of("Enum", enum_values: ["Plain", "Map", "DoubleMap"]).decode(scale_bytes).value
+        storage_function_type = Scale::Types.type_of("Enum", %w[Plain Map DoubleMap]).decode(scale_bytes).value
         if storage_function_type == "Plain"
           result[:type] = {
             Plain: adjust(String.decode(scale_bytes).value)
@@ -100,7 +130,7 @@ module Scale
         end
 
         result[:fallback] = Hex.decode(scale_bytes).value
-        result[:docs] = type_of("Vec<String>").decode(scale_bytes).value.map(&:value)
+        result[:docs] = Scale::Types.type_of("Vec<String>").decode(scale_bytes).value.map(&:value)
 
         MetadataV7ModuleStorageEntry.new(result)
       end
@@ -113,11 +143,10 @@ module Scale
           name: String.decode(scale_bytes).value,
           type: String.decode(scale_bytes).value, # convert
           value: Hex.decode(scale_bytes).value,
-          docs: type_of("Vec<String>").decode(scale_bytes).value.map(&:value)
+          docs: Scale::Types.type_of("Vec<String>").decode(scale_bytes).value.map(&:value)
         }
         MetadataV7ModuleConstants.new result
       end
     end
-
   end
 end