scale.rb 0.1.0 → 0.2.0

data/lib/metadata/metadata_v0.rb

@@ -0,0 +1,206 @@
+module Scale
+  module Types
+    class MetadataV0
+      include SingleValue
+      attr_accessor :call_index, :event_index
+
+      def initialize(value)
+        @call_index = {}
+        @event_index = {}
+        super(value)
+      end
+
+      def self.decode(scale_bytes)
+        value = {
+          metadata: {
+            version: 0,
+            outerEvent: {
+              name: Bytes.decode(scale_bytes).value,
+              events: []
+            },
+            modules: [],
+            outerDispatch: {
+              name: "Call",
+              calls: []
+            }
+          }
+        }
+
+        events_modules = Scale::Types.type_of("Vec<MetadataV0EventModule>").decode(scale_bytes).value.map(&:value)
+        modules = Scale::Types.type_of("Vec<MetadataV0Module>").decode(scale_bytes).value.map(&:value)
+
+        Bytes.decode(scale_bytes).value
+
+        sections = Scale::Types.type_of("Vec<MetadataV0Section>").decode(scale_bytes).value.map(&:value)
+
+        value[:metadata][:outerEvent][:events] = events_modules
+        value[:metadata][:modules] = modules
+        value[:metadata][:outerDispatch][:calls] = sections
+
+        result = MetadataV0.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 MetadataV0EventModule
+      include SingleValue
+
+      def self.decode(scale_bytes)
+        name = Bytes.decode(scale_bytes).value
+        events = Scale::Types.type_of('Vec<MetadataV0Event>').decode(scale_bytes).value.map(&:value)
+        MetadataV0EventModule.new([
+          name, 
+          events
+        ])
+      end
+    end
+
+    class MetadataV0Event
+      include SingleValue
+
+      def self.decode(scale_bytes)
+        name = Bytes.decode(scale_bytes).value
+        args = Scale::Types.type_of("Vec<Bytes>").decode(scale_bytes).value.map(&:value)
+        documentation = Scale::Types.type_of("Vec<Bytes>").decode(scale_bytes).value.map(&:value)
+        MetadataV0Event.new({name: name, args: args.map {|arg| arg }, documentation: documentation})
+      end
+    end
+
+    class MetadataV0Module
+      include SingleValue
+
+      def self.decode(scale_bytes)
+        prefix = Bytes.decode(scale_bytes).value
+        name = Bytes.decode(scale_bytes).value
+        call_name = Bytes.decode(scale_bytes).value
+
+        functions = Scale::Types.type_of("Vec<MetadataV0ModuleFunction>").decode(scale_bytes).value.map(&:value)
+
+        result = {
+            prefix: prefix,
+            module: {
+                name: name,
+                call: {
+                    name: call_name,
+                    functions: functions
+                }
+            }
+        }
+
+        has_storage = Bool.decode(scale_bytes).value
+        if has_storage
+          storage_prefix = Bytes.decode(scale_bytes).value
+          storage = Scale::Types.type_of("Vec<MetadataV0ModuleStorage>").decode(scale_bytes).value.map(&:value)
+          result[:storage] = {
+            prefix: storage_prefix,
+            functions: storage
+          }
+        end
+
+        MetadataV0Module.new(result)
+      end
+    end
+
+    class MetadataV0ModuleFunction
+      include SingleValue
+
+      def self.decode(scale_bytes)
+        id = U16.decode(scale_bytes).value
+        name = Bytes.decode(scale_bytes).value
+        args = Scale::Types.type_of("Vec<MetadataModuleCallArgument>").decode(scale_bytes).value.map(&:value)
+        documentation = Scale::Types.type_of("Vec<Bytes>").decode(scale_bytes).value.map(&:value)
+        MetadataV0ModuleFunction.new({
+          id: id,
+          name: name,
+          args: args,
+          documentation: documentation
+        })
+      end
+    end
+
+    class MetadataModuleCallArgument
+      include SingleValue
+
+      def self.decode(scale_bytes)
+        name = Bytes.decode(scale_bytes).value
+        type = Bytes.decode(scale_bytes).value
+
+        MetadataModuleCallArgument.new({name: name, type: type})
+      end
+    end
+
+    class MetadataV0ModuleStorage
+      include SingleValue
+
+      def self.decode(scale_bytes)
+        name = Bytes.decode(scale_bytes).value
+        modifier = Scale::Types.type_of("Enum", ["Optional", "Default"]).decode(scale_bytes).value
+
+        is_key_value = Bool.decode(scale_bytes).value
+
+        if is_key_value
+          type = {
+            Map: {
+              key: Bytes.decode(scale_bytes).value,
+              value: Bytes.decode(scale_bytes).value
+            }
+          }
+        else
+          type = {
+            Plain: Bytes.decode(scale_bytes).value
+          }
+        end
+
+        fallback = Hex.decode(scale_bytes).value
+        documentation = Scale::Types.type_of("Vec<Bytes>").decode(scale_bytes).value.map(&:value)
+
+        MetadataV0ModuleStorage.new({
+          name: name,
+          modifier: modifier,
+          type: type,
+          fallback: fallback,
+          documentation: documentation
+        })
+      end
+    end
+
+    class MetadataV0Section
+      include SingleValue
+
+      def self.decode(scale_bytes)
+        name = Bytes.decode(scale_bytes).value
+        prefix = Bytes.decode(scale_bytes).value
+        id = U16.decode(scale_bytes).value
+        
+        MetadataV0Section.new({
+          name: name,
+          prefix: prefix,
+          index: id
+        })
+      end
+    end
+
+  end
+end

data/lib/metadata/metadata_v1.rb

@@ -0,0 +1,120 @@
+module Scale
+  module Types
+    class MetadataV1
+      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<MetadataV1Module>").decode(scale_bytes).value
+
+        value = {
+          magicNumber: 1_635_018_093,
+          metadata: {
+            version: 1,
+            modules: modules.map(&:value)
+          }
+        }
+
+        result = MetadataV1.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 MetadataV1Module
+      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<MetadataV1ModuleStorage>").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
+
+        MetadataModule.new(result)
+      end
+    end
+
+    class MetadataV1ModuleStorage
+      include SingleValue
+
+      def self.decode(scale_bytes)
+        name = Bytes.decode(scale_bytes).value
+        modifier = Scale::Types.type_of("Enum", ["Optional", "Default"]).decode(scale_bytes).value
+
+        is_key_value = Bool.decode(scale_bytes).value
+
+        if is_key_value
+          type = {
+            MapType: {
+              key: adjust(Bytes.decode(scale_bytes).value),
+              value: adjust(Bytes.decode(scale_bytes).value)
+            }
+          }
+        else
+          type = {
+            PlainType: adjust(Bytes.decode(scale_bytes).value)
+          }
+        end
+
+        fallback = Hex.decode(scale_bytes).value
+        docs = Scale::Types.type_of("Vec<Bytes>").decode(scale_bytes).value
+
+        MetadataV1ModuleStorage.new({
+          name: name,
+          modifier: modifier,
+          type: type,
+          default: fallback,
+          docs: docs
+        })
+      end
+    end
+
+  end
+end

data/lib/metadata/metadata_v10.rb

@@ -1,22 +1,51 @@
 module Scale
   module Types
-
     class MetadataV10
       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<MetadataV8Module>").decode(scale_bytes).value;
-        result = {
-          magicNumber: 1635018093,
+        modules = Scale::Types.type_of("Vec<MetadataV8Module>").decode(scale_bytes).value
+
+        value = {
+          magicNumber: 1_635_018_093,
           metadata: {
-            V10: {
-              modules: modules.map(&:value)
-            }
+            version: 10,
+            modules: modules.map(&:value)
           }
         }
 
-        MetadataV10.new(result)
+        result = MetadataV10.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_v11.rb

@@ -0,0 +1,51 @@
+module Scale
+  module Types
+    class MetadataV11
+      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<MetadataV8Module>").decode(scale_bytes).value
+
+        value = {
+          magicNumber: 1_635_018_093,
+          metadata: {
+            version: 11,
+            modules: modules.map(&:value)
+          }
+        }
+
+        result = MetadataV11.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_v2.rb

@@ -0,0 +1,51 @@
+module Scale
+  module Types
+    class MetadataV2
+      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<MetadataModule>").decode(scale_bytes).value
+
+        value = {
+          magicNumber: 1_635_018_093,
+          metadata: {
+            version: 2,
+            modules: modules.map(&:value)
+          }
+        }
+
+        result = MetadataV2.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