scale_rb 0.1.3 → 0.1.5

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,8 +106,10 @@ 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]
+    else
+      self[key]
     end
   end
 end

data/lib/portable_codec.rb

@@ -81,37 +81,41 @@ module PortableCodec
     def decode_composite(composite_type, bytes, registry)
       fields = composite_type._get(:fields)
 
-      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
-      ]
+      # 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
 
     def decode_variant(variant_type, bytes, registry)
       variants = variant_type._get(:variants)
 
       index = bytes[0]
-      if index > (variants.length - 1)
-        raise VariantIndexOutOfRange,
-              "type: #{variant_type}, index: #{index}, bytes: #{bytes}"
-      end
+      item = variants.find { |v| v._get(:index) == index } # item is an composite
 
-      item_variant = variants.find { |v| v._get(:index) == index }
-      item_name = item_variant._get(:name)
-      item, remaining_bytes = decode_composite(item_variant, bytes[1..], registry)
+      raise VariantIndexOutOfRange, "type: #{variant_type}, index: #{index}, bytes: #{bytes}" if item.nil?
 
-      [
-        item.empty? ? item_name : { item_name.to_sym => item },
-        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
 
     def _decode_types(ids, bytes, registry = {})
@@ -181,18 +185,23 @@ module PortableCodec
     #   or
     #   [value1, value2, ...]
     def encode_composite(composite_type, value, registry)
-      values =
-        if value.instance_of?(Hash)
-          value.values
-        elsif value.instance_of?(Array)
-          value
-        else
-          raise CompositeInvalidValue, "value: #{value}, only hash and array"
-        end
-
       fields = composite_type._get(:fields)
-      type_id_list = fields.map { |f| f._get(:type) }
-      _encode_types(type_id_list, values, registry)
+      # reduce composite level when composite only has one field without name
+      if fields.length == 1 && fields.first._get(:name).nil?
+        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:
@@ -213,11 +222,11 @@ module PortableCodec
           raise VariantInvalidValue, "type: #{variant_type}, value: #{value}"
         end
 
-      variant = variants.find { |var| var._get(:name) == name }
-      raise VariantItemNotFound, "type: #{variant_type}, name: #{name}" if variant.nil?
-      raise VariantInvalidValue, "type: #{variant_type}, v: #{v}" if variant._get(:fields).length != v.length
+      item = variants.find { |var| var._get(:name) == name }
+      raise VariantItemNotFound, "type: #{variant_type}, name: #{name}" if item.nil?
+      raise VariantInvalidValue, "type: #{variant_type}, v: #{v}" if item._get(:fields).length != v.length
 
-      ScaleRb.encode_uint('u8', variant._get(:index)) + encode_composite(variant, v, registry)
+      ScaleRb.encode_uint('u8', item._get(:index)) + encode_composite(item, v, registry)
     end
 
     def _encode_types(ids, values, registry)

data/lib/scale_rb/version.rb

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

data/lib/scale_rb.rb

@@ -9,15 +9,21 @@ 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'
 
 # client
-require 'substrate/rpc'
-require 'substrate/client'
+require 'client/rpc_request_builder'
+require 'client/http_client'
+require 'client/abstract_ws_client'
 
 # get registry from config
 require 'registry'

data/lib/storage_helper.rb

@@ -2,37 +2,56 @@
 
 module StorageHelper
   class << self
-    # params:
-    #   pallet_name: module name
-    #   method_name: storage name
-    #   params: {
-    #     values: values,
-    #     type_ids: type_ids,
-    #     hashers: hashers,
-    #   }
-    #   registry: portable_types_registry
-    def encode_storage_key(pallet_name, method_name, params = nil, registry = nil)
-      pallet_method_key = Hasher.twox128(pallet_name) + Hasher.twox128(method_name)
+    # 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 params.nil?
-        pallet_method_key
-      else
-        values = params[:values]
-        type_ids = params[:type_ids]
-        hashers = params[:hashers]
+      if key && registry
+
+        types, values =
+          if key[:hashers].length == 1
+            [
+              [key[:type]],
+              [key[:value]]
+            ]
+          else
+            [
+              registry[key[:type]]._get(:def)._get(:tuple),
+              key[:value]
+            ]
+          end
 
-        pallet_method_key + PortableCodec._encode_types_with_hashers(type_ids, values, registry, hashers)
+        storage_key + PortableCodec._encode_types_with_hashers(types, values, registry, key[:hashers])
+      else
+        storage_key
       end
     end
 
-    def build_params(param_values, storage_key_type_id, hashers, registry)
-      type_ids = registry._get(storage_key_type_id)._get(:def)._get(:tuple)
-      type_ids = [storage_key_type_id] if type_ids.nil?
-      {
-        values: param_values,
-        type_ids: type_ids,
-        hashers: hashers
-      }
+    # data: hex string
+    # type: portable type id
+    # optional: boolean
+    # fallback: hex string
+    def decode_storage(data, type, optional, fallback, registry)
+      data ||= (optional ? nil : fallback)
+      PortableCodec.decode(type, data.to_bytes, registry)[0]
+    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)
     end
   end
 end

data/scale_rb.gemspec

@@ -26,6 +26,6 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   # for hashers
-  spec.add_dependency 'blake2b_rs', '~> 0.1.2'
+  spec.add_dependency 'blake2b_rs', '~> 0.1.4'
   spec.add_dependency 'xxhash'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scale_rb
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.5
 platform: ruby
 authors:
 - Aki Wu
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-10-13 00:00:00.000000000 Z
+date: 2023-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: blake2b_rs
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.2
+        version: 0.1.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.2
+        version: 0.1.4
 - !ruby/object:Gem::Dependency
   name: xxhash
   requirement: !ruby/object:Gem::Requirement
@@ -59,18 +59,24 @@ files:
 - bin/console
 - bin/setup
 - exe/metadata
+- lib/client/abstract_ws_client.rb
+- lib/client/http_client.rb
+- lib/client/rpc_request_builder.rb
 - 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
 - lib/scale_rb.rb
 - lib/scale_rb/version.rb
 - lib/storage_helper.rb
-- lib/substrate/client.rb
-- lib/substrate/rpc.rb
 - scale_rb.gemspec
 homepage: https://github.com/wuminzhe/scale_rb
 licenses:
@@ -93,7 +99,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: New Ruby SCALE Codec Library