scale_rb 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 381954b869c210f582d6d119be4efe2b0f41ab4aa783793ee1a8b5b3ae3f37fc
-  data.tar.gz: 474b9ae37ee03d0112f63892a10b1a7965f73987ec03f28838dc3e050d5f29cd
+  metadata.gz: 04c1447c216cac863ad108d269030a8f3d180d1666c2bba347efad2fa7939335
+  data.tar.gz: bc3b74a6e4ed311491e0369d2b73ae3ac5ab98d430df311257385503db6b70d7
 SHA512:
-  metadata.gz: 50ee90afbb3f5a9b27676912608dfa8de48bac33e8e19f1e21ee5db8f2aa1cf4c21f95cfca27e3bc6220481312bb57254004a8f219f6b6d1be94b295c47ffd68
-  data.tar.gz: 7cdedc298adc696bb5a3df76c63710c13863a86d4c066f7a9fe2767bd349cb7f71ed4f26490faa3a77abb8022144102396b407f6ce02e9d8d10c8029f754a451
+  metadata.gz: fac868163255299dcba6094edbe98daed394ede7130262bebf449befc21cdb921e52f1b0a455ae61d46547fa30d28af6927705ed99ae8b7035025d095527f9d4
+  data.tar.gz: 4f9394ab7bb01d73d96e160c4b0c76dae593dd7331e9a276a090e9a7d03060085763c378f5ab0bba5daf64d5bc62b0f4ae0e054d406905c549f8b667d7db7e43

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    scale_rb (0.1.3)
+    scale_rb (0.1.4)
       blake2b_rs (~> 0.1.2)
       xxhash
 

data/lib/codec.rb

@@ -16,6 +16,22 @@ end
 # TODO: set, bitvec
 module ScaleRb
   class << self
+    def type_def?(type)
+      type.instance_of?(String) && (
+        bytes?(type) ||
+        boolean?(type) ||
+        string?(type) ||
+        compact?(type) ||
+        int?(type) ||
+        uint?(type) ||
+        option?(type) ||
+        array?(type) ||
+        vec?(type) ||
+        tuple?(type)
+      ) ||
+        type.instance_of?(Hash)
+    end
+
     def bytes?(type)
       type.downcase == 'bytes'
     end
@@ -25,7 +41,7 @@ module ScaleRb
     end
 
     def string?(type)
-      type.downcase == 'str' || type.downcase == 'string' || type.downcase == 'text'
+      type.downcase == 'str' || type.downcase == 'string' || type.downcase == 'text' || type.downcase == 'type'
     end
 
     def compact?(type)
@@ -97,14 +113,16 @@ end
 module ScaleRb
   class << self
     def _get_final_type_from_registry(registry, type)
-      mapped_type = registry[type]
-      if mapped_type.nil?
-        nil
-      elsif registry[mapped_type].nil?
-        mapped_type
-      else
-        _get_final_type_from_registry(registry, mapped_type)
-      end
+      raise "Wrong lookup type #{type.class}" if !type.instance_of?(String) && !type.instance_of?(Hash)
+
+      return if type.instance_of?(Hash)
+
+      mapped = registry._get(type) # mapped: String(name, type_def) | Hash(type_def: struct, enum) | nil
+
+      return if mapped.nil?
+      return mapped if type_def?(mapped)
+
+      _get_final_type_from_registry(registry, mapped)
     end
 
     def _decode_types(types, bytes, registry)

data/lib/metadata/metadata.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+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_storage_item(pallet_name, item_name, metadata)
+      raise ScaleRb::NotImplemented, metadata._get(:metadata).keys.first unless metadata._get(:metadata)._key?(:v14)
+
+      metadata_v14 = metadata._get(:metadata)._get(:v14)
+      MetadataV14.get_storage_item(pallet_name, item_name, metadata_v14)
+    end
+  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

@@ -0,0 +1,79 @@
+# 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
+        end
+      end
+
+      def get_storage_item(module_name, item_name, metadata)
+        modula = get_module(module_name, metadata)
+        modula._get(:storage)._get(:items).find do |item|
+          item._get(:name) == item_name
+        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'
+          }
+        }
+      },
+      StorageMetadataV10: {
+        prefix: 'Text',
+        items: 'Vec<StorageEntryMetadataV10>'
+      },
+      StorageHasherV10: {
+        _enum: %w[
+          Blake2_128
+          Blake2_256
+          Blake2_128Concat
+          Twox128
+          Twox256
+          Twox64Concat
+        ]
+      }
+    }.freeze
+  end
+end

data/lib/metadata/metadata_v11.rb

@@ -0,0 +1,85 @@
+# 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
+        end
+      end
+
+      def get_storage_item(module_name, item_name, metadata)
+        modula = get_module(module_name, metadata)
+        modula._get(:storage)._get(:items).find do |item|
+          item._get(:name) == item_name
+        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'
+          }
+        }
+      },
+      StorageMetadataV11: {
+        prefix: 'Text',
+        items: 'Vec<StorageEntryMetadataV11>'
+      },
+      StorageHasherV11: {
+        _enum: %w[
+          Blake2_128
+          Blake2_256
+          Blake2_128Concat
+          Twox128
+          Twox256
+          Twox64Concat
+          Identity
+        ]
+      }
+    }.freeze
+  end
+end

data/lib/metadata/metadata_v12.rb

@@ -0,0 +1,47 @@
+# 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
+        end
+      end
+
+      def get_storage_item(module_name, item_name, metadata)
+        modula = get_module(module_name, metadata)
+        modula._get(:storage)._get(:items).find do |item|
+          item._get(:name) == item_name
+        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
+  end
+end

data/lib/metadata/metadata_v13.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Metadata
+  module MetadataV13
+    class << self
+      def get_module(module_name, metadata)
+        metadata._get(:metadata)._get(:v13)._get(:modules).find do |m|
+          m._get(:name) == module_name
+        end
+      end
+
+      def get_storage_item(module_name, item_name, metadata)
+        modula = get_module(module_name, metadata)
+        modula._get(:storage)._get(:items).find do |item|
+          item._get(:name) == item_name
+        end
+      end
+    end
+
+    TYPES = {
+      MetadataV13: {
+        modules: 'Vec<ModuleMetadataV13>',
+        extrinsic: 'ExtrinsicMetadataV13'
+      },
+
+      ModuleMetadataV13: {
+        name: 'Text',
+        storage: 'Option<StorageMetadataV13>',
+        calls: 'Option<Vec<FunctionMetadataV13>>',
+        events: 'Option<Vec<EventMetadataV13>>',
+        constants: 'Vec<ModuleConstantMetadataV13>',
+        errors: 'Vec<ErrorMetadataV13>',
+        index: 'u8'
+      },
+      StorageMetadataV13: {
+        prefix: 'Text',
+        items: 'Vec<StorageEntryMetadataV13>'
+      },
+      StorageEntryMetadataV13: {
+        name: 'Text',
+        modifier: 'StorageEntryModifierV13',
+        type: 'StorageEntryTypeV13',
+        fallback: 'Bytes',
+        docs: 'Vec<Text>'
+      },
+      StorageEntryModifierV13: 'StorageEntryModifierV12',
+      StorageEntryTypeV13: {
+        _enum: {
+          plain: 'Type',
+          map: {
+            hasher: 'StorageHasherV13',
+            key: 'Type',
+            value: 'Type',
+            linked: 'bool'
+          },
+          doubleMap: {
+            hasher: 'StorageHasherV13',
+            key1: 'Type',
+            key2: 'Type',
+            value: 'Type',
+            key2Hasher: 'StorageHasherV13'
+          },
+          nMap: {
+            keyVec: 'Vec<Type>',
+            hashers: 'Vec<StorageHasherV13>',
+            value: 'Type'
+          }
+        }
+      },
+      StorageHasherV13: 'StorageHasherV12',
+      FunctionMetadataV13: 'FunctionMetadataV12',
+      EventMetadataV13: 'EventMetadataV12',
+      ModuleConstantMetadataV13: 'ModuleConstantMetadataV12',
+      ErrorMetadataV13: 'ErrorMetadataV12',
+      ExtrinsicMetadataV13: 'ExtrinsicMetadataV12'
+    }.freeze
+  end
+end

data/lib/metadata/metadata_v14.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module Metadata
+  module MetadataV14
+    class << self
+      def build_registry(metadata)
+        types = metadata._get(:lookup)._get(:types)
+        types.map { |type| [type._get(:id), type._get(:type)] }.to_h
+      end
+
+      def get_module(pallet_name, metadata)
+        metadata._get(:metadata)._get(:v14)._get(:pallets).find do |p|
+          p._get(:name) == pallet_name
+        end
+      end
+
+      def get_storage_item(pallet_name, item_name, metadata)
+        pallet = get_module(pallet_name, metadata)
+        pallet._get(:storage)._get(:items).find do |item|
+          item._get(:name) == item_name
+        end
+      end
+    end
+
+    TYPES = {
+      MetadataV14: {
+        lookup: 'PortableRegistry',
+        pallets: 'Vec<PalletMetadataV14>',
+        extrinsic: 'ExtrinsicMetadataV14',
+        type: 'SiLookupTypeId'
+      },
+
+      # PortableRegistry begin
+      PortableRegistry: {
+        types: 'Vec<PortableTypeV14>'
+      },
+      PortableTypeV14: {
+        id: 'Si1LookupTypeId',
+        type: 'Si1Type'
+      },
+      Si1LookupTypeId: 'Compact',
+      Si1Type: {
+        path: 'Si1Path',
+        params: 'Vec<Si1TypeParameter>',
+        def: 'Si1TypeDef',
+        docs: 'Vec<Text>'
+      },
+      Si1Path: 'Vec<Text>',
+      Si1TypeParameter: {
+        name: 'Text',
+        type: 'Option<Si1LookupTypeId>'
+      },
+      Si1TypeDef: {
+        _enum: {
+          composite: 'Si1TypeDefComposite',
+          variant: 'Si1TypeDefVariant',
+          sequence: 'Si1TypeDefSequence',
+          array: 'Si1TypeDefArray',
+          tuple: 'Si1TypeDefTuple',
+          primitive: 'Si1TypeDefPrimitive',
+          compact: 'Si1TypeDefCompact',
+          bitSequence: 'Si1TypeDefBitSequence',
+          historicMetaCompat: 'Text' # TODO: sanitize?
+        }
+      },
+      Si1TypeDefComposite: {
+        fields: 'Vec<Si1Field>'
+      },
+      Si1Field: {
+        name: 'Option<Text>',
+        type: 'Si1LookupTypeId',
+        typeName: 'Option<Text>',
+        docs: 'Vec<Text>'
+      },
+      Si1TypeDefVariant: {
+        variants: 'Vec<Si1Variant>'
+      },
+      Si1Variant: {
+        name: 'Text',
+        fields: 'Vec<Si1Field>',
+        index: 'u8',
+        docs: 'Vec<Text>'
+      },
+      Si1TypeDefSequence: {
+        type: 'Si1LookupTypeId'
+      },
+      Si1TypeDefArray: {
+        len: 'u32',
+        type: 'Si1LookupTypeId'
+      },
+      Si1TypeDefTuple: 'Vec<Si1LookupTypeId>',
+      Si1TypeDefPrimitive: {
+        _enum: %w[
+          Bool Char Str U8 U16 U32 U64 U128 U256 I8 I16 I32 I64 I128 I256
+        ]
+      },
+      Si1TypeDefCompact: {
+        type: 'Si1LookupTypeId'
+      },
+      Si1TypeDefBitSequence: {
+        bitStoreType: 'Si1LookupTypeId',
+        bitOrderType: 'Si1LookupTypeId'
+      },
+      # PortableRegistry end
+
+      # PalletMetadataV14 begin
+      PalletMetadataV14: {
+        name: 'Text',
+        storage: 'Option<PalletStorageMetadataV14>',
+        calls: 'Option<PalletCallMetadataV14>',
+        events: 'Option<PalletEventMetadataV14>',
+        constants: 'Vec<PalletConstantMetadataV14>',
+        errors: 'Option<PalletErrorMetadataV14>',
+        index: 'U8'
+      },
+      PalletStorageMetadataV14: {
+        prefix: 'Text',
+        items: 'Vec<StorageEntryMetadataV14>'
+      },
+      StorageEntryMetadataV14: {
+        name: 'Text',
+        modifier: 'StorageEntryModifierV14',
+        type: 'StorageEntryTypeV14',
+        fallback: 'Bytes',
+        docs: 'Vec<Text>'
+      },
+      StorageEntryModifierV14: {
+        _enum: %w[Optional Default Required]
+      },
+      StorageEntryTypeV14: {
+        _enum: {
+          plain: 'SiLookupTypeId',
+          map: {
+            hashers: 'Vec<StorageHasherV14>',
+            key: 'SiLookupTypeId',
+            value: 'SiLookupTypeId'
+          }
+        }
+      },
+      StorageHasherV14: {
+        _enum: %w[Blake2128 Blake2256 Blake2128Concat Twox128 Twox256 Twox64Concat Identity]
+      },
+      PalletCallMetadataV14: {
+        type: 'Si1LookupTypeId'
+      },
+      PalletEventMetadataV14: {
+        type: 'SiLookupTypeId'
+      },
+      PalletConstantMetadataV14: {
+        name: 'Text',
+        type: 'SiLookupTypeId',
+        value: 'Bytes',
+        docs: 'Vec<Text>'
+      },
+      PalletErrorMetadataV14: {
+        type: 'SiLookupTypeId'
+      },
+      # PalletMetadataV14 end
+
+      # ExtrinsicMetadataV14 begin
+      ExtrinsicMetadataV14: {
+        type: 'SiLookupTypeId',
+        version: 'u8',
+        signedExtensions: 'Vec<SignedExtensionMetadataV14>'
+      },
+      SignedExtensionMetadataV14: {
+        identifier: 'Text',
+        type: 'SiLookupTypeId',
+        additionalSigned: 'SiLookupTypeId'
+      },
+      # ExtrinsicMetadataV14 end
+
+      SiLookupTypeId: 'Compact'
+    }.freeze
+  end
+end

data/lib/metadata/metadata_v9.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Metadata
+  module MetadataV9
+    class << self
+      def get_module(module_name, metadata)
+        metadata._get(:metadata)._get(:v9)._get(:modules).find do |m|
+          m._get(:name) == module_name
+        end
+      end
+
+      def get_storage_item(module_name, item_name, metadata)
+        modula = get_module(module_name, metadata)
+        modula._get(:storage)._get(:items).find do |item|
+          item._get(:name) == item_name
+        end
+      end
+    end
+
+    TYPES = {
+      ErrorMetadataV9: {
+        name: 'Text',
+        docs: 'Vec<Text>'
+      },
+      EventMetadataV9: {
+        name: 'Text',
+        args: 'Vec<Type>',
+        docs: 'Vec<Text>'
+      },
+      FunctionArgumentMetadataV9: {
+        name: 'Text',
+        type: 'Type'
+      },
+      FunctionMetadataV9: {
+        name: 'Text',
+        args: 'Vec<FunctionArgumentMetadataV9>',
+        docs: 'Vec<Text>'
+      },
+      MetadataV9: {
+        modules: 'Vec<ModuleMetadataV9>'
+      },
+      ModuleConstantMetadataV9: {
+        name: 'Text',
+        type: 'Type',
+        value: 'Bytes',
+        docs: 'Vec<Text>'
+      },
+      ModuleMetadataV9: {
+        name: 'Text',
+        storage: 'Option<StorageMetadataV9>',
+        calls: 'Option<Vec<FunctionMetadataV9>>',
+        events: 'Option<Vec<EventMetadataV9>>',
+        constants: 'Vec<ModuleConstantMetadataV9>',
+        errors: 'Vec<ErrorMetadataV9>'
+      },
+      StorageEntryMetadataV9: {
+        name: 'Text',
+        modifier: 'StorageEntryModifierV9',
+        type: 'StorageEntryTypeV9',
+        fallback: 'Bytes',
+        docs: 'Vec<Text>'
+      },
+      StorageEntryModifierV9: {
+        _enum: %w[Optional Default Required]
+      },
+      StorageEntryTypeV9: {
+        _enum: {
+          Plain: 'Type',
+          Map: {
+            hasher: 'StorageHasherV9',
+            key: 'Type',
+            value: 'Type',
+            linked: 'bool'
+          },
+          DoubleMap: {
+            hasher: 'StorageHasherV9',
+            key1: 'Type',
+            key2: 'Type',
+            value: 'Type',
+            key2Hasher: 'StorageHasherV9'
+          }
+        }
+      },
+      StorageHasherV9: {
+        _enum: %w[
+          Blake2_128
+          Blake2_256
+          Twox128
+          Twox256
+          Twox64Concat
+        ]
+      },
+      StorageMetadataV9: {
+        prefix: 'Text',
+        items: 'Vec<StorageEntryMetadataV9>'
+      }
+    }.freeze
+  end
+end

data/lib/monkey_patching.rb

@@ -106,7 +106,7 @@ class Hash
   def _get(key)
     if key.instance_of?(String)
       self[key] || self[key.to_sym]
-    else
+    elsif key.instance_of?(Symbol)
       self[key] || self[key.to_s]
     end
   end

data/lib/scale_rb/version.rb

@@ -1,3 +1,3 @@
 module ScaleRb
-  VERSION = '0.1.3'
+  VERSION = '0.1.4'
 end

data/lib/scale_rb.rb

@@ -9,8 +9,13 @@ require 'codec'
 require 'portable_codec'
 
 # metadata types, decoding and helpers
-require 'metadata'
-require 'metadata_v14'
+require 'metadata/metadata_v9'
+require 'metadata/metadata_v10'
+require 'metadata/metadata_v11'
+require 'metadata/metadata_v12'
+require 'metadata/metadata_v13'
+require 'metadata/metadata_v14'
+require 'metadata/metadata'
 
 require 'hasher'
 require 'storage_helper'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: scale_rb
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Aki Wu
@@ -61,8 +61,13 @@ files:
 - exe/metadata
 - lib/codec.rb
 - lib/hasher.rb
-- lib/metadata.rb
-- lib/metadata_v14.rb
+- lib/metadata/metadata.rb
+- lib/metadata/metadata_v10.rb
+- lib/metadata/metadata_v11.rb
+- lib/metadata/metadata_v12.rb
+- lib/metadata/metadata_v13.rb
+- lib/metadata/metadata_v14.rb
+- lib/metadata/metadata_v9.rb
 - lib/monkey_patching.rb
 - lib/portable_codec.rb
 - lib/registry.rb

data/lib/metadata.rb

@@ -1,199 +0,0 @@
-# frozen_string_literal: true
-
-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_storage_item(pallet_name, item_name, metadata)
-      raise ScaleRb::NotImplemented, metadata._get(:metadata).keys.first unless metadata._get(:metadata)._key?(:v14)
-
-      metadata_v14 = metadata._get(:metadata)._get(:v14)
-      MetadataV14.get_storage_item(pallet_name, item_name, metadata_v14)
-    end
-  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'
-      }
-    },
-
-    'MetadataV14' => {
-      lookup: 'PortableRegistry',
-      pallets: 'Vec<PalletMetadataV14>',
-      extrinsic: 'ExtrinsicMetadataV14',
-      type: 'SiLookupTypeId'
-    },
-
-    # PortableRegistry begin
-    'PortableRegistry' => {
-      types: 'Vec<PortableTypeV14>'
-    },
-    'PortableTypeV14' => {
-      id: 'Si1LookupTypeId',
-      type: 'Si1Type'
-    },
-    'Si1LookupTypeId' => 'Compact',
-    'Si1Type' => {
-      path: 'Si1Path',
-      params: 'Vec<Si1TypeParameter>',
-      def: 'Si1TypeDef',
-      docs: 'Vec<Text>'
-    },
-    'Si1Path' => 'Vec<Text>',
-    'Si1TypeParameter' => {
-      name: 'Text',
-      type: 'Option<Si1LookupTypeId>'
-    },
-    'Si1TypeDef' => {
-      _enum: {
-        composite: 'Si1TypeDefComposite',
-        variant: 'Si1TypeDefVariant',
-        sequence: 'Si1TypeDefSequence',
-        array: 'Si1TypeDefArray',
-        tuple: 'Si1TypeDefTuple',
-        primitive: 'Si1TypeDefPrimitive',
-        compact: 'Si1TypeDefCompact',
-        bitSequence: 'Si1TypeDefBitSequence',
-        historicMetaCompat: 'Text' # TODO: sanitize?
-      }
-    },
-    'Si1TypeDefComposite' => {
-      fields: 'Vec<Si1Field>'
-    },
-    'Si1Field' => {
-      name: 'Option<Text>',
-      type: 'Si1LookupTypeId',
-      typeName: 'Option<Text>',
-      docs: 'Vec<Text>'
-    },
-    'Si1TypeDefVariant' => {
-      variants: 'Vec<Si1Variant>'
-    },
-    'Si1Variant' => {
-      name: 'Text',
-      fields: 'Vec<Si1Field>',
-      index: 'u8',
-      docs: 'Vec<Text>'
-    },
-    'Si1TypeDefSequence' => {
-      type: 'Si1LookupTypeId'
-    },
-    'Si1TypeDefArray' => {
-      len: 'u32',
-      type: 'Si1LookupTypeId'
-    },
-    'Si1TypeDefTuple' => 'Vec<Si1LookupTypeId>',
-    'Si1TypeDefPrimitive' => {
-      _enum: %w[
-        Bool Char Str U8 U16 U32 U64 U128 U256 I8 I16 I32 I64 I128 I256
-      ]
-    },
-    'Si1TypeDefCompact' => {
-      type: 'Si1LookupTypeId'
-    },
-    'Si1TypeDefBitSequence' => {
-      bitStoreType: 'Si1LookupTypeId',
-      bitOrderType: 'Si1LookupTypeId'
-    },
-    # PortableRegistry end
-
-    # PalletMetadataV14 begin
-    'PalletMetadataV14' => {
-      name: 'Text',
-      storage: 'Option<PalletStorageMetadataV14>',
-      calls: 'Option<PalletCallMetadataV14>',
-      events: 'Option<PalletEventMetadataV14>',
-      constants: 'Vec<PalletConstantMetadataV14>',
-      errors: 'Option<PalletErrorMetadataV14>',
-      index: 'U8'
-    },
-    'PalletStorageMetadataV14' => {
-      prefix: 'Text',
-      items: 'Vec<StorageEntryMetadataV14>'
-    },
-    'StorageEntryMetadataV14' => {
-      name: 'Text',
-      modifier: 'StorageEntryModifierV14',
-      type: 'StorageEntryTypeV14',
-      fallback: 'Bytes',
-      docs: 'Vec<Text>'
-    },
-    'StorageEntryModifierV14' => {
-      _enum: %w[Optional Default Required]
-    },
-    'StorageEntryTypeV14' => {
-      _enum: {
-        plain: 'SiLookupTypeId',
-        map: {
-          hashers: 'Vec<StorageHasherV14>',
-          key: 'SiLookupTypeId',
-          value: 'SiLookupTypeId'
-        }
-      }
-    },
-    'StorageHasherV14' => {
-      _enum: %w[Blake2128 Blake2256 Blake2128Concat Twox128 Twox256 Twox64Concat Identity]
-    },
-    'PalletCallMetadataV14' => {
-      type: 'Si1LookupTypeId'
-    },
-    'PalletEventMetadataV14' => {
-      type: 'SiLookupTypeId'
-    },
-    'PalletConstantMetadataV14' => {
-      name: 'Text',
-      type: 'SiLookupTypeId',
-      value: 'Bytes',
-      docs: 'Vec<Text>'
-    },
-    'PalletErrorMetadataV14' => {
-      type: 'SiLookupTypeId'
-    },
-    # PalletMetadataV14 end
-
-    # ExtrinsicMetadataV14 begin
-    'ExtrinsicMetadataV14' => {
-      type: 'SiLookupTypeId',
-      version: 'u8',
-      signedExtensions: 'Vec<SignedExtensionMetadataV14>'
-    },
-    'SignedExtensionMetadataV14' => {
-      identifier: 'Text',
-      type: 'SiLookupTypeId',
-      additionalSigned: 'SiLookupTypeId'
-    },
-    # ExtrinsicMetadataV14 end
-
-    'SiLookupTypeId' => 'Compact'
-  }.freeze
-end

data/lib/metadata_v14.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module MetadataV14
-  class << self
-    def build_registry(metadata)
-      types = metadata._get(:lookup)._get(:types)
-      types.map { |type| [type._get(:id), type._get(:type)] }.to_h
-    end
-
-    def get_storage_item(pallet_name, item_name, metadata)
-      pallet =
-        metadata._get(:pallets).find do |p|
-          p._get(:name) == pallet_name
-        end
-
-      pallet._get(:storage)._get(:items).find do |item|
-        item._get(:name) == item_name
-      end
-    end
-  end
-end