scale_rb 0.1.3 → 0.1.5

data/lib/metadata.rb

@@ -1,199 +0,0 @@
-# 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)
-      raise ScaleRb::NotImplemented, metadata._get(:metadata).keys.first unless metadata._get(:metadata)._key?(:v14)
-
-      metadata_v14 = metadata._get(:metadata)._get(:v14)
-      MetadataV14.get_storage_item(pallet_name, item_name, metadata_v14)
-    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'
-      }
-    },
-
-    '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

data/lib/metadata_v14.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-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_storage_item(pallet_name, item_name, metadata)
-      pallet =
-        metadata._get(:pallets).find do |p|
-          p._get(:name) == pallet_name
-        end
-
-      pallet._get(:storage)._get(:items).find do |item|
-        item._get(:name) == item_name
-      end
-    end
-  end
-end

data/lib/substrate/rpc.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-require 'uri'
-require 'net/http'
-require 'json'
-
-module Substrate
-  module RPC
-    class << self
-      def json_rpc_call(method, params, url)
-        uri = URI(url)
-        req = Net::HTTP::Post.new(uri, 'Content-Type' => 'application/json')
-        req.body = {
-          'id' => 1,
-          'jsonrpc' => '2.0',
-          'method' => method,
-          'params' => params.reject(&:nil?)
-        }.to_json
-        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 chain_getBlockHash(url, block_number = nil)
-        json_rpc_call('chain_getBlockHash', [block_number], url)
-      end
-
-      def chain_getBlock(url, at = nil)
-        json_rpc_call('chain_getBlock', [at], url)
-      end
-
-      def state_getRuntimeVersion(url, at = nil)
-        json_rpc_call('state_getRuntimeVersion', [at], url)
-      end
-
-      def state_getMetadata(url, at = nil)
-        json_rpc_call('state_getMetadata', [at], url)
-      end
-
-      def state_getStorage(url, key, at = nil)
-        json_rpc_call('state_getStorage', [key, at], url)
-      end
-
-      def state_queryStorageAt(url, keys, at = nil)
-        json_rpc_call('state_queryStorageAt', [keys, at], url)
-      end
-
-      def state_getKeysPaged(url, key, count, start_key = nil, at = nil)
-        json_rpc_call('state_getKeysPaged', [key, count, start_key, at], url)
-      end
-
-      def eth_call(url, to, data, at_block_number = nil)
-        json_rpc_call('eth_call', [
-                        {
-                          'from' => nil,
-                          'to' => to,
-                          'data' => data
-                        },
-                        at_block_number
-                      ], url)
-      end
-    end
-  end
-end