scale_rb 0.1.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 381954b869c210f582d6d119be4efe2b0f41ab4aa783793ee1a8b5b3ae3f37fc
-  data.tar.gz: 474b9ae37ee03d0112f63892a10b1a7965f73987ec03f28838dc3e050d5f29cd
+  metadata.gz: f83289d7a27bca72fe9e21e43f2b06ff29e191e47b9e1397cb96ea1adf6ee6c0
+  data.tar.gz: a1e77aaffcbc32aa795cb9cd57303f71a3fc1477c42e2540034d9060dc88a415
 SHA512:
-  metadata.gz: 50ee90afbb3f5a9b27676912608dfa8de48bac33e8e19f1e21ee5db8f2aa1cf4c21f95cfca27e3bc6220481312bb57254004a8f219f6b6d1be94b295c47ffd68
-  data.tar.gz: 7cdedc298adc696bb5a3df76c63710c13863a86d4c066f7a9fe2767bd349cb7f71ed4f26490faa3a77abb8022144102396b407f6ce02e9d8d10c8029f754a451
+  metadata.gz: 26a88e5148bd175700d992542ea490dfd97b298b24dd8a6955fa24e276c12a8018b914c9c2f321b59cce4d8be24ceda7674814a83495a6079bebef43f8407d7a
+  data.tar.gz: 74e818ab1e4d56caac4b78de0e15545b53e86361a5557fa72eae7e8310dec0b09a101590551e5b6d5b218d41c690e6eaea6221a84a93a14c904620724390aaf0

data/.gitignore

@@ -6,6 +6,7 @@
 /pkg/
 /spec/reports/
 /tmp/
+/.idea/
 
 # rspec failure tracking
 .rspec_status

data/Gemfile.lock

@@ -1,14 +1,14 @@
 PATH
   remote: .
   specs:
-    scale_rb (0.1.3)
-      blake2b_rs (~> 0.1.2)
+    scale_rb (0.1.5)
+      blake2b_rs (~> 0.1.4)
       xxhash
 
 GEM
   remote: https://rubygems.org/
   specs:
-    blake2b_rs (0.1.3)
+    blake2b_rs (0.1.4)
       ffi (~> 1.0)
       thermite (~> 0)
     diff-lcs (1.5.0)

data/README.md

@@ -2,6 +2,9 @@
 
 *WARNING: UNDER DEVELOPMENT*
 
+* Only support metadata v14.
+* Http & WebSocket client helper. No Client in this repo.
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/exe/metadata

@@ -6,7 +6,7 @@ require 'json'
 require 'optparse'
 
 def print_metadata(url, at = nil)
-  puts JSON.pretty_generate(Substrate::Client.get_metadata(url, at))
+  puts JSON.pretty_generate(HttpClient.get_metadata(url, at))
 end
 
 # ./bin/metadata http://g2.dev.darwinia.network:2234 -b 0x23ebddd6519aaf1b7fc916c3709af13d7a4010943fb53038406581171000a58e
@@ -31,10 +31,10 @@ else
       block_hash = @options[:block]
     else
       block_number = @options[:block].to_i
-      block_hash = Substrate::RPC.chain_getBlockHash url, block_number
+      block_hash = HttpClient.chain_getBlockHash url, block_number
     end
   else
-    block_hash = Substrate::RPC.chain_getBlockHash url
+    block_hash = HttpClient.chain_getBlockHash url
   end
 
   print_metadata url, block_hash

data/lib/client/abstract_ws_client.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+class AbstractWsClient
+  extend RpcRequestBuilder
+  attr_accessor :metadata, :registry
+
+  def initialize
+    @id = 0
+    @metadata = nil
+    @registry = nil
+    @callbacks = {}
+    @subscription_callbacks = {}
+  end
+
+  def send_json_rpc(_body)
+    raise 'WsClient is a abstract base class for websocket client, please use its sub-class'
+  end
+
+  # changes: [
+  #   [
+  #     "0x26aa394eea5630e07c48ae0c9558cef780d41e5e16056765bc8461851072c9d7", # storage key
+  #     "0x0400000000000000d887690900000000020000" # change
+  #   ]
+  # ]
+  def process(resp)
+    # handle id
+    @callbacks[resp['id']]&.call(resp['id'], resp) if resp['id']
+
+    # handle storage subscription
+    return unless resp['params'] && resp['params']['subscription']
+    return unless @metadata && @registry
+
+    subscription = resp['params']['subscription']
+    changes = resp['params']['result']['changes']
+    block = resp['params']['result']['block']
+    p "block: #{block}"
+
+    return unless @subscription_callbacks[subscription]
+
+    pallet_name, item_name, subscription_callback = @subscription_callbacks[subscription]
+    storage_item = Metadata.get_storage_item(pallet_name, item_name, @metadata)
+    storages = decode_storages(changes.map(&:last), storage_item, registry)
+    subscription_callback.call(storages)
+  end
+
+  def get_metadata(callback = nil)
+    if callback.nil?
+      callback = lambda do |id, resp|
+        return unless resp['id'] && resp['result']
+        return if resp['id'] != id
+
+        metadata_hex = resp['result']
+        metadata = Metadata.decode_metadata(metadata_hex.strip.to_bytes)
+        return unless metadata
+
+        @metadata = metadata
+        @registry = Metadata.build_registry(@metadata)
+      end
+    end
+
+    id = bind_id_to(callback)
+    body = state_getMetadata(id)
+    send_json_rpc(body)
+  end
+
+  def subscribe_storage(pallet_name, item_name, subscription_callback, key = nil, registry = nil)
+    callback = create_callback_for_subscribe_storage(pallet_name, item_name, subscription_callback)
+    id = bind_id_to(callback)
+    body = derived_state_subscribe_storage(id, pallet_name, item_name, key, registry)
+    send_json_rpc(body)
+  end
+
+  private
+
+  def bind_id_to(callback)
+    @callbacks[@id] = callback
+    old = @id
+    @id += 1
+    old
+  end
+
+  def decode_storages(datas, storage_item, registry)
+    datas.map do |data|
+      StorageHelper.decode_storage2(data, storage_item, registry)
+    end
+  end
+
+  def create_callback_for_subscribe_storage(pallet_name, item_name, subscription_callback)
+    lambda do |id, resp|
+      return unless resp['id'] && resp['result']
+      return if resp['id'] != id
+
+      @subscription_callbacks[resp['result']] = [
+        pallet_name,
+        item_name,
+        subscription_callback
+      ]
+    end
+  end
+end

data/lib/{substrate/client.rb → client/http_client.rb}

@@ -1,15 +1,49 @@
 # frozen_string_literal: true
 
-module Substrate
-  module Client
+require 'uri'
+require 'net/http'
+require 'json'
+
+module ScaleRb
+  module HttpClient
+    extend RpcRequestBuilder
+
     class << self
+      def request(url, body)
+        uri = URI(url)
+        req = Net::HTTP::Post.new(uri, 'Content-Type' => 'application/json')
+        req.body = body
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true if uri.instance_of? URI::HTTPS
+        res = http.request(req)
+        # puts res unless res.is_a?(Net::HTTPSuccess)
+
+        result = JSON.parse(res.body)
+        raise result['error'] if result['error']
+
+        result['result']
+      end
+
+      def json_rpc_call(url, method, *params)
+        body = build_json_rpc_body(method, params, Time.now.to_i)
+        request(url, body)
+      end
+
+      def respond_to_missing?(*_args)
+        true
+      end
+
+      def method_missing(method, *args)
+        json_rpc_call(args[0], method, *args[1..])
+      end
+
       def get_metadata(url, at = nil)
-        hex = Substrate::RPC.state_getMetadata(url, at)
+        hex = state_getMetadata(url, at)
         Metadata.decode_metadata(hex.strip.to_bytes)
       end
 
       def query_storage_at(url, storage_keys, type_id, default, registry, at = nil)
-        result = Substrate::RPC.state_queryStorageAt(url, storage_keys, at)
+        result = state_queryStorageAt(url, storage_keys, at)
         result.map do |item|
           item['changes'].map do |change|
             storage_key = change[0]
@@ -21,7 +55,7 @@ module Substrate
       end
 
       def get_storage_keys_by_partial_key(url, partial_storage_key, start_key = nil, at = nil)
-        storage_keys = Substrate::RPC.state_getKeysPaged(url, partial_storage_key, 1000, start_key, at)
+        storage_keys = state_getKeysPaged(url, partial_storage_key, 1000, start_key, at)
         if storage_keys.length == 1000
           storage_keys + get_storage_keys_by_partial_key(url, partial_storage_key, storage_keys.last, at)
         else
@@ -43,14 +77,6 @@ module Substrate
         end.flatten
       end
 
-      # type_id: result type id
-      def get_storage(url, storage_key, type_id, default, registry, at = nil)
-        data = Substrate::RPC.state_getStorage(url, storage_key, at) || default
-        return nil if data.nil?
-
-        PortableCodec.decode(type_id, data.to_bytes, registry)[0]
-      end
-
       # 1. Plain
       #   key:   nil
       #   value: { type: 3, modifier: 'Default', callback: '' }
@@ -78,7 +104,7 @@ module Substrate
       #   },
       #   ..
       #
-      def get_storage2(url, pallet_name, item_name, key, value, registry, at = nil)
+      def get_storage(url, pallet_name, item_name, key, value, registry, at = nil)
         # map, but no key's value provided. get all storages under the partial storage key
         if !key.nil? && key[:value].nil?
           partial_storage_key = StorageHelper.encode_storage_key(pallet_name, item_name).to_hex
@@ -91,20 +117,13 @@ module Substrate
             at
           )
         else
-          params = (StorageHelper.build_params(key[:value], key[:type], key[:hashers], registry) unless key.nil?)
-          storage_key = StorageHelper.encode_storage_key(pallet_name, item_name, params, registry).to_hex
-          get_storage(
-            url,
-            storage_key,
-            value[:type],
-            value[:modifier] == 'Default' ? value[:fallback] : nil,
-            registry,
-            at
-          )
+          storage_key = StorageHelper.encode_storage_key(pallet_name, item_name, key, registry).to_hex
+          data = state_getStorage(url, storage_key, at)
+          StorageHelper.decode_storage(data, value[:type], value[:modifier] == 'Optional', value[:fallback], registry)
         end
       end
 
-      def get_storage3(url, pallet_name, item_name, value_of_key, metadata, at = nil)
+      def get_storage2(url, pallet_name, item_name, value_of_key, metadata, at = nil)
         raise 'metadata should not be nil' if metadata.nil?
 
         registry = Metadata.build_registry(metadata)
@@ -116,6 +135,7 @@ module Substrate
 
         plain = type._get(:plain)
         map = type._get(:map)
+
         key, value =
           if plain
             [
@@ -130,8 +150,8 @@ module Substrate
           else
             raise 'NoSuchStorageType'
           end
-        get_storage2(url, pallet_name, item_name, key, value, registry, at)
+        get_storage(url, pallet_name, item_name, key, value, registry, at)
       end
     end
   end
-end
+end

data/lib/client/rpc_request_builder.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module RpcRequestBuilder
+  def build_json_rpc_body(method, params, id)
+    {
+      'id' => id,
+      'jsonrpc' => '2.0',
+      'method' => method,
+      'params' => params.reject(&:nil?)
+    }.to_json
+  end
+
+  def respond_to_missing?(*_args)
+    true
+  end
+
+  # example:
+  #   state_getStorage(1, '0x363a..', 563_868)
+  #
+  #   ==
+  #
+  #   build_json_rpc_body('state_getStorage', ['0x363a..', 563_868], 1)
+  def method_missing(method, *args)
+    build_json_rpc_body(method, args[1..], args[0])
+  end
+
+  ###################################
+  # derived functions
+  ###################################
+  def derived_state_get_storage(rpc_id, pallet_name, item_name, key = nil, registry = nil)
+    storage_key = StorageHelper.encode_storage_key(pallet_name, item_name, key, registry).to_hex
+    state_getStorage(rpc_id, [storage_key])
+  end
+
+  def derived_state_subscribe_storage(rpc_id, pallet_name, item_name, key = nil, registry = nil)
+    storage_key = StorageHelper.encode_storage_key(pallet_name, item_name, key, registry).to_hex
+    state_subscribeStorage(rpc_id, [storage_key])
+  end
+
+  def derived_eth_call(rpc_id, to, data, at = nil)
+    eth_call(
+      rpc_id,
+      [
+        {
+          'from' => nil, 'to' => to, 'data' => data
+        },
+        at
+      ]
+    )
+  end
+end

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)
+      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
+  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