scale_rb 0.5.0 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb19be98106d9f8331a9be9812f6252c23d6913cbd98cedcae34bf1a464e7b90
-  data.tar.gz: cff1e034d85f130ed7d149628647f020adb9ffc532d9646bceda054007d6bf14
+  metadata.gz: e8d513edcbe185b4b84fa7e7f9a89f9787e658e79a42aac9843d0d225f5f1ecd
+  data.tar.gz: 14ed9841bb41104aa9a064b45f3f170c77f4c8aeb1eddd015d4cc62587c8d0e6
 SHA512:
-  metadata.gz: de658214901aa13071c6b8d0c1aa94c8db0b2cee3c6c1df3207eb0881399c12215ce6c05a7d89c7da115e279a60fbe4688710e5f3fba827d5bd729afb7275e59
-  data.tar.gz: 999f5311c1a66933281798c40bbb3b7956e528b3164c264f2a7694fa48c142683e49ff47a185c1e174501b2e8c3b083d2bd513d1e6c37cffff9002d9186908e4
+  metadata.gz: 1488b38cb5b710b3f438508c14a6aff777d7374d12c25badbdf05ff8dd745ad64512b4e0dddbcc718a0e344aa518de50b95f9d0594a0e55f15981d7043f85672
+  data.tar.gz: 5ee07ecf3b77535a52944ee1f68fb49558f4a0b276727121e029c19e73faff2eb48be6598ea91b82aac0477075c4f76f8b962c9dddd9ecef3a2d1514ae041b24

data/examples/http_client_3.rb

@@ -0,0 +1,84 @@
+require 'scale_rb'
+
+client = ScaleRb::HttpClient.new('https://polkadot-rpc.dwellir.com')
+puts format('%20s: %s', 'supported_methods', client.supported_methods.join(', '))
+
+block_number = 22_931_689
+puts format('%20s: %d', 'block_number', block_number)
+
+block_hash = client.chain_getBlockHash(block_number)
+puts format('%20s: %s', 'block_hash', block_hash)
+
+runtime_version = client.state_getRuntimeVersion(block_hash)
+puts format('%20s: %s', 'spec_name', runtime_version[:specName])
+puts format('%20s: %s', 'spec_version', runtime_version[:specVersion])
+
+metadata = client.get_metadata(block_hash)
+
+######################################
+# Events
+######################################
+events = client.get_storage('System', 'Events', block_hash:, metadata:)
+events.each_with_index do |event, index|
+  puts format('%20s: %d', 'event index', index)
+  puts format('%20s: %s', 'event', event)
+end
+
+######################################
+# Validators
+######################################
+validators = client.get_storage('Session', 'Validators', block_hash:, metadata:)
+validators.each_with_index do |validator, index|
+  puts format('%20s: %d', 'validator index', index)
+  puts format('%20s: %s', 'validator', ScaleRb::Utils.u8a_to_hex(validator))
+end
+
+######################################
+# Block
+######################################
+blockResult = client.chain_getBlock(block_hash)
+
+block = blockResult[:block]
+justifications = blockResult[:justifications]
+puts format('%20s: %s', 'justifications', justifications)
+
+header = block[:header]
+
+parent_hash = header[:parentHash]
+puts format('%20s: %s', 'parent_hash', parent_hash)
+
+state_root = header[:stateRoot]
+puts format('%20s: %s', 'state_root', state_root)
+
+extrinsics_root = header[:extrinsicsRoot]
+puts format('%20s: %s', 'extrinsics_root', extrinsics_root)
+
+digest_logs = header[:digest][:logs]
+pre_runtime_log = nil
+digest_logs.each_with_index do |digest_log, index|
+  decoded, = ScaleRb::Codec.decode(
+    metadata.digest_item_type_id,
+    ScaleRb::Utils.hex_to_u8a(digest_log),
+    metadata.registry
+  )
+  puts format('%20s: %d', 'log index', index)
+  puts format('%20s: %s', 'log', decoded)
+
+  # check if decoded has a key of "PreRuntime"
+  pre_runtime_log = decoded[:PreRuntime] if decoded.key?(:PreRuntime)
+end
+
+engine = pre_runtime_log[0]
+puts format('%20s: %s', 'engine', ScaleRb::Utils.u8a_to_utf8(engine))
+data = pre_runtime_log[1] # if engine is BABE, data's type is sp_consensus_babe::digests::PreDigest
+authority_index, = ScaleRb::CodecUtils.decode_uint('U32', data[1..]) # we don't need to decode the data, but get the authority_index
+puts format('%20s: %d', 'authority_index', authority_index)
+author = validators[authority_index]
+puts format('%20s: %s', 'author', ScaleRb::Utils.u8a_to_hex(author))
+
+extrinsics = block[:extrinsics]
+extrinsics.each_with_index do |extrinsic, index|
+  puts format('%20s: %d', 'extrinsic index', index)
+  decoded = ScaleRb::ExtrinsicHelper.decode_extrinsic(ScaleRb::Utils.hex_to_u8a(extrinsic), metadata)
+  puts format('%20s: %s', 'extrinsic', decoded)
+end

data/exe/metadata

@@ -35,5 +35,5 @@ else
   end
 
   metadata = client.get_metadata(block_hash)
-  puts JSON.pretty_generate(metadata)
+  puts metadata.to_json
 end

data/lib/scale_rb/call_helper.rb

@@ -9,7 +9,7 @@ module ScaleRb
     #   "0x05000a1287977578f888bdc1c7627781af1cc000e6ab1300004c31b8d9a798"._to_bytes
     def self.decode_call(callbytes, metadata)
       pallet_index = callbytes[0]
-      pallet = Metadata.get_module_by_index(pallet_index, metadata)
+      pallet = metadata.pallet_by_index(pallet_index)
 
       # Remove the pallet_index
       # The callbytes we used below should not contain the pallet index.
@@ -20,7 +20,7 @@ module ScaleRb
       decoded = Codec.decode(
         calls_type_id,
         callbytes_without_pallet_index,
-        Metadata.build_registry(metadata)
+        metadata.build_registry
       )&.first
 
       {
@@ -34,9 +34,9 @@ module ScaleRb
     #   {: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 self.encode_call(call, metadata)
-      calls_type_id = Metadata.get_calls_type_id(call[:pallet_name], metadata)
-      pallet_index = Metadata.get_module(call[:pallet_name], metadata)._get(:index)
-      [pallet_index] + Codec.encode(calls_type_id, call[:call], Metadata.build_registry(metadata))
+      calls_type_id = metadata.calls_type_id(call[:pallet_name])
+      pallet_index = metadata.pallet(call[:pallet_name])[:index]
+      [pallet_index] + Codec.encode(calls_type_id, call[:call], metadata.build_registry)
     end
   end
 end

data/lib/scale_rb/client/{client_ext.rb → client_share.rb}

@@ -1,11 +1,11 @@
 module ScaleRb
   # This module is used to add extra methods to both the ScaleRb::WsClient ScaleRb::HttpClient
-  module ClientExt
+  module ClientShare
     # get decoded metadata at block_hash
     def get_metadata(block_hash = nil)
       block_hash ||= chain_getHead
       metadata_hex = state_getMetadata(block_hash)
-      Metadata.decode_metadata(metadata_hex)
+      Metadata::Metadata.from_hex(metadata_hex)
     end
 
     # Get decoded storage at block_hash
@@ -30,6 +30,14 @@ module ScaleRb
       )
     end
 
+    def respond_to_missing?(*_args)
+      true
+    end
+
+    def method_missing(method, *args)
+      request(method.to_s, args)
+    end
+
     private
 
     def query_storage_at(block_hash, storage_keys, type_id, default, registry)
@@ -134,10 +142,8 @@ module ScaleRb
     def get_storage2(block_hash, pallet_name, item_name, params, metadata)
       raise 'Metadata should not be nil' if metadata.nil?
 
-      registry = Metadata.build_registry(metadata)
-      item = Metadata.get_storage_item(
-        pallet_name, item_name, metadata
-      )
+      registry = metadata.registry
+      item = metadata.storage(pallet_name, item_name)
       raise "No such storage item: `#{pallet_name}`.`#{item_name}`" if item.nil?
 
       modifier = item._get(:modifier) # Default | Optional

data/lib/scale_rb/client/http_client.rb

@@ -4,11 +4,11 @@ require 'uri'
 require 'net/http'
 require 'json'
 
-require_relative 'client_ext'
+require_relative 'client_share'
 
 module ScaleRb
   class HttpClient
-    include ClientExt
+    include ClientShare
     attr_accessor :supported_methods
 
     def initialize(url)

data/lib/scale_rb/client/ws_client.rb

@@ -2,7 +2,7 @@ require 'async'
 require 'async/websocket/client'
 require 'async/http/endpoint'
 
-require_relative 'client_ext'
+require_relative 'client_share'
 
 module ScaleRb
   class WsClient
@@ -52,7 +52,7 @@ end
 
 module ScaleRb
   class WsClient
-    include ClientExt
+    include ClientShare
     attr_accessor :supported_methods
 
     def initialize(connection)

data/lib/scale_rb/decode.rb

@@ -19,6 +19,7 @@ module ScaleRb
       when CompactType then decode_compact(bytes)
       when ArrayType then decode_array(type, bytes, registry)
       when SequenceType then decode_sequence(type, bytes, registry)
+      when BitSequenceType then decode_bit_sequence(type, bytes)
       when TupleType then decode_tuple(type, bytes, registry)
       when StructType then decode_struct(type, bytes, registry)
       when UnitType then [[], bytes]
@@ -65,6 +66,22 @@ module ScaleRb
       _decode_types([sequence_type.type] * len, remaining_bytes, registry)
     end
 
+    __ :decode_bit_sequence, { sequence_type: BitSequenceType, bytes: U8Array }, DecodeResult[TypedArray[Any]]
+    def decode_bit_sequence(sequence_type, bytes)
+      ScaleRb.logger.debug("Decoding bit sequence: #{sequence_type}, bytes: #{bytes.length} bytes")
+
+      bit_len, remaining_bytes = decode_compact(bytes)
+      byte_len = (bit_len / 8.0).ceil
+      the_bytes, remaining_bytes = [remaining_bytes[0...byte_len], remaining_bytes[byte_len..]]
+      [
+        {
+          bytes: the_bytes,
+          bit_len: bit_len
+        },
+        remaining_bytes
+      ]
+    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")

data/lib/scale_rb/extrinsic_helper.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module ScaleRb
+  module ExtrinsicHelper
+    class << self
+      def decode_extrinsic(bytes, metadata)
+        extrinsic_hash = "0x#{Blake2b.hex(bytes, 32)}"
+
+        _, remaining_bytes = ScaleRb::Codec.decode_compact(bytes)
+        meta, remaining_bytes = [remaining_bytes[0], remaining_bytes[1..]]
+        signed = (meta & 0x80) == 0x80
+        version = (meta & 0x7f)
+
+        raise "Unsupported version: #{version}" unless version == 4
+
+        if signed
+          # puts "signed"
+          signature, remaining_bytes = ScaleRb::Codec.decode(
+            metadata.signature_type_id, 
+            remaining_bytes, 
+            metadata.registry
+          )
+          call, = ScaleRb::Codec.decode(
+            metadata.runtime_call_type_id, 
+            remaining_bytes, 
+            metadata.registry
+          )
+          {
+            version: 4,
+            signature: signature,
+            call: call,
+            extrinsic_hash: extrinsic_hash
+          }
+        else
+          # puts "unsigned"
+          call, = ScaleRb::Codec.decode(
+            metadata.runtime_call_type_id, 
+            remaining_bytes, 
+            metadata.registry
+          )
+          {
+            version: 4,
+            call: call,
+            extrinsic_hash: extrinsic_hash
+          }
+        end
+      end
+    end
+  end
+end

data/lib/scale_rb/metadata/metadata.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative './registry'
-
 require_relative './metadata_v9'
 require_relative './metadata_v10'
 require_relative './metadata_v11'
@@ -13,95 +11,245 @@ require_relative './metadata_v14'
 # 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)
+    class Metadata
+      attr_reader :magic_number, :version, :metadata, :registry, :address_type_id, :runtime_call_type_id, :digest_type_id,
+                  :digest_item_type_id, :event_record_list_type_id, :event_record_type_id, :event_type_id, :signature_type_id
+
+      # Runtime type ids
+      attr_reader :unchecked_extrinsic_type_id
+
+      def initialize(metadata_prefixed, unchecked_extrinsic_type_id = nil)
+        @metadata_prefixed = metadata_prefixed
+        @magic_number = @metadata_prefixed[:magicNumber]
+        metadata = @metadata_prefixed[:metadata]
+        @version = metadata.keys.first
+        raise "Unsupported metadata version: #{@version}" unless :V14 == @version
+
+        @metadata = metadata[@version]
+        @registry = ScaleRb::PortableRegistry.new(@metadata.dig(:lookup, :types))
+
+        # Runtime type ids
+        @unchecked_extrinsic_type_id = unchecked_extrinsic_type_id || find_unchecked_extrinsic_type_id
+        @address_type_id = find_address_type_id
+        @runtime_call_type_id = find_runtime_call_type_id
+
+        @digest_type_id = find_digest_type_id
+        @digest_item_type_id = find_digest_item_type_id
+
+        @event_record_list_type_id = find_event_record_list_type_id
+        @event_record_type_id = find_event_record_type_id
+        @event_type_id = find_event_type_id
+
+        @signature_type_id = build_signature_type_id
+      end
+
+      def self.from_hex(hex)
+        metadata_prefixed, = ScaleRb::Codec.decode('MetadataPrefixed', Utils.hex_to_u8a(hex), OldRegistry.new(TYPES))
+        Metadata.new(metadata_prefixed)
+      end
+
+      def self.from_json(str)
+        metadata_prefixed = JSON.parse(str, symbolize_names: true)
+        Metadata.new(metadata_prefixed)
+      end
+
+      def to_json(*_args)
+        JSON.pretty_generate(@metadata_prefixed)
+      end
+
+      def pallet(pallet_name)
+        @metadata[:pallets].find do |pallet|
+          pallet[:name] == pallet_name
+        end
+      end
+
+      def pallet_by_index(pallet_index)
+        @metadata[:pallets].find do |pallet|
+          pallet[:index] == pallet_index
+        end
+      end
+
+      def storage(pallet_name, item_name)
+        pallet = pallet(pallet_name)
+        raise "Pallet `#{pallet_name}` not found" if pallet.nil?
+
+        pallet.dig(:storage, :items).find do |item|
+          item[:name] == item_name
+        end
+      end
 
-        registry = ScaleRb::Metadata::Registry.new TYPES
-        ti = registry.use('MetadataPrefixed')
-        metadata, = ScaleRb::Codec.decode(ti, bytes, registry)
-        metadata
+      def error(pallet_index, error_index)
+        pallet = pallet_by_index(pallet_index)
+        raise "Pallet `#{pallet_index}` not found" if pallet.nil?
+
+        errors_type_id = pallet.dig(:errors, :type)
+        errors_type = @registry[errors_type_id]
+        error_variant = errors_type.variants.find do |variant|
+          variant.index == error_index
+        end
+        raise "Error `#{error_index}` not found" if errors_type.nil?
+
+        [
+          pallet[:name], error_variant.name.to_s
+        ]
+      end
+
+      #########################################################################
+
+      # % pallet_call_type :: [String, String] -> SimpleVariant | TupleVariant | StructVariant
+      def pallet_call_type(pallet_name, call_name)
+        calls_type_id = pallet_calls_type_id(pallet_name)
+
+        calls_type = @registry[calls_type_id] # #<ScaleRb::Types::VariantType ...>
+        raise 'Calls type is not correct' if calls_type.nil?
+
+        calls_type.variants.find do |variant|
+          variant.name.to_s.downcase == call_name.downcase
+        end
+      end
+
+      def pallet_call_names(pallet_name)
+        calls_type_id = pallet_calls_type_id(pallet_name)
+        return [] if calls_type_id.nil?
+
+        calls_type = @registry[calls_type_id] # #<ScaleRb::Types::VariantType ...>
+        raise 'Calls type is not correct' if calls_type.nil?
+
+        calls_type.variants.map do |variant|
+          variant.name.to_s
+        end
       end
 
-      def build_registry(metadata_prefixed)
-        types = ScaleRb::Utils.get(metadata_prefixed, :metadata, :V14, :lookup, :types)
-        ScaleRb::PortableRegistry.new(types)
+      private
+
+      def find_unchecked_extrinsic_type_id
+        @registry.types.each_with_index do |type, index|
+          return index if type.path.first == 'sp_runtime' && type.path.last == 'UncheckedExtrinsic'
+        end
       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)
+      def find_address_type_id
+        @registry[@unchecked_extrinsic_type_id].params.find do |param|
+          param.name.downcase == 'address'
+        end.type
+      end
 
-        Metadata.const_get("Metadata#{version.upcase}").get_module(pallet_name, metadata_prefixed)
+      def find_runtime_call_type_id
+        @registry[@unchecked_extrinsic_type_id].params.find do |param|
+          param.name.downcase == 'call'
+        end.type
       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)
+      def find_extrinsic_signature_type_id
+        @registry[@unchecked_extrinsic_type_id].params.find do |param|
+          param.name.downcase == 'signature'
+        end.type
+      end
 
-        Metadata.const_get("Metadata#{version.upcase}").get_module_by_index(pallet_index, metadata_prefixed)
+      def find_digest_type_id
+        storage_item = storage('System', 'Digest')
+        storage_item.dig(:type, :plain)
       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)
+      def find_digest_item_type_id
+        # #<ScaleRb::Types::StructType registry=a_portable_registry path=["sp_runtime", "generic", "digest", "Digest"] params=[] fields=[#<ScaleRb::Types::Field name="logs" type=14>]>
+        digest_type = @registry[@digest_type_id]
+
+        field = digest_type.fields.find do |field|
+          field.name == 'logs'
+        end
+        seq = @registry[field.type]
+        raise 'Type is not correct' unless seq.is_a?(ScaleRb::Types::SequenceType)
+
+        seq.type
+      end
 
-        Metadata.const_get("Metadata#{version.upcase}").get_storage_item(pallet_name, item_name, metadata_prefixed)
+      def find_event_record_list_type_id
+        storage_item = storage('System', 'Events')
+        storage_item.dig(:type, :plain)
       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)
+      def find_event_record_type_id
+        seq = @registry[@event_record_list_type_id]
+        raise 'Type is not correct' unless seq.is_a?(ScaleRb::Types::SequenceType)
 
-        Metadata.const_get("Metadata#{version.upcase}").get_calls_type(pallet_name, metadata_prefixed)
+        seq.type
       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)
+      def find_event_type_id
+        @registry[@event_record_type_id].fields.find do |field|
+          field.name == 'event'
+        end.type
+      end
+
+      def build_signature_type_id
+        signed_extensions_type = ScaleRb::Types::StructType.new(
+          path: ['SignedExtensions'],
+          fields: @metadata[:extrinsic][:signedExtensions].map do |signed_extension|
+            ScaleRb::Types::Field.new(
+              name: signed_extension[:identifier],
+              type: signed_extension[:type]
+            )
+          end,
+          registry: @registry
+        )
+
+        signed_extensions_type_id = @registry.add_type(signed_extensions_type)
 
-        Metadata.const_get("Metadata#{version.upcase}").get_calls_type_id(pallet_name, metadata_prefixed)
+        signature_type = ScaleRb::Types::StructType.new(
+          path: ['ExtrinsicSignature'],
+          fields: [
+            ScaleRb::Types::Field.new(name: 'address', type: @address_type_id),
+            ScaleRb::Types::Field.new(name: 'signature', type: find_extrinsic_signature_type_id),
+            ScaleRb::Types::Field.new(name: 'signedExtensions', type: signed_extensions_type_id)
+          ],
+          registry: @registry
+        )
+
+        @registry.add_type(signature_type)
       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)
+      # equals to:
+      #  pallet = pallet(pallet_name)
+      #  raise "Pallet `#{pallet_name}` not found" if pallet.nil?
+      #  pallet.dig(:calls, :type)
+      def pallet_calls_type_id(pallet_name)
+        runtime_call_type = @registry[@runtime_call_type_id]
+        v = runtime_call_type.variants.find do |variant|
+          variant.name.to_s.downcase == pallet_name.downcase
+        end
 
-        Metadata.const_get("Metadata#{version.upcase}").get_call_type(pallet_name, call_name, metadata_prefixed)
+        v&.tuple&.tuple&.first
       end
     end
 
+    #########################################################################
+
     TYPES = {
-      Type: 'Str',
-      Bytes: 'Vec<u8>',
-      MetadataPrefixed: {
-        magicNumber: 'U32',
-        metadata: 'Metadata'
+      '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'
+      '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)