scale_rb 0.1.14 → 0.2.0

data/lib/metadata/metadata.rb

@@ -1,129 +1,137 @@
 # frozen_string_literal: true
 
-module Metadata
-  class << self
-    def decode_metadata(bytes)
-      metadata, = ScaleRb.decode('MetadataTop', bytes, TYPES)
-      metadata
+module ScaleRb
+  module Metadata
+    class << self
+      def decode_metadata(bytes)
+        metadata, = ScaleRb.decode('MetadataTop', bytes, TYPES)
+        metadata
+      end
+
+      def build_registry(metadata)
+        raise ScaleRb::NotImplemented, metadata._get(:metadata).keys.first unless metadata._get(:metadata)._key?(:v14)
+
+        metadata_v14 = metadata._get(:metadata)._get(:v14)
+        MetadataV14.build_registry(metadata_v14)
+      end
+
+      def get_module(pallet_name, metadata)
+        version = metadata._get(:metadata).keys.first
+        raise ScaleRb::NotImplemented, metadata._get(:metadata).keys.first unless %w[v9 v10 v11 v12 v13
+                                                                                     v14].include?(version.to_s)
+
+        Metadata.const_get("Metadata#{version.upcase}").get_module(pallet_name, metadata)
+      end
+
+      def get_module_by_index(pallet_index, metadata)
+        version = metadata._get(:metadata).keys.first
+        raise ScaleRb::NotImplemented, metadata._get(:metadata).keys.first unless %w[v9 v10 v11 v12 v13
+                                                                                     v14].include?(version.to_s)
+
+        Metadata.const_get("Metadata#{version.upcase}").get_module_by_index(pallet_index, metadata)
+      end
+
+      def get_storage_item(pallet_name, item_name, metadata)
+        version = metadata._get(:metadata).keys.first
+        raise ScaleRb::NotImplemented, metadata._get(:metadata).keys.first unless %w[v9 v10 v11 v12 v13
+                                                                                     v14].include?(version.to_s)
+
+        Metadata.const_get("Metadata#{version.upcase}").get_storage_item(pallet_name, item_name, metadata)
+      end
+
+      def get_calls_type(pallet_name, metadata)
+        version = metadata._get(:metadata).keys.first
+        raise ScaleRb::NotImplemented, metadata._get(:metadata).keys.first unless %w[v9 v10 v11 v12 v13
+                                                                                     v14].include?(version.to_s)
+
+        Metadata.const_get("Metadata#{version.upcase}").get_calls_type(pallet_name, metadata)
+      end
+
+      def get_calls_type_id(pallet_name, metadata)
+        version = metadata._get(:metadata).keys.first
+        raise ScaleRb::NotImplemented, metadata._get(:metadata).keys.first unless %w[v9 v10 v11 v12 v13
+                                                                                     v14].include?(version.to_s)
+
+        Metadata.const_get("Metadata#{version.upcase}").get_calls_type_id(pallet_name, metadata)
+      end
+
+      def get_call_type(pallet_name, call_name, metadata)
+        version = metadata._get(:metadata).keys.first
+        raise ScaleRb::NotImplemented, metadata._get(:metadata).keys.first unless %w[v9 v10 v11 v12 v13
+                                                                                     v14].include?(version.to_s)
+
+        Metadata.const_get("Metadata#{version.upcase}").get_call_type(pallet_name, call_name, metadata)
+      end
+
+      # call examples:
+      #   {:pallet_name=>"Deposit", :call_name=>"Claim", :call=>["claim", []]}
+      #   {:pallet_name=>"Balances", :call_name=>"Transfer", :call=>[{:transfer=>{:dest=>[10, 18, 135, 151, 117, 120, 248, 136, 189, 193, 199, 98, 119, 129, 175, 28, 192, 0, 230, 171], :value=>11000000000000000000}}, []]}
+      def encode_call(call, metadata)
+        calls_type_id = get_calls_type_id(call[:pallet_name], metadata)
+        pallet_index = get_module(call[:pallet_name], metadata)._get(:index)
+        [pallet_index] + PortableCodec.encode(calls_type_id, call[:call].first, build_registry(metadata))
+      end
+
+      # callbytes's structure is: pallet_index + call_index + argsbytes
+      #
+      # callbytes examples:
+      #   "0x0901"._to_bytes
+      #   "0x05000a1287977578f888bdc1c7627781af1cc000e6ab1300004c31b8d9a798"._to_bytes
+      def decode_call(callbytes, metadata)
+        pallet_index = callbytes[0]
+        pallet = get_module_by_index(pallet_index, metadata)
+
+        pallet_name = pallet._get(:name)
+
+        # Remove the pallet_index
+        # The callbytes we used below should not contain the pallet index.
+        # This is because the pallet index is not part of the call type.
+        # Its structure is: call_index + call_args
+        callbytes_without_pallet_index = callbytes[1..]
+        calls_type_id = pallet._get(:calls)._get(:type)
+        decoded = PortableCodec.decode(
+          calls_type_id,
+          callbytes_without_pallet_index,
+          build_registry(metadata)
+        )
+
+        {
+          pallet_name: pallet_name,
+          call_name: decoded.first.is_a?(String) ? decoded.first._to_camel : decoded.first.keys.first.to_s._to_camel,
+          call: decoded
+        }
+      end
     end
 
-    def build_registry(metadata)
-      raise ScaleRb::NotImplemented, metadata._get(:metadata).keys.first unless metadata._get(:metadata)._key?(:v14)
-
-      metadata_v14 = metadata._get(:metadata)._get(:v14)
-      MetadataV14.build_registry(metadata_v14)
-    end
-
-    def get_module(pallet_name, metadata)
-      version = metadata._get(:metadata).keys.first
-      raise ScaleRb::NotImplemented, metadata._get(:metadata).keys.first unless %w[v9 v10 v11 v12 v13 v14].include?(version.to_s)
-
-      Metadata.const_get("Metadata#{version.upcase}").get_module(pallet_name, metadata)
-    end
-
-    def get_module_by_index(pallet_index, metadata)
-      version = metadata._get(:metadata).keys.first
-      raise ScaleRb::NotImplemented, metadata._get(:metadata).keys.first unless %w[v9 v10 v11 v12 v13 v14].include?(version.to_s)
-
-      Metadata.const_get("Metadata#{version.upcase}").get_module_by_index(pallet_index, metadata)
-    end
-
-    def get_storage_item(pallet_name, item_name, metadata)
-      version = metadata._get(:metadata).keys.first
-      raise ScaleRb::NotImplemented, metadata._get(:metadata).keys.first unless %w[v9 v10 v11 v12 v13 v14].include?(version.to_s)
-
-      Metadata.const_get("Metadata#{version.upcase}").get_storage_item(pallet_name, item_name, metadata)
-    end
-
-    def get_calls_type(pallet_name, metadata)
-      version = metadata._get(:metadata).keys.first
-      raise ScaleRb::NotImplemented, metadata._get(:metadata).keys.first unless %w[v9 v10 v11 v12 v13 v14].include?(version.to_s)
-
-      Metadata.const_get("Metadata#{version.upcase}").get_calls_type(pallet_name, metadata)
-    end
-
-    def get_calls_type_id(pallet_name, metadata)
-      version = metadata._get(:metadata).keys.first
-      raise ScaleRb::NotImplemented, metadata._get(:metadata).keys.first unless %w[v9 v10 v11 v12 v13 v14].include?(version.to_s)
-
-      Metadata.const_get("Metadata#{version.upcase}").get_calls_type_id(pallet_name, metadata)
-    end
-
-    def get_call_type(pallet_name, call_name, metadata)
-      version = metadata._get(:metadata).keys.first
-      raise ScaleRb::NotImplemented, metadata._get(:metadata).keys.first unless %w[v9 v10 v11 v12 v13 v14].include?(version.to_s)
-
-      Metadata.const_get("Metadata#{version.upcase}").get_call_type(pallet_name, call_name, metadata) 
-    end
-
-    # call examples:
-    #   {:pallet_name=>"Deposit", :call_name=>"Claim", :call=>["claim", []]}
-    #   {:pallet_name=>"Balances", :call_name=>"Transfer", :call=>[{:transfer=>{:dest=>[10, 18, 135, 151, 117, 120, 248, 136, 189, 193, 199, 98, 119, 129, 175, 28, 192, 0, 230, 171], :value=>11000000000000000000}}, []]}
-    def encode_call(call, metadata)
-      calls_type_id = get_calls_type_id(call[:pallet_name], metadata)
-      pallet_index = get_module(call[:pallet_name], metadata)._get(:index)
-      [pallet_index] + PortableCodec.encode(calls_type_id, call[:call].first, build_registry(metadata))
-    end
-
-    # callbytes's structure is: pallet_index + call_index + argsbytes
-    # 
-    # callbytes examples:
-    #   "0x0901".to_bytes
-    #   "0x05000a1287977578f888bdc1c7627781af1cc000e6ab1300004c31b8d9a798".to_bytes
-    def decode_call(callbytes, metadata)
-      pallet_index = callbytes[0]
-      pallet = get_module_by_index(pallet_index, metadata)
-      
-      pallet_name = pallet._get(:name)
-
-      # Remove the pallet_index
-      # The callbytes we used below should not contain the pallet index. 
-      # This is because the pallet index is not part of the call type.
-      # Its structure is: call_index + call_args
-      callbytes_without_pallet_index = callbytes[1..]
-      calls_type_id = pallet._get(:calls)._get(:type)
-      decoded = PortableCodec.decode(
-        calls_type_id, 
-        callbytes_without_pallet_index, 
-        build_registry(metadata)
-      )
-
-      {
-        pallet_name: pallet_name,
-        call_name: decoded.first.is_a?(String) ? decoded.first.to_camel : decoded.first.keys.first.to_s.to_camel,
-        call: decoded
+    TYPES = {
+      'MetadataTop' => {
+        magicNumber: 'U32',
+        metadata: 'Metadata'
+      },
+      'Metadata' => {
+        _enum: {
+          v0: 'MetadataV0',
+          v1: 'MetadataV1',
+          v2: 'MetadataV2',
+          v3: 'MetadataV3',
+          v4: 'MetadataV4',
+          v5: 'MetadataV5',
+          v6: 'MetadataV6',
+          v7: 'MetadataV7',
+          v8: 'MetadataV8',
+          v9: 'MetadataV9',
+          v10: 'MetadataV10',
+          v11: 'MetadataV11',
+          v12: 'MetadataV12',
+          v13: 'MetadataV13',
+          v14: 'MetadataV14'
+        }
       }
-    end
+    }.merge(MetadataV14::TYPES)
+            .merge(MetadataV13::TYPES)
+            .merge(MetadataV12::TYPES)
+            .merge(MetadataV11::TYPES)
+            .merge(MetadataV10::TYPES)
+            .merge(MetadataV9::TYPES)
   end
-
-  TYPES = {
-    'MetadataTop' => {
-      magicNumber: 'U32',
-      metadata: 'Metadata'
-    },
-    'Metadata' => {
-      _enum: {
-        v0: 'MetadataV0',
-        v1: 'MetadataV1',
-        v2: 'MetadataV2',
-        v3: 'MetadataV3',
-        v4: 'MetadataV4',
-        v5: 'MetadataV5',
-        v6: 'MetadataV6',
-        v7: 'MetadataV7',
-        v8: 'MetadataV8',
-        v9: 'MetadataV9',
-        v10: 'MetadataV10',
-        v11: 'MetadataV11',
-        v12: 'MetadataV12',
-        v13: 'MetadataV13',
-        v14: 'MetadataV14'
-      }
-    }
-  }.merge(MetadataV14::TYPES)
-          .merge(MetadataV13::TYPES)
-          .merge(MetadataV12::TYPES)
-          .merge(MetadataV11::TYPES)
-          .merge(MetadataV10::TYPES)
-          .merge(MetadataV9::TYPES)
 end

data/lib/metadata/metadata_v10.rb

@@ -1,80 +1,83 @@
 # frozen_string_literal: true
 
-module Metadata
-  module MetadataV10
-    class << self
-      def get_module(module_name, metadata)
-        metadata._get(:metadata)._get(:v10)._get(:modules).find do |m|
-          m._get(:name) == module_name
+module ScaleRb
+  module Metadata
+    module MetadataV10
+      class << self
+        def get_module(module_name, metadata)
+          metadata._get(:metadata)._get(:v10)._get(:modules).find do |m|
+            m._get(:name) == module_name
+          end
         end
-      end
 
-      def get_storage_item(module_name, item_name, metadata)
-        modula = get_module(module_name, metadata)
-        raise "Module `#{module_name}` not found" if modula.nil?
-        modula._get(:storage)._get(:items).find do |item|
-          item._get(:name) == item_name
+        def get_storage_item(module_name, item_name, metadata)
+          modula = get_module(module_name, metadata)
+          raise "Module `#{module_name}` not found" if modula.nil?
+
+          modula._get(:storage)._get(:items).find do |item|
+            item._get(:name) == item_name
+          end
         end
       end
-    end
 
-    TYPES = {
-      ErrorMetadataV10: 'ErrorMetadataV9',
-      EventMetadataV10: 'EventMetadataV9',
-      FunctionArgumentMetadataV10: 'FunctionArgumentMetadataV9',
-      FunctionMetadataV10: 'FunctionMetadataV9',
-      MetadataV10: {
-        modules: 'Vec<ModuleMetadataV10>'
-      },
-      ModuleConstantMetadataV10: 'ModuleConstantMetadataV9',
-      ModuleMetadataV10: {
-        name: 'Text',
-        storage: 'Option<StorageMetadataV10>',
-        calls: 'Option<Vec<FunctionMetadataV10>>',
-        events: 'Option<Vec<EventMetadataV10>>',
-        constants: 'Vec<ModuleConstantMetadataV10>',
-        errors: 'Vec<ErrorMetadataV10>'
-      },
-      StorageEntryModifierV10: 'StorageEntryModifierV9',
-      StorageEntryMetadataV10: {
-        name: 'Text',
-        modifier: 'StorageEntryModifierV10',
-        type: 'StorageEntryTypeV10',
-        fallback: 'Bytes',
-        docs: 'Vec<Text>'
-      },
-      StorageEntryTypeV10: {
-        _enum: {
-          Plain: 'Type',
-          Map: {
-            hasher: 'StorageHasherV10',
-            key: 'Type',
-            value: 'Type',
-            linked: 'bool'
-          },
-          DoubleMap: {
-            hasher: 'StorageHasherV10',
-            key1: 'Type',
-            key2: 'Type',
-            value: 'Type',
-            key2Hasher: 'StorageHasherV10'
+      TYPES = {
+        ErrorMetadataV10: 'ErrorMetadataV9',
+        EventMetadataV10: 'EventMetadataV9',
+        FunctionArgumentMetadataV10: 'FunctionArgumentMetadataV9',
+        FunctionMetadataV10: 'FunctionMetadataV9',
+        MetadataV10: {
+          modules: 'Vec<ModuleMetadataV10>'
+        },
+        ModuleConstantMetadataV10: 'ModuleConstantMetadataV9',
+        ModuleMetadataV10: {
+          name: 'Text',
+          storage: 'Option<StorageMetadataV10>',
+          calls: 'Option<Vec<FunctionMetadataV10>>',
+          events: 'Option<Vec<EventMetadataV10>>',
+          constants: 'Vec<ModuleConstantMetadataV10>',
+          errors: 'Vec<ErrorMetadataV10>'
+        },
+        StorageEntryModifierV10: 'StorageEntryModifierV9',
+        StorageEntryMetadataV10: {
+          name: 'Text',
+          modifier: 'StorageEntryModifierV10',
+          type: 'StorageEntryTypeV10',
+          fallback: 'Bytes',
+          docs: 'Vec<Text>'
+        },
+        StorageEntryTypeV10: {
+          _enum: {
+            Plain: 'Type',
+            Map: {
+              hasher: 'StorageHasherV10',
+              key: 'Type',
+              value: 'Type',
+              linked: 'bool'
+            },
+            DoubleMap: {
+              hasher: 'StorageHasherV10',
+              key1: 'Type',
+              key2: 'Type',
+              value: 'Type',
+              key2Hasher: 'StorageHasherV10'
+            }
           }
+        },
+        StorageMetadataV10: {
+          prefix: 'Text',
+          items: 'Vec<StorageEntryMetadataV10>'
+        },
+        StorageHasherV10: {
+          _enum: %w[
+            Blake2_128
+            Blake2_256
+            Blake2_128Concat
+            Twox128
+            Twox256
+            Twox64Concat
+          ]
         }
-      },
-      StorageMetadataV10: {
-        prefix: 'Text',
-        items: 'Vec<StorageEntryMetadataV10>'
-      },
-      StorageHasherV10: {
-        _enum: %w[
-          Blake2_128
-          Blake2_256
-          Blake2_128Concat
-          Twox128
-          Twox256
-          Twox64Concat
-        ]
-      }
-    }.freeze
+      }.freeze
+    end
   end
 end

data/lib/metadata/metadata_v11.rb

@@ -1,86 +1,89 @@
 # frozen_string_literal: true
 
-module Metadata
-  module MetadataV11
-    class << self
-      def get_module(module_name, metadata)
-        metadata._get(:metadata)._get(:v11)._get(:modules).find do |m|
-          m._get(:name) == module_name
+module ScaleRb
+  module Metadata
+    module MetadataV11
+      class << self
+        def get_module(module_name, metadata)
+          metadata._get(:metadata)._get(:v11)._get(:modules).find do |m|
+            m._get(:name) == module_name
+          end
         end
-      end
 
-      def get_storage_item(module_name, item_name, metadata)
-        modula = get_module(module_name, metadata)
-        raise "Module `#{module_name}` not found" if modula.nil?
-        modula._get(:storage)._get(:items).find do |item|
-          item._get(:name) == item_name
+        def get_storage_item(module_name, item_name, metadata)
+          modula = get_module(module_name, metadata)
+          raise "Module `#{module_name}` not found" if modula.nil?
+
+          modula._get(:storage)._get(:items).find do |item|
+            item._get(:name) == item_name
+          end
         end
       end
-    end
 
-    TYPES = {
-      ErrorMetadataV11: 'ErrorMetadataV10',
-      EventMetadataV11: 'EventMetadataV10',
-      ExtrinsicMetadataV11: {
-        version: 'u8',
-        signedExtensions: 'Vec<Text>'
-      },
-      FunctionArgumentMetadataV11: 'FunctionArgumentMetadataV10',
-      FunctionMetadataV11: 'FunctionMetadataV10',
-      MetadataV11: {
-        modules: 'Vec<ModuleMetadataV11>',
-        extrinsic: 'ExtrinsicMetadataV11'
-      },
-      ModuleConstantMetadataV11: 'ModuleConstantMetadataV10',
-      ModuleMetadataV11: {
-        name: 'Text',
-        storage: 'Option<StorageMetadataV11>',
-        calls: 'Option<Vec<FunctionMetadataV11>>',
-        events: 'Option<Vec<EventMetadataV11>>',
-        constants: 'Vec<ModuleConstantMetadataV11>',
-        errors: 'Vec<ErrorMetadataV11>'
-      },
-      StorageEntryModifierV11: 'StorageEntryModifierV10',
-      StorageEntryMetadataV11: {
-        name: 'Text',
-        modifier: 'StorageEntryModifierV11',
-        type: 'StorageEntryTypeV11',
-        fallback: 'Bytes',
-        docs: 'Vec<Text>'
-      },
-      StorageEntryTypeV11: {
-        _enum: {
-          Plain: 'Type',
-          Map: {
-            hasher: 'StorageHasherV11',
-            key: 'Type',
-            value: 'Type',
-            linked: 'bool'
-          },
-          DoubleMap: {
-            hasher: 'StorageHasherV11',
-            key1: 'Type',
-            key2: 'Type',
-            value: 'Type',
-            key2Hasher: 'StorageHasherV11'
+      TYPES = {
+        ErrorMetadataV11: 'ErrorMetadataV10',
+        EventMetadataV11: 'EventMetadataV10',
+        ExtrinsicMetadataV11: {
+          version: 'u8',
+          signedExtensions: 'Vec<Text>'
+        },
+        FunctionArgumentMetadataV11: 'FunctionArgumentMetadataV10',
+        FunctionMetadataV11: 'FunctionMetadataV10',
+        MetadataV11: {
+          modules: 'Vec<ModuleMetadataV11>',
+          extrinsic: 'ExtrinsicMetadataV11'
+        },
+        ModuleConstantMetadataV11: 'ModuleConstantMetadataV10',
+        ModuleMetadataV11: {
+          name: 'Text',
+          storage: 'Option<StorageMetadataV11>',
+          calls: 'Option<Vec<FunctionMetadataV11>>',
+          events: 'Option<Vec<EventMetadataV11>>',
+          constants: 'Vec<ModuleConstantMetadataV11>',
+          errors: 'Vec<ErrorMetadataV11>'
+        },
+        StorageEntryModifierV11: 'StorageEntryModifierV10',
+        StorageEntryMetadataV11: {
+          name: 'Text',
+          modifier: 'StorageEntryModifierV11',
+          type: 'StorageEntryTypeV11',
+          fallback: 'Bytes',
+          docs: 'Vec<Text>'
+        },
+        StorageEntryTypeV11: {
+          _enum: {
+            Plain: 'Type',
+            Map: {
+              hasher: 'StorageHasherV11',
+              key: 'Type',
+              value: 'Type',
+              linked: 'bool'
+            },
+            DoubleMap: {
+              hasher: 'StorageHasherV11',
+              key1: 'Type',
+              key2: 'Type',
+              value: 'Type',
+              key2Hasher: 'StorageHasherV11'
+            }
           }
+        },
+        StorageMetadataV11: {
+          prefix: 'Text',
+          items: 'Vec<StorageEntryMetadataV11>'
+        },
+        StorageHasherV11: {
+          _enum: %w[
+            Blake2_128
+            Blake2_256
+            Blake2_128Concat
+            Twox128
+            Twox256
+            Twox64Concat
+            Identity
+          ]
         }
-      },
-      StorageMetadataV11: {
-        prefix: 'Text',
-        items: 'Vec<StorageEntryMetadataV11>'
-      },
-      StorageHasherV11: {
-        _enum: %w[
-          Blake2_128
-          Blake2_256
-          Blake2_128Concat
-          Twox128
-          Twox256
-          Twox64Concat
-          Identity
-        ]
-      }
-    }.freeze
+      }.freeze
+    end
   end
 end

data/lib/metadata/metadata_v12.rb

@@ -1,48 +1,51 @@
 # frozen_string_literal: true
 
-module Metadata
-  module MetadataV12
-    class << self
-      def get_module(module_name, metadata)
-        metadata._get(:metadata)._get(:v12)._get(:modules).find do |m|
-          m._get(:name) == module_name
+module ScaleRb
+  module Metadata
+    module MetadataV12
+      class << self
+        def get_module(module_name, metadata)
+          metadata._get(:metadata)._get(:v12)._get(:modules).find do |m|
+            m._get(:name) == module_name
+          end
         end
-      end
 
-      def get_storage_item(module_name, item_name, metadata)
-        modula = get_module(module_name, metadata)
-        raise "Module `#{module_name}` not found" if modula.nil?
-        modula._get(:storage)._get(:items).find do |item|
-          item._get(:name) == item_name
+        def get_storage_item(module_name, item_name, metadata)
+          modula = get_module(module_name, metadata)
+          raise "Module `#{module_name}` not found" if modula.nil?
+
+          modula._get(:storage)._get(:items).find do |item|
+            item._get(:name) == item_name
+          end
         end
       end
-    end
 
-    TYPES = {
-      ErrorMetadataV12: 'ErrorMetadataV11',
-      EventMetadataV12: 'EventMetadataV11',
-      ExtrinsicMetadataV12: 'ExtrinsicMetadataV11',
-      FunctionArgumentMetadataV12: 'FunctionArgumentMetadataV11',
-      FunctionMetadataV12: 'FunctionMetadataV11',
-      MetadataV12: {
-        modules: 'Vec<ModuleMetadataV12>',
-        extrinsic: 'ExtrinsicMetadataV12'
-      },
-      ModuleConstantMetadataV12: 'ModuleConstantMetadataV11',
-      ModuleMetadataV12: {
-        name: 'Text',
-        storage: 'Option<StorageMetadataV12>',
-        calls: 'Option<Vec<FunctionMetadataV12>>',
-        events: 'Option<Vec<EventMetadataV12>>',
-        constants: 'Vec<ModuleConstantMetadataV12>',
-        errors: 'Vec<ErrorMetadataV12>',
-        index: 'u8'
-      },
-      StorageEntryModifierV12: 'StorageEntryModifierV11',
-      StorageEntryMetadataV12: 'StorageEntryMetadataV11',
-      StorageEntryTypeV12: 'StorageEntryTypeV11',
-      StorageMetadataV12: 'StorageMetadataV11',
-      StorageHasherV12: 'StorageHasherV11'
-    }.freeze
+      TYPES = {
+        ErrorMetadataV12: 'ErrorMetadataV11',
+        EventMetadataV12: 'EventMetadataV11',
+        ExtrinsicMetadataV12: 'ExtrinsicMetadataV11',
+        FunctionArgumentMetadataV12: 'FunctionArgumentMetadataV11',
+        FunctionMetadataV12: 'FunctionMetadataV11',
+        MetadataV12: {
+          modules: 'Vec<ModuleMetadataV12>',
+          extrinsic: 'ExtrinsicMetadataV12'
+        },
+        ModuleConstantMetadataV12: 'ModuleConstantMetadataV11',
+        ModuleMetadataV12: {
+          name: 'Text',
+          storage: 'Option<StorageMetadataV12>',
+          calls: 'Option<Vec<FunctionMetadataV12>>',
+          events: 'Option<Vec<EventMetadataV12>>',
+          constants: 'Vec<ModuleConstantMetadataV12>',
+          errors: 'Vec<ErrorMetadataV12>',
+          index: 'u8'
+        },
+        StorageEntryModifierV12: 'StorageEntryModifierV11',
+        StorageEntryMetadataV12: 'StorageEntryMetadataV11',
+        StorageEntryTypeV12: 'StorageEntryTypeV11',
+        StorageMetadataV12: 'StorageMetadataV11',
+        StorageHasherV12: 'StorageHasherV11'
+      }.freeze
+    end
   end
 end