scale_rb 0.1.15 → 0.2.2

data/lib/codec.rb

@@ -145,12 +145,12 @@ module ScaleRb
       when 0
         [bytes[0] >> 2, bytes[1..]]
       when 1
-        [bytes[0..1].flip.to_uint >> 2, bytes[2..]]
+        [bytes[0..1]._flip._to_uint >> 2, bytes[2..]]
       when 2
-        [bytes[0..3].flip.to_uint >> 2, bytes[4..]]
+        [bytes[0..3]._flip._to_uint >> 2, bytes[4..]]
       when 3
         length = 4 + (bytes[0] >> 2)
-        [bytes[1..length].flip.to_uint, bytes[length + 1..]]
+        [bytes[1..length]._flip._to_uint, bytes[length + 1..]]
       else
         raise Unreachable, 'type: Compact'
       end
@@ -220,7 +220,7 @@ module ScaleRb
 
     def decode_bytes(bytes)
       length, remaining_bytes = _do_decode_compact(bytes)
-      value = remaining_bytes[0...length].to_hex
+      value = remaining_bytes[0...length]._to_hex
       # debug 'length', length
       # debug 'value', value
       [
@@ -246,7 +246,7 @@ module ScaleRb
       length, remaining_bytes = _do_decode_compact(bytes)
       raise NotEnoughBytesError, 'type: String' if remaining_bytes.length < length
 
-      value = remaining_bytes[0...length].to_utf8
+      value = remaining_bytes[0...length]._to_utf8
       # debug 'byte length', length
       # debug 'value', value.inspect
       [
@@ -260,7 +260,7 @@ module ScaleRb
       byte_length = bit_length / 8
       raise NotEnoughBytesError, "type: #{type}" if bytes.length < byte_length
 
-      value = bytes[0...byte_length].flip.to_int(bit_length)
+      value = bytes[0...byte_length]._flip._to_int(bit_length)
       # debug 'value', value
       [
         value,
@@ -273,7 +273,7 @@ module ScaleRb
       byte_length = bit_length / 8
       raise NotEnoughBytesError, "type: #{type_def}" if bytes.length < byte_length
 
-      value = bytes[0...byte_length].flip.to_uint
+      value = bytes[0...byte_length]._flip._to_uint
       # debug 'value', value
       [
         value,
@@ -396,16 +396,16 @@ module ScaleRb
 
     def encode_compact(value)
       return [value << 2] if (value >= 0) && (value < 64)
-      return ((value << 2) + 1).to_bytes.flip if value < 2**14
-      return ((value << 2) + 2).to_bytes.flip if value < 2**30
+      return ((value << 2) + 1)._to_bytes._flip if value < 2**14
+      return ((value << 2) + 2)._to_bytes._flip if value < 2**30
 
-      bytes = value.to_bytes.flip
+      bytes = value._to_bytes._flip
       [(((bytes.length - 4) << 2) + 3)] + bytes
     end
 
     def encode_uint(type, value)
       bit_length = type[1..].to_i
-      value.to_bytes(bit_length).flip
+      value._to_bytes(bit_length)._flip
     end
 
     def encode_option(type, value, registry = {})

data/lib/hasher.rb

@@ -3,52 +3,54 @@
 require 'xxhash'
 require 'blake2b'
 
-module Hasher
-  class << self
-    # params:
-    #   hasher: 'Identity' | 'Twox64Concat' | 'Blake2128Concat'
-    #    bytes: u8 array
-    # return: u8 array
-    def apply_hasher(hasher, bytes)
-      function_name = hasher.gsub('_', '').underscore
-      Hasher.send(function_name, bytes)
+module ScaleRb
+  module Hasher
+    class << self
+      # params:
+      #   hasher: 'Identity' | 'Twox64Concat' | 'Blake2128Concat'
+      #    bytes: u8 array
+      # return: u8 array
+      def apply_hasher(hasher, bytes)
+        function_name = hasher.gsub('_', '')._underscore
+        Hasher.send(function_name, bytes)
+      end
     end
-  end
 
-  class << self
-    def identity(bytes)
-      bytes
-    end
+    class << self
+      def identity(bytes)
+        bytes
+      end
 
-    def twox64_concat(bytes)
-      data = bytes.to_utf8
-      twox64(data) + bytes
-    end
+      def twox64_concat(bytes)
+        data = bytes._to_utf8
+        twox64(data) + bytes
+      end
 
-    def blake2128_concat(bytes)
-      blake2_128(bytes) + bytes
-    end
+      def blake2128_concat(bytes)
+        blake2_128(bytes) + bytes
+      end
 
-    def twox64(str)
-      result = XXhash.xxh64 str, 0
-      result.to_bytes.reverse
-    end
+      def twox64(str)
+        result = XXhash.xxh64 str, 0
+        result._to_bytes.reverse
+      end
 
-    def twox128(str)
-      bytes = []
-      2.times do |i|
-        result = XXhash.xxh64 str, i
-        bytes += result.to_bytes.reverse
+      def twox128(str)
+        bytes = []
+        2.times do |i|
+          result = XXhash.xxh64 str, i
+          bytes += result._to_bytes.reverse
+        end
+        bytes
       end
-      bytes
-    end
 
-    def blake2_128(bytes)
-      Blake2b.hex(bytes, 16).to_bytes
-    end
+      def blake2_128(bytes)
+        Blake2b.hex(bytes, 16)._to_bytes
+      end
 
-    def blake2_256(bytes)
-      Blake2b.hex(bytes, 32).to_bytes
+      def blake2_256(bytes)
+        Blake2b.hex(bytes, 32)._to_bytes
+      end
     end
   end
 end

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