scale_rb 0.1.15 → 0.2.0

data/lib/portable_codec.rb

@@ -1,280 +1,284 @@
 # frozen_string_literal: true
 
-module PortableCodec
-  class Error < StandardError; end
-  class TypeNotFound < Error; end
-  class TypeNotImplemented < Error; end
-  class CompositeInvalidValue < Error; end
-  class ArrayLengthNotEqual < Error; end
-  class VariantItemNotFound < Error; end
-  class VariantIndexOutOfRange < Error; end
-  class VariantInvalidValue < Error; end
-
-  class << self
-    def u256(value)
-      bytes = ScaleRb.encode('u256', value)
-      bytes.each_slice(8).map do |slice|
-        ScaleRb.decode('u64', slice).first
+module ScaleRb
+  module PortableCodec
+    class Error < StandardError; end
+    class TypeNotFound < Error; end
+    class TypeNotImplemented < Error; end
+    class CompositeInvalidValue < Error; end
+    class ArrayLengthNotEqual < Error; end
+    class VariantItemNotFound < Error; end
+    class VariantIndexOutOfRange < Error; end
+    class VariantInvalidValue < Error; end
+
+    class << self
+      def u256(value)
+        bytes = ScaleRb.encode('u256', value)
+        bytes.each_slice(8).map do |slice|
+          ScaleRb.decode('u64', slice).first
+        end
       end
     end
-  end
 
-  class << self
-    # registry:
-    #   {
-    #     0 => {
-    #       path: [...],
-    #       params: [...],
-    #       def: {
-    #         primitive: 'u8' | array: {} | ...
-    #       }
-    #     },
-    #     1 => {
-    #       ...
-    #     }
-    #   }
-    def decode(id, bytes, registry)
-      type = registry[id]
-      raise TypeNotFound, "id: #{id}" if type.nil?
-
-      _path = type._get(:path)
-      _params = type._get(:params)
-      type_def = type._get(:def)
-
-      return decode_primitive(type_def, bytes) if type_def._key?(:primitive)
-      return decode_compact(bytes) if type_def._key?(:compact)
-      return decode_array(type_def._get(:array), bytes, registry) if type_def._key?(:array)
-      return decode_sequence(type_def._get(:sequence), bytes, registry) if type_def._key?(:sequence)
-      return decode_tuple(type_def._get(:tuple), bytes, registry) if type_def._key?(:tuple)
-      return decode_composite(type_def._get(:composite), bytes, registry) if type_def._key?(:composite)
-      return decode_variant(type_def._get(:variant), bytes, registry) if type_def._key?(:variant)
-
-      raise TypeNotImplemented, "id: #{id}"
-    end
+    class << self
+      # registry:
+      #   {
+      #     0 => {
+      #       path: [...],
+      #       params: [...],
+      #       def: {
+      #         primitive: 'u8' | array: {} | ...
+      #       }
+      #     },
+      #     1 => {
+      #       ...
+      #     }
+      #   }
+      def decode(id, bytes, registry)
+        type = registry[id]
+        raise TypeNotFound, "id: #{id}" if type.nil?
+
+        _path = type._get(:path)
+        _params = type._get(:params)
+        type_def = type._get(:def)
+
+        return decode_primitive(type_def, bytes) if type_def._key?(:primitive)
+        return decode_compact(bytes) if type_def._key?(:compact)
+        return decode_array(type_def._get(:array), bytes, registry) if type_def._key?(:array)
+        return decode_sequence(type_def._get(:sequence), bytes, registry) if type_def._key?(:sequence)
+        return decode_tuple(type_def._get(:tuple), bytes, registry) if type_def._key?(:tuple)
+        return decode_composite(type_def._get(:composite), bytes, registry) if type_def._key?(:composite)
+        return decode_variant(type_def._get(:variant), bytes, registry) if type_def._key?(:variant)
+
+        raise TypeNotImplemented, "id: #{id}"
+      end
 
-    # Uint, Str, Bool
-    # Int, Bytes ?
-    def decode_primitive(type_def, bytes)
-      primitive = type_def._get(:primitive)
-      return ScaleRb.decode_uint(primitive, bytes) if ScaleRb.uint?(primitive)
-      return ScaleRb.decode_string(bytes) if ScaleRb.string?(primitive)
-      return ScaleRb.decode_boolean(bytes) if ScaleRb.boolean?(primitive)
-      # return ScaleRb.decode_int(primitive, bytes) if int?(primitive)
-      # return ScaleRb.decode_bytes(bytes) if bytes?(primitive)
-    end
+      # Uint, Str, Bool
+      # Int, Bytes ?
+      def decode_primitive(type_def, bytes)
+        primitive = type_def._get(:primitive)
+        return ScaleRb.decode_uint(primitive, bytes) if ScaleRb.uint?(primitive)
+        return ScaleRb.decode_string(bytes) if ScaleRb.string?(primitive)
 
-    def decode_compact(bytes)
-      ScaleRb.decode_compact(bytes)
-    end
+        ScaleRb.decode_boolean(bytes) if ScaleRb.boolean?(primitive)
+        # return ScaleRb.decode_int(primitive, bytes) if int?(primitive)
+        # return ScaleRb.decode_bytes(bytes) if bytes?(primitive)
+      end
 
-    def decode_array(array_type, bytes, registry)
-      len = array_type._get(:len)
-      inner_type_id = array_type._get(:type)
-
-      # check if the type of inner_type_id is a u8
-      if _u8?(inner_type_id, registry)
-        [
-          bytes[0...len].to_hex,
-          bytes[len..]
-        ]
-      else
-        _decode_types([inner_type_id] * len, bytes, registry)
+      def decode_compact(bytes)
+        ScaleRb.decode_compact(bytes)
       end
-    end
 
-    def _u8?(type_id, registry)
-      type = registry[type_id]
-      raise TypeNotFound, "id: #{type_id}" if type.nil?
+      def decode_array(array_type, bytes, registry)
+        len = array_type._get(:len)
+        inner_type_id = array_type._get(:type)
 
-      type._get(:def)._get(:primitive)&.downcase == 'u8'
-    end
+        # check if the type of inner_type_id is a u8
+        if _u8?(inner_type_id, registry)
+          [
+            bytes[0...len]._to_hex,
+            bytes[len..]
+          ]
+        else
+          _decode_types([inner_type_id] * len, bytes, registry)
+        end
+      end
 
-    def decode_sequence(sequence_type, bytes, registry)
-      len, remaining_bytes = decode_compact(bytes)
-      inner_type_id = sequence_type._get(:type)
-      _decode_types([inner_type_id] * len, remaining_bytes, registry)
-    end
+      def _u8?(type_id, registry)
+        type = registry[type_id]
+        raise TypeNotFound, "id: #{type_id}" if type.nil?
 
-    def decode_tuple(tuple_type, bytes, registry)
-      _decode_types(tuple_type, bytes, registry)
-    end
+        type._get(:def)._get(:primitive)&.downcase == 'u8'
+      end
 
-    # {
-    #   name: value,
-    #   ...
-    # }
-    def decode_composite(composite_type, bytes, registry)
-      fields = composite_type._get(:fields)
-
-      # reduce composite level when composite only has one field without name
-      if fields.length == 1 && fields.first._get(:name).nil?
-        decode(fields.first._get(:type), bytes, registry)
-      else
-        type_name_list = fields.map { |f| f._get(:name) }
-        type_id_list = fields.map { |f| f._get(:type) }
-
-        type_value_list, remaining_bytes = _decode_types(type_id_list, bytes, registry)
-        [
-          if type_name_list.all?(&:nil?)
-            type_value_list
-          else
-            [type_name_list.map(&:to_sym), type_value_list].transpose.to_h
-          end,
-          remaining_bytes
-        ]
+      def decode_sequence(sequence_type, bytes, registry)
+        len, remaining_bytes = decode_compact(bytes)
+        inner_type_id = sequence_type._get(:type)
+        _decode_types([inner_type_id] * len, remaining_bytes, registry)
+      end
+
+      def decode_tuple(tuple_type, bytes, registry)
+        _decode_types(tuple_type, bytes, registry)
+      end
+
+      # {
+      #   name: value,
+      #   ...
+      # }
+      def decode_composite(composite_type, bytes, registry)
+        fields = composite_type._get(:fields)
+
+        # reduce composite level when composite only has one field without name
+        if fields.length == 1 && fields.first._get(:name).nil?
+          decode(fields.first._get(:type), bytes, registry)
+        else
+          type_name_list = fields.map { |f| f._get(:name) }
+          type_id_list = fields.map { |f| f._get(:type) }
+
+          type_value_list, remaining_bytes = _decode_types(type_id_list, bytes, registry)
+          [
+            if type_name_list.all?(&:nil?)
+              type_value_list
+            else
+              [type_name_list.map(&:to_sym), type_value_list].transpose.to_h
+            end,
+            remaining_bytes
+          ]
+        end
       end
-    end
 
-    def decode_variant(variant_type, bytes, registry)
-      variants = variant_type._get(:variants)
+      def decode_variant(variant_type, bytes, registry)
+        variants = variant_type._get(:variants)
 
-      index = bytes[0].to_i # TODO: check
-      item = variants.find { |v| v._get(:index) == index } # item is an composite
+        index = bytes[0].to_i # TODO: check
+        item = variants.find { |v| v._get(:index) == index } # item is an composite
 
-      raise VariantIndexOutOfRange, "type: #{variant_type}, index: #{index}, bytes: #{bytes}" if item.nil?
+        raise VariantIndexOutOfRange, "type: #{variant_type}, index: #{index}, bytes: #{bytes}" if item.nil?
 
-      item_name = item._get(:name)
-      item_fields = item._get(:fields)
-      if item_fields.empty?
-        [item_name, bytes[1..]]
-      else
-        item_value, remaining_bytes = decode_composite(item, bytes[1..], registry)
-        [{ item_name.to_sym => item_value }, remaining_bytes]
+        item_name = item._get(:name)
+        item_fields = item._get(:fields)
+        if item_fields.empty?
+          [item_name, bytes[1..]]
+        else
+          item_value, remaining_bytes = decode_composite(item, bytes[1..], registry)
+          [{ item_name.to_sym => item_value }, remaining_bytes]
+        end
       end
-    end
 
-    def _decode_types(ids, bytes, registry = {})
-      ScaleRb._decode_each(ids, bytes) do |id, remaining_bytes|
-        decode(id, remaining_bytes, registry)
+      def _decode_types(ids, bytes, registry = {})
+        ScaleRb._decode_each(ids, bytes) do |id, remaining_bytes|
+          decode(id, remaining_bytes, registry)
+        end
       end
-    end
 
-    def encode_with_hasher(value, type_id, registry, hasher)
-      value_bytes = encode(type_id, value, registry)
-      Hasher.apply_hasher(hasher, value_bytes)
-    end
+      def encode_with_hasher(value, type_id, registry, hasher)
+        value_bytes = encode(type_id, value, registry)
+        Hasher.apply_hasher(hasher, value_bytes)
+      end
 
-    def encode(id, value, registry)
-      type = registry[id]
-      raise TypeNotFound, "id: #{id}" if type.nil?
+      def encode(id, value, registry)
+        type = registry[id]
+        raise TypeNotFound, "id: #{id}" if type.nil?
 
-      type_def = type._get(:def)
-      # debug
-      # p type_def
-      # p value
+        type_def = type._get(:def)
+        # debug
+        # p type_def
+        # p value
 
-      return encode_primitive(type_def, value) if type_def._key?(:primitive)
-      return encode_compact(value) if type_def._key?(:compact)
-      return encode_array(type_def._get(:array), value, registry) if type_def._key?(:array)
-      return encode_sequence(type_def._get(:sequence), value, registry) if type_def._key?(:sequence)
-      return encode_tuple(type_def._get(:tuple), value, registry) if type_def._key?(:tuple)
-      return encode_composite(type_def._get(:composite), value, registry) if type_def._key?(:composite)
-      return encode_variant(type_def._get(:variant), value, registry) if type_def._key?(:variant)
+        return encode_primitive(type_def, value) if type_def._key?(:primitive)
+        return encode_compact(value) if type_def._key?(:compact)
+        return encode_array(type_def._get(:array), value, registry) if type_def._key?(:array)
+        return encode_sequence(type_def._get(:sequence), value, registry) if type_def._key?(:sequence)
+        return encode_tuple(type_def._get(:tuple), value, registry) if type_def._key?(:tuple)
+        return encode_composite(type_def._get(:composite), value, registry) if type_def._key?(:composite)
+        return encode_variant(type_def._get(:variant), value, registry) if type_def._key?(:variant)
 
-      raise TypeNotImplemented, "id: #{id}"
-    end
+        raise TypeNotImplemented, "id: #{id}"
+      end
 
-    def encode_primitive(type_def, value)
-      primitive = type_def._get(:primitive)
-      return ScaleRb.encode_uint(primitive, value) if ScaleRb.uint?(primitive)
-      return ScaleRb.encode_string(value) if ScaleRb.string?(primitive)
-      return ScaleRb.encode_boolean(value) if ScaleRb.boolean?(primitive)
-    end
+      def encode_primitive(type_def, value)
+        primitive = type_def._get(:primitive)
+        return ScaleRb.encode_uint(primitive, value) if ScaleRb.uint?(primitive)
+        return ScaleRb.encode_string(value) if ScaleRb.string?(primitive)
 
-    def encode_compact(value)
-      ScaleRb.encode_compact(value)
-    end
+        ScaleRb.encode_boolean(value) if ScaleRb.boolean?(primitive)
+      end
 
-    def encode_array(array_type, value, registry)
-      length = array_type._get(:len)
-      inner_type_id = array_type._get(:type)
-      raise ArrayLengthNotEqual, "type: #{array_type}, value: #{value.inspect}" if length != value.length
+      def encode_compact(value)
+        ScaleRb.encode_compact(value)
+      end
 
-      _encode_types([inner_type_id] * length, value, registry)
-    end
+      def encode_array(array_type, value, registry)
+        length = array_type._get(:len)
+        inner_type_id = array_type._get(:type)
+        raise ArrayLengthNotEqual, "type: #{array_type}, value: #{value.inspect}" if length != value.length
 
-    def encode_sequence(sequence_type, value, registry)
-      inner_type_id = sequence_type._get(:type)
-      length_bytes = encode_compact(value.length)
-      length_bytes + _encode_types([inner_type_id] * value.length, value, registry)
-    end
+        _encode_types([inner_type_id] * length, value, registry)
+      end
 
-    # tuple_type: [type_id1, type_id2, ...]
-    def encode_tuple(tuple_type, value, registry)
-      _encode_types(tuple_type, value, registry)
-    end
+      def encode_sequence(sequence_type, value, registry)
+        inner_type_id = sequence_type._get(:type)
+        length_bytes = encode_compact(value.length)
+        length_bytes + _encode_types([inner_type_id] * value.length, value, registry)
+      end
 
-    # value:
-    #   {
-    #     name1: value1,
-    #     name2: value2,
-    #     ...
-    #   }
-    #   or
-    #   [value1, value2, ...]
-    def encode_composite(composite_type, value, registry)
-      fields = composite_type._get(:fields)
-      # reduce composite level when composite only has one field without name
-      if fields.length == 1 && fields.first._get(:name).nil?
-        # debug
-        # p fields.first._get(:type)
-        # p value
-        encode(fields.first._get(:type), value, registry)
-      else
-        values =
+      # tuple_type: [type_id1, type_id2, ...]
+      def encode_tuple(tuple_type, value, registry)
+        _encode_types(tuple_type, value, registry)
+      end
+
+      # value:
+      #   {
+      #     name1: value1,
+      #     name2: value2,
+      #     ...
+      #   }
+      #   or
+      #   [value1, value2, ...]
+      def encode_composite(composite_type, value, registry)
+        fields = composite_type._get(:fields)
+        # reduce composite level when composite only has one field without name
+        if fields.length == 1 && fields.first._get(:name).nil?
+          # debug
+          # p fields.first._get(:type)
+          # p value
+          encode(fields.first._get(:type), value, registry)
+        else
+          values =
+            if value.instance_of?(Hash)
+              value.values
+            elsif value.instance_of?(Array)
+              value
+            else
+              raise CompositeInvalidValue, "value: #{value}, only hash and array"
+            end
+
+          type_id_list = fields.map { |f| f._get(:type) }
+          _encode_types(type_id_list, values, registry)
+        end
+      end
+
+      # value:
+      # {
+      #   name: v(Hash)
+      # }
+      # or
+      # the_value(String)
+      def encode_variant(variant_type, value, registry)
+        variants = variant_type._get(:variants)
+
+        name, v = # v: item inner value
           if value.instance_of?(Hash)
-            value.values
-          elsif value.instance_of?(Array)
-            value
+            [value.keys.first.to_s, value.values.first]
+          elsif value.instance_of?(String)
+            [value, {}]
           else
-            raise CompositeInvalidValue, "value: #{value}, only hash and array"
+            raise VariantInvalidValue, "type: #{variant_type}, value: #{value}"
           end
 
-        type_id_list = fields.map { |f| f._get(:type) }
-        _encode_types(type_id_list, values, registry)
-      end
-    end
+        item = variants.find { |var| var._get(:name) == name }
+        raise VariantItemNotFound, "type: #{variant_type}, name: #{name}" if item.nil?
 
-    # value:
-    # {
-    #   name: v(Hash)
-    # }
-    # or
-    # the_value(String)
-    def encode_variant(variant_type, value, registry)
-      variants = variant_type._get(:variants)
-
-      name, v = # v: item inner value
-        if value.instance_of?(Hash)
-          [value.keys.first.to_s, value.values.first]
-        elsif value.instance_of?(String)
-          [value, {}]
-        else
-          raise VariantInvalidValue, "type: #{variant_type}, value: #{value}"
+        # if the variant item has more than one field, the value must be a hash with the same length.
+        # if the variant item has only one field, that means the field is a type id point to a composite. TODO: check the type's fields length
+        if item._get(:fields).length > 1 && item._get(:fields).length != v.length
+          raise VariantFieldsLengthNotMatch,
+                "type: #{variant_type}, \nvalue: #{v}"
         end
 
-      item = variants.find { |var| var._get(:name) == name }
-      raise VariantItemNotFound, "type: #{variant_type}, name: #{name}" if item.nil?
-
-      # if the variant item has more than one field, the value must be a hash with the same length.
-      # if the variant item has only one field, that means the field is a type id point to a composite. TODO: check the type's fields length
-      if item._get(:fields).length > 1 && item._get(:fields).length != v.length
-        raise VariantFieldsLengthNotMatch,
-              "type: #{variant_type}, \nvalue: #{v}"
+        ScaleRb.encode_uint('u8', item._get(:index)) + encode_composite(item, v, registry)
       end
 
-      ScaleRb.encode_uint('u8', item._get(:index)) + encode_composite(item, v, registry)
-    end
-
-    def _encode_types(ids, values, registry)
-      ScaleRb._encode_each(ids, values) do |id, value|
-        encode(id, value, registry)
+      def _encode_types(ids, values, registry)
+        ScaleRb._encode_each(ids, values) do |id, value|
+          encode(id, value, registry)
+        end
       end
-    end
 
-    def _encode_types_with_hashers(ids, values, registry, hashers)
-      ScaleRb._encode_each_with_hashers(ids, values, hashers) do |id, value|
-        encode(id, value, registry)
+      def _encode_types_with_hashers(ids, values, registry, hashers)
+        ScaleRb._encode_each_with_hashers(ids, values, hashers) do |id, value|
+          encode(id, value, registry)
+        end
       end
     end
   end

data/lib/scale_rb/version.rb

@@ -1,3 +1,3 @@
 module ScaleRb
-  VERSION = '0.1.15'
+  VERSION = '0.2.0'
 end

data/lib/scale_rb.rb

@@ -21,7 +21,6 @@ require 'hasher'
 require 'storage_helper'
 
 # client
-require 'client/rpc_request_builder'
 require 'client/http_client'
 require 'client/abstract_ws_client'
 

data/lib/storage_helper.rb

@@ -1,64 +1,66 @@
 # frozen_string_literal: true
 
-module StorageHelper
-  class << self
-    # key: {
-    #   value: ,
-    #   type: ,
-    #   hashers: []
-    # }
-    def encode_storage_key(pallet_name, item_name, key = nil, registry = nil)
-      storage_key = Hasher.twox128(pallet_name) + Hasher.twox128(item_name)
+module ScaleRb
+  module StorageHelper
+    class << self
+      # key: {
+      #   value: ,
+      #   type: ,
+      #   hashers: []
+      # }
+      def encode_storage_key(pallet_name, item_name, key = nil, registry = nil)
+        storage_key = Hasher.twox128(pallet_name) + Hasher.twox128(item_name)
 
-      if key && registry
+        if key && registry
 
-        key_types, key_values, key_hashers =
-          if key[:hashers].length == 1
-            [
-              [key[:type]],
-              key[:value],
-              key[:hashers]
-            ]
-          else
-            [
-              registry[key[:type]]._get(:def)._get(:tuple).first(key[:value].length),
-              key[:value],
-              key[:hashers].first(key[:value].length)
-            ]
+          key_types, key_values, key_hashers =
+            if key[:hashers].length == 1
+              [
+                [key[:type]],
+                [key[:value]],
+                key[:hashers]
+              ]
+            else
+              [
+                registry[key[:type]]._get(:def)._get(:tuple).first(key[:value].length),
+                key[:value],
+                key[:hashers].first(key[:value].length)
+              ]
+            end
+
+          if key_types.class != key_values.class || key_types.length != key_values.length
+            raise "Key's value doesn't match key's type, key's value: #{key_values.inspect}, but key's type: #{key_types.inspect}. Please check your key's value."
           end
 
-        if key_types.class != key_values.class || key_types.length != key_values.length
-          raise "Key's value doesn't match key's type, key's value: #{key_values.inspect}, but key's type: #{key_types.inspect}. Please check your key's value."
+          storage_key + PortableCodec._encode_types_with_hashers(key_types, key_values, registry, key_hashers)
+        else
+          storage_key
         end
-
-        storage_key + PortableCodec._encode_types_with_hashers(key_types, key_values, registry, key_hashers)
-      else
-        storage_key
       end
-    end
 
-    # data: hex string
-    # type: portable type id
-    # optional: boolean
-    # fallback: hex string
-    # returns nil or data
-    def decode_storage(data, type, optional, fallback, registry)
-      data ||= (optional ? nil : fallback)
-      PortableCodec.decode(type, data.to_bytes, registry)[0] if data
-    end
+      # data: hex string
+      # type: portable type id
+      # optional: boolean
+      # fallback: hex string
+      # returns nil or data
+      def decode_storage(data, type, optional, fallback, registry)
+        data ||= (optional ? nil : fallback)
+        PortableCodec.decode(type, data._to_bytes, registry)[0] if data
+      end
 
-    # storage_item: the storage item from metadata
-    def decode_storage2(data, storage_item, registry)
-      modifier = storage_item._get(:modifier) # Default | Optional
-      fallback = storage_item._get(:fallback)
-      type = storage_item._get(:type)._get(:plain) || storage_item._get(:type)._get(:map)._get(:value)
-      decode_storage(data, type, modifier == 'Optional', fallback, registry)
-    end
+      # storage_item: the storage item from metadata
+      def decode_storage2(data, storage_item, registry)
+        modifier = storage_item._get(:modifier) # Default | Optional
+        fallback = storage_item._get(:fallback)
+        type = storage_item._get(:type)._get(:plain) || storage_item._get(:type)._get(:map)._get(:value)
+        decode_storage(data, type, modifier == 'Optional', fallback, registry)
+      end
 
-    def decode_storage3(data, pallet_name, item_name, metadata)
-      registry = Metadata.build_registry(metadata)
-      storage_item = Metadata.get_storage_item(pallet_name, item_name, metadata)
-      decode_storage2(data, storage_item, registry)
+      def decode_storage3(data, pallet_name, item_name, metadata)
+        registry = Metadata.build_registry(metadata)
+        storage_item = Metadata.get_storage_item(pallet_name, item_name, metadata)
+        decode_storage2(data, storage_item, registry)
+      end
     end
   end
 end