scale_rb 0.4.1 → 0.5.0

data/lib/scale_rb/codec_utils.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module ScaleRb
+  module CodecUtils
+    module InternalDecodeUtils
+      extend TypeEnforcer
+      include Types
+
+      __ :decode_uint,
+         { type: String.constrained(format: /\A[Uu]\d+\z/), bytes: U8Array },
+         DecodeResult[UnsignedInteger]
+      def decode_uint(type, bytes)
+        bit_length = type[1..].to_i
+        byte_length = bit_length / 8
+        raise Codec::NotEnoughBytesError, "type: #{type}" if bytes.length < byte_length
+
+        value = Utils.u8a_to_uint(bytes[0...byte_length].reverse)
+        # debug 'value', value
+        [
+          value,
+          bytes[byte_length..]
+        ]
+      end
+
+      __ :decode_int, { type: String.constrained(format: /\A[Ii]\d+\z/), bytes: U8Array }, DecodeResult[Integer]
+      def decode_int(type, bytes)
+        bit_length = type[1..].to_i
+        byte_length = bit_length / 8
+        raise Codec::NotEnoughBytesError, "type: #{type}" if bytes.length < byte_length
+
+        value = Utils.u8a_to_int(bytes[0...byte_length].reverse, bit_length)
+        # debug 'value', value
+        [
+          value,
+          bytes[byte_length..]
+        ]
+      end
+
+      __ :decode_str, { bytes: U8Array }, DecodeResult[String]
+      def decode_str(bytes)
+        length, remaining_bytes = _do_decode_compact(bytes)
+        raise Codec::NotEnoughBytesError, 'type: String' if remaining_bytes.length < length
+
+        [Utils.u8a_to_utf8(remaining_bytes[0...length]), remaining_bytes[length..]]
+      end
+
+      __ :decode_boolean, { bytes: U8Array }, DecodeResult[Bool]
+      def decode_boolean(bytes)
+        value = case bytes[0]
+                when 0x00 then false
+                when 0x01 then true
+                else raise Codec::InvalidBytesError, 'type: Boolean'
+                end
+        [value, bytes[1..]]
+      end
+
+      # TODO: inner type decoding
+      __ :decode_compact, { bytes: U8Array }, DecodeResult[UnsignedInteger]
+      def decode_compact(bytes)
+        _do_decode_compact(bytes)
+      end
+
+      private
+
+      def _do_decode_compact(bytes)
+        case bytes[0] & 3
+        when 0 then [bytes[0] >> 2, bytes[1..]]
+        when 1 then [Utils.u8a_to_uint(bytes[0..1].reverse) >> 2, bytes[2..]]
+        when 2 then [Utils.u8a_to_uint(bytes[0..3].reverse) >> 2, bytes[4..]]
+        when 3
+          length = 4 + (bytes[0] >> 2)
+          [Utils.u8a_to_uint(bytes[1..length].reverse), bytes[length + 1..]]
+        else
+          raise Codec::Unreachable, 'type: Compact'
+        end
+      end
+    end
+
+    module InternalEncodeUtils
+      extend TypeEnforcer
+      include Types
+
+      __ :encode_uint, { type: String.constrained(format: /\A[Uu]\d+\z/), value: Integer }, U8Array
+      def encode_uint(type, value)
+        raise InvalidValueError, "type: #{type}, value: #{value.inspect}" unless value.is_a?(::Integer)
+
+        bit_length = type[1..].to_i
+        Utils.int_to_u8a(value, bit_length).reverse
+      end
+
+      __ :encode_int, { type: String.constrained(format: /\A[Ii]\d+\z/), value: Integer }, U8Array
+      def encode_int(_type, _value)
+        raise NotImplemented, 'encode_int'
+        # raise InvalidValueError, "type: #{type}, value: #{value.inspect}" unless value.is_a?(Integer)
+        #
+        # bit_length = type[1..].to_i
+        # Utils.int_to_u8a(value, bit_length).reverse
+      end
+
+      __ :encode_str, { string: String }, U8Array
+      def encode_str(string)
+        body = string.unpack('C*')
+        encode_compact(body.length) + body
+      end
+
+      __ :encode_boolean, { value: Bool }, U8Array
+      def encode_boolean(value)
+        return [0x00] if value == false
+        return [0x01] if value == true
+
+        raise InvalidValueError, "type: Bool, value: #{value.inspect}"
+      end
+
+      __ :encode_compact, { value: Integer }, U8Array
+      def encode_compact(value)
+        return [value << 2] if value.between?(0, 63)
+        return Utils.int_to_u8a(((value << 2) + 1)).reverse if value < 2**14
+        return Utils.int_to_u8a(((value << 2) + 2)).reverse if value < 2**30
+
+        bytes = Utils.int_to_u8a(value).reverse
+        [(((bytes.length - 4) << 2) + 3)] + bytes
+      end
+    end
+
+    extend InternalDecodeUtils
+    extend InternalEncodeUtils
+  end
+end

data/lib/scale_rb/decode.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require_relative 'codec_utils'
+
+# rubocop:disable all
+module ScaleRb
+  module Decode
+    extend TypeEnforcer
+    include Types
+
+    __ :decode, { id: Ti, bytes: U8Array, registry: Registry }, DecodeResult[Any]
+    def decode(id, bytes, registry)
+      ScaleRb.logger.debug("Decoding #{id}, bytes: #{bytes.length} bytes")
+      type = registry[id]
+      raise Codec::TypeNotFound, "id: #{id}" if type.nil?
+
+      case type
+      when PrimitiveType then decode_primitive(type, bytes)
+      when CompactType then decode_compact(bytes)
+      when ArrayType then decode_array(type, bytes, registry)
+      when SequenceType then decode_sequence(type, bytes, registry)
+      when TupleType then decode_tuple(type, bytes, registry)
+      when StructType then decode_struct(type, bytes, registry)
+      when UnitType then [[], bytes]
+      when VariantType then decode_variant(type, bytes, registry)
+      else raise Codec::TypeNotImplemented, "id: #{id}, type: #{type}"
+      end
+    end
+
+    __ :decode_primitive, { type: PrimitiveType, bytes: U8Array }, DecodeResult[UnsignedInteger | Integer | String | Bool]
+    def decode_primitive(type, bytes)
+      primitive = type.primitive.to_s
+      ScaleRb.logger.debug("Decoding primitive: #{primitive}, bytes: #{bytes.length} bytes")
+
+      return CodecUtils.decode_uint(primitive, bytes) if primitive.start_with?('U')
+      return CodecUtils.decode_int(primitive, bytes) if primitive.start_with?('I')
+      return CodecUtils.decode_str(bytes) if primitive == 'Str'
+      return CodecUtils.decode_boolean(bytes) if primitive == 'Bool'
+
+      raise Codec::TypeNotImplemented, "decoding primitive: #{primitive}"
+    end
+
+    __ :decode_compact, { bytes: U8Array }, DecodeResult[UnsignedInteger]
+    def decode_compact(bytes)
+      ScaleRb.logger.debug("Decoding compact: bytes: #{bytes.length} bytes")
+
+      CodecUtils.decode_compact(bytes)
+    end
+
+    __ :decode_array, { type: ArrayType, bytes: U8Array, registry: Registry }, DecodeResult[TypedArray[Any]]
+    def decode_array(type, bytes, registry)
+      ScaleRb.logger.debug("Decoding array: #{type}, bytes: #{bytes.length} bytes")
+
+      len = type.len
+      inner_type_id = type.type
+
+      _decode_types([inner_type_id] * len, bytes, registry)
+    end
+
+    __ :decode_sequence, { sequence_type: SequenceType, bytes: U8Array, registry: Registry }, DecodeResult[TypedArray[Any]]
+    def decode_sequence(sequence_type, bytes, registry)
+      ScaleRb.logger.debug("Decoding sequence: #{sequence_type}, bytes: #{bytes.length} bytes")
+
+      len, remaining_bytes = decode_compact(bytes)
+      _decode_types([sequence_type.type] * len, remaining_bytes, registry)
+    end
+
+    __ :decode_tuple, { tuple_type: TupleType, bytes: U8Array, registry: Registry }, DecodeResult[TypedArray[Any] | Any]
+    def decode_tuple(tuple_type, bytes, registry)
+      ScaleRb.logger.debug("Decoding tuple: #{tuple_type}, bytes: #{bytes.length} bytes")
+
+      type_ids = tuple_type.tuple
+
+      # NOTE: If the tuple has only one element, decode that element directly.
+      # This is to make the structure of the decoded result clear.
+      if type_ids.length == 1
+        decode(type_ids.first, bytes, registry)
+      else
+        _decode_types(type_ids, bytes, registry)
+      end
+    end
+
+    __ :decode_struct, { struct_type: StructType, bytes: U8Array, registry: Registry }, DecodeResult[HashMap[Symbol, Any]]
+    def decode_struct(struct_type, bytes, registry)
+      ScaleRb.logger.debug("Decoding struct: #{struct_type}, bytes: #{bytes.length} bytes")
+
+      fields = struct_type.fields
+
+      names = fields.map { |f| f.name.to_sym }
+      type_ids = fields.map(&:type)
+
+      values, remaining_bytes = _decode_types(type_ids, bytes, registry)
+      [
+        [names, values].transpose.to_h,
+        remaining_bytes
+      ]
+    end
+
+    __ :decode_variant, { variant_type: VariantType, bytes: U8Array, registry: Registry }, DecodeResult[Nil | String | Integer | Symbol | HashMap[Symbol, Any]]
+    def decode_variant(variant_type, bytes, registry)
+      ScaleRb.logger.debug("Decoding variant: #{variant_type}, bytes: #{bytes.length} bytes")
+
+      # find the variant by the index
+      index = bytes[0].to_i
+      variant = variant_type.variants.find { |v| v.index == index }
+      raise Codec::VariantIndexOutOfRange, "type: #{variant_type}, index: #{index}, bytes: #{bytes}" if variant.nil?
+
+      # decode the variant
+      case variant
+      when SimpleVariant
+        if variant.name == :None
+          [nil, bytes[1..]]
+        else
+          [
+            variant.name,
+            bytes[1..]
+          ]
+        end
+      when TupleVariant
+        value, remainning_bytes = decode_tuple(variant.tuple, bytes[1..], registry)
+        if variant.name == :Some
+          [value, remainning_bytes]
+        else
+          [
+            { variant.name => value },
+            remainning_bytes
+          ]
+        end
+      when StructVariant
+        value, remainning_bytes = decode_struct(variant.struct, bytes[1..], registry)
+        [
+          { variant.name => value },
+          remainning_bytes
+        ]
+      else raise 'Unreachable'
+      end
+    end
+
+    private
+
+    # @param type_id [Ti] Type identifier
+    # @param registry [Hash] Registry of types
+    # @return [Bool] True if the type is a U8, false otherwise
+    def _u8?(type_id, registry)
+      type = registry[type_id]
+      raise Codec::TypeNotFound, "id: #{type_id}" if type.nil?
+
+      type.is_a?(ScaleRb::PrimitiveType) && type.primitive == 'U8'
+    end
+
+    # @param type_ids [Array<Ti>] Array of type identifiers
+    # @param bytes [U8Array] Byte array to decode
+    # @param registry [Hash] Registry of types
+    # @return [Array<(Array<Any>, U8Array)>] Decoded values and remaining bytes
+    def _decode_types(type_ids, bytes, registry = {})
+      remaining_bytes = bytes
+      values = type_ids.map do |type_id|
+        value, remaining_bytes = decode(type_id, remaining_bytes, registry)
+        value
+      end
+      [values, remaining_bytes]
+    end
+  end
+end

data/lib/scale_rb/encode.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+# rubocop:disable all
+module ScaleRb
+  module Encode
+    extend TypeEnforcer
+    include Types
+
+    __ :encode, { id: Ti, value: Any, registry: Registry }, U8Array, level: 3
+    def encode(id, value, registry)
+      ScaleRb.logger.debug("Encoding #{id}, value: #{value}")
+      type = registry[id]
+      raise Codec::TypeNotFound, "id: #{id}" if type.nil?
+
+      case type # type: PortableType
+      when PrimitiveType then encode_primitive(type, value)
+      when CompactType then encode_compact(value)
+      when ArrayType then encode_array(type, value, registry)
+      when SequenceType then encode_sequence(type, value, registry)
+      when TupleType then encode_tuple(type, value, registry)
+      when StructType then encode_struct(type, value, registry)
+      when UnitType then []
+      when VariantType then encode_variant(type, value, registry)
+      else raise Codec::TypeNotImplemented, "encoding id: #{id}, type: #{type}"
+      end
+    end
+
+    __ :encode_primitive, { type: PrimitiveType, value: Any }, U8Array
+    def encode_primitive(type, value)
+      primitive = type.primitive.to_s
+      ScaleRb.logger.debug("Encoding primitive: #{primitive}, value: #{value}")
+
+      return ScaleRb::CodecUtils.encode_uint(primitive, value) if primitive.start_with?('U')
+      return ScaleRb::CodecUtils.encode_int(primitive, value) if primitive.start_with?('I')
+      return ScaleRb::CodecUtils.encode_string(value) if primitive == 'Str'
+      return ScaleRb::CodecUtils.encode_boolean(value) if primitive == 'Bool'
+
+      raise Codec::TypeNotImplemented, "encoding primitive: #{primitive}"
+    end
+
+    __ :encode_compact, { value: Ti }, U8Array
+    def encode_compact(value)
+      ScaleRb.logger.debug("Encoding compact: #{value}")
+
+      ScaleRb::CodecUtils.encode_compact(value)
+    end
+
+    __ :encode_array, { array_type: ArrayType, value: Array.of(Any), registry: Registry }, U8Array
+    def encode_array(array_type, value, registry)
+      ScaleRb.logger.debug("Encoding array: #{array_type}, value: #{value}")
+
+      len = array_type.len
+      inner_type_id = array_type.type
+
+      _encode_types([inner_type_id] * len, value, registry)
+    end
+
+    __ :encode_sequence, { sequence_type: SequenceType, value: Array.of(Any), registry: Registry }, U8Array
+    def encode_sequence(sequence_type, value, registry)
+      ScaleRb.logger.debug("Encoding sequence: #{sequence_type}, value: #{value}")
+
+      len = value.length
+      inner_type_id = sequence_type.type
+
+      encode_compact(len) + _encode_types([inner_type_id] * len, value, registry)
+    end
+
+    __ :encode_tuple, { tuple_type: TupleType, value: Array.of(Any) | Any, registry: Registry }, U8Array
+    def encode_tuple(tuple_type, value, registry)
+      ScaleRb.logger.debug("Encoding tuple: #{tuple_type}, value: #{value}")
+
+      type_ids = tuple_type.tuple
+
+      # For example: if the tuple type is (AccountId32), the value can be a AccountId32
+      # TODO: Check if this is correct
+      value = [value] if type_ids.length == 1
+
+      _encode_types(type_ids, value, registry)
+    end
+
+    __ :encode_struct, { struct_type: StructType, value: Hash.map(Symbol, Any), registry: Registry }, U8Array
+    def encode_struct(struct_type, value, registry)
+      ScaleRb.logger.debug("Encoding struct: #{struct_type}, value: #{value}")
+
+      fields = struct_type.fields
+
+      type_ids = fields.map(&:type)
+      _encode_types(type_ids, value.values, registry)
+    end
+
+    __ :encode_variant, { variant_type: VariantType, value: Nil | String | Integer | Symbol | HashMap[Symbol, Any], registry: Registry }, U8Array
+    def encode_variant(variant_type, value, registry)
+      ScaleRb.logger.debug("Encoding variant: #{variant_type}, value: #{value}")
+
+      if variant_type.option?
+        if value.nil?
+          name = :None
+        else
+          name = :Some
+        end
+      else
+        name = value.is_a?(::Symbol) ? value : value.keys.first
+      end
+
+      variant = variant_type.variants.find { |v| v.name == name }
+      raise Codec::VariantItemNotFound, "type: #{variant_type}, name: #{value}" if variant.nil?
+
+      case variant
+      when SimpleVariant
+        ScaleRb::CodecUtils.encode_uint('U8', variant.index)
+      when TupleVariant
+        # value example1: {:X2=>[{:Parachain=>12}, {:PalletInstance=>34}]}
+        # value.values.first: [[{:Parachain=>12}, {:PalletInstance=>34}]]
+        #
+        # value example2: {:Parachain=>12}
+        # value.values.first: 12
+        ScaleRb::CodecUtils.encode_uint('U8', variant.index) + encode_tuple(variant.tuple, value.values.first, registry)
+      when StructVariant
+        # value example: {
+        #   :Transact=>{
+        #     :origin_type=>:SovereignAccount, 
+        #     :require_weight_at_most=>5000000000,
+        #     :call=>...
+        #   }
+        # }
+        # value.values.first: {
+        #   :origin_type=>:SovereignAccount,
+        #   :require_weight_at_most=>5000000000,
+        #   :call=>...
+        # }
+        ScaleRb::CodecUtils.encode_uint('U8', variant.index) + encode_struct(variant.struct, value.values.first, registry)
+      end
+    end
+
+    private
+
+    # @param type_ids [Array<Ti>] Array of type identifiers
+    # @param values [Array<Any>] Array of values to encode
+    # @param registry [Registry] Registry of types
+    # @return [U8Array] Encoded bytes
+    def _encode_types(type_ids, values, registry)
+      raise Codec::LengthNotEqualErr, "type_ids: #{type_ids}, values: #{values.inspect}" if type_ids.length != values.length
+
+      type_ids.each_with_index.reduce([]) do |memo, (type_id, i)|
+        memo + encode(type_id, values[i], registry)
+      end
+    end
+
+  end
+end

data/lib/{hasher.rb → scale_rb/hasher.rb}

@@ -8,10 +8,12 @@ module ScaleRb
     class << self
       # params:
       #   hasher: 'Identity' | 'Twox64Concat' | 'Blake2128Concat'
-      #    bytes: u8 array
-      # return: u8 array
+      #   bytes: u8a | hex string
+      # return: u8a
       def apply_hasher(hasher, bytes)
-        function_name = hasher.gsub('_', '')._underscore
+        bytes = Utils.hex_to_u8a(bytes) if bytes.is_a?(::String)
+
+        function_name = Utils.underscore(hasher.to_s.gsub('_', ''))
         Hasher.send(function_name, bytes)
       end
     end
@@ -22,7 +24,7 @@ module ScaleRb
       end
 
       def twox64_concat(bytes)
-        data = bytes._to_utf8
+        data = Utils.u8a_to_utf8(bytes)
         twox64(data) + bytes
       end
 
@@ -32,24 +34,24 @@ module ScaleRb
 
       def twox64(str)
         result = XXhash.xxh64 str, 0
-        result._to_bytes.reverse
+        Utils.hex_to_u8a(result.to_s(16)).reverse
       end
 
       def twox128(str)
         bytes = []
         2.times do |i|
           result = XXhash.xxh64 str, i
-          bytes += result._to_bytes.reverse
+          bytes += Utils.hex_to_u8a(result.to_s(16)).reverse
         end
         bytes
       end
 
       def blake2_128(bytes)
-        Blake2b.hex(bytes, 16)._to_bytes
+        Utils.hex_to_u8a(Blake2b.hex(bytes, 16))
       end
 
       def blake2_256(bytes)
-        Blake2b.hex(bytes, 32)._to_bytes
+        Utils.hex_to_u8a(Blake2b.hex(bytes, 32))
       end
     end
   end

data/lib/scale_rb/metadata/metadata.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative './registry'
+
+require_relative './metadata_v9'
+require_relative './metadata_v10'
+require_relative './metadata_v11'
+require_relative './metadata_v12'
+require_relative './metadata_v13'
+require_relative './metadata_v14'
+
+# NOTE: Only v14 and later are supported.
+# https://github.com/paritytech/frame-metadata/blob/main/frame-metadata/src/lib.rs#L85
+module ScaleRb
+  module Metadata
+    class << self
+      def decode_metadata(hex)
+        bytes = ScaleRb::Utils.hex_to_u8a(hex)
+
+        registry = ScaleRb::Metadata::Registry.new TYPES
+        ti = registry.use('MetadataPrefixed')
+        metadata, = ScaleRb::Codec.decode(ti, bytes, registry)
+        metadata
+      end
+
+      def build_registry(metadata_prefixed)
+        types = ScaleRb::Utils.get(metadata_prefixed, :metadata, :V14, :lookup, :types)
+        ScaleRb::PortableRegistry.new(types)
+      end
+
+      def get_module(pallet_name, metadata_prefixed)
+        metadata = Utils.get(metadata_prefixed, :metadata)
+        version = metadata.keys.first
+        raise NotImplementedError, version unless %i[V14].include?(version)
+
+        Metadata.const_get("Metadata#{version.upcase}").get_module(pallet_name, metadata_prefixed)
+      end
+
+      def get_module_by_index(pallet_index, metadata_prefixed)
+        metadata = Utils.get(metadata_prefixed, :metadata)
+        version = metadata.keys.first.to_sym
+        raise NotImplementedError, version unless %i[V14].include?(version)
+
+        Metadata.const_get("Metadata#{version.upcase}").get_module_by_index(pallet_index, metadata_prefixed)
+      end
+
+      def get_storage_item(pallet_name, item_name, metadata_prefixed)
+        metadata = Utils.get(metadata_prefixed, :metadata)
+        version = metadata.keys.first.to_sym
+        raise NotImplementedError, version unless %i[V14].include?(version)
+
+        Metadata.const_get("Metadata#{version.upcase}").get_storage_item(pallet_name, item_name, metadata_prefixed)
+      end
+
+      def get_calls_type(pallet_name, metadata_prefixed)
+        metadata = Utils.get(metadata_prefixed, :metadata)
+        version = metadata.keys.first.to_sym
+        raise NotImplementedError, version unless %i[V14].include?(version)
+
+        Metadata.const_get("Metadata#{version.upcase}").get_calls_type(pallet_name, metadata_prefixed)
+      end
+
+      def get_calls_type_id(pallet_name, metadata_prefixed)
+        metadata = Utils.get(metadata_prefixed, :metadata)
+        version = metadata.keys.first.to_sym
+        raise NotImplementedError, version unless %i[V14].include?(version)
+
+        Metadata.const_get("Metadata#{version.upcase}").get_calls_type_id(pallet_name, metadata_prefixed)
+      end
+
+      def get_call_type(pallet_name, call_name, metadata_prefixed)
+        metadata = Utils.get(metadata_prefixed, :metadata)
+        version = metadata.keys.first.to_sym
+        raise NotImplementedError, version unless %i[V14].include?(version)
+
+        Metadata.const_get("Metadata#{version.upcase}").get_call_type(pallet_name, call_name, metadata_prefixed)
+      end
+    end
+
+    TYPES = {
+      Type: 'Str',
+      Bytes: 'Vec<u8>',
+      MetadataPrefixed: {
+        magicNumber: 'U32',
+        metadata: 'Metadata'
+      },
+      Placeholder: 'Null',
+      Metadata: {
+        _enum: {
+          V0: 'Placeholder',
+          V1: 'Placeholder',
+          V2: 'Placeholder',
+          V3: 'Placeholder',
+          V4: 'Placeholder',
+          V5: 'Placeholder',
+          V6: 'Placeholder',
+          V7: 'Placeholder',
+          V8: 'Placeholder',
+          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
+end

data/lib/{metadata → scale_rb/metadata}/metadata_v10.rb

@@ -3,23 +3,6 @@
 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
-
-        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
-
       TYPES = {
         ErrorMetadataV10: 'ErrorMetadataV9',
         EventMetadataV10: 'EventMetadataV9',

data/lib/{metadata → scale_rb/metadata}/metadata_v11.rb

@@ -3,23 +3,6 @@
 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
-
-        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
-
       TYPES = {
         ErrorMetadataV11: 'ErrorMetadataV10',
         EventMetadataV11: 'EventMetadataV10',

data/lib/{metadata → scale_rb/metadata}/metadata_v12.rb

@@ -3,23 +3,6 @@
 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
-
-        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
-
       TYPES = {
         ErrorMetadataV12: 'ErrorMetadataV11',
         EventMetadataV12: 'EventMetadataV11',