scale.rb 0.2.12 → 0.2.17

data/Cargo.toml

@@ -2,10 +2,17 @@
 name = "SCALE-testing-interface"
 version = "0.1.0"
 authors = ["Robert Hambrock <robert@web3.foundation>"]
+edition = "2018"
 
 [dependencies]
-parity-scale-codec = { version = "1.2.0" }
+parity-scale-codec = { version = "1.3.6" }
+sp-core = { version = "2.0.0", git = "https://github.com/paritytech/substrate.git", features = ["full_crypto"]}
+frame-support = { version = "2.0.0", git = "https://github.com/paritytech/substrate.git" }
 
 [lib]
 name = "scale_ffi"
-crate-type = ["dylib"]
+crate-type = ["dylib"]
+
+[[bin]]
+name = "storage_key"
+path = "src/storage_key.rs"

data/Gemfile.lock

@@ -1,32 +1,30 @@
 PATH
   remote: .
   specs:
-    scale.rb (0.2.12)
-      activesupport (>= 4.0.0)
+    scale.rb (0.2.17)
+      base58
+      blake2b_rs (~> 0.1.2)
+      faye-websocket
       json (~> 2.3.0)
-      substrate_common.rb (~> 0.1.9)
-      thor (~> 0.19.0)
+      xxhash
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (6.0.3.4)
-      concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (>= 0.7, < 2)
-      minitest (~> 5.1)
-      tzinfo (~> 1.1)
-      zeitwerk (~> 2.2, >= 2.2.2)
     base58 (0.2.3)
-    blake2b (0.10.0)
+    blake2b_rs (0.1.2)
+      ffi (= 1.15.0)
+      thermite (~> 0)
     coderay (1.1.2)
-    concurrent-ruby (1.1.7)
     diff-lcs (1.3)
-    ffi (1.12.2)
-    i18n (1.8.5)
-      concurrent-ruby (~> 1.0)
+    eventmachine (1.2.7)
+    faye-websocket (0.11.0)
+      eventmachine (>= 0.12.0)
+      websocket-driver (>= 0.5.1)
+    ffi (1.15.0)
     json (2.3.1)
     method_source (0.9.2)
-    minitest (5.14.2)
+    minitar (0.9)
     pry (0.12.2)
       coderay (~> 1.1.0)
       method_source (~> 0.9.0)
@@ -44,27 +42,26 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.9.0)
     rspec-support (3.9.0)
-    substrate_common.rb (0.1.9)
-      base58
-      blake2b
-      xxhash
-    thor (0.19.4)
-    thread_safe (0.3.6)
-    tzinfo (1.2.7)
-      thread_safe (~> 0.1)
+    thermite (0.13.0)
+      minitar (~> 0.5)
+      rake (>= 10)
+      tomlrb (~> 1.2)
+    tomlrb (1.3.0)
+    websocket-driver (0.7.3)
+      websocket-extensions (>= 0.1.0)
+    websocket-extensions (0.1.5)
     xxhash (0.4.0)
-    zeitwerk (2.4.1)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  bundler (~> 1.17)
-  ffi (~> 1.12)
+  bundler
+  ffi (~> 1.15.0)
   pry
   rake (~> 13.0)
   rspec (~> 3.2)
   scale.rb!
 
 BUNDLED WITH
-   1.17.3
+   2.2.13

data/README.md

@@ -19,7 +19,7 @@ Because the feature of ruby 2.6 is used, the ruby version is required to be >= 2
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'scale.rb'
+gem 'scale.rb', '0.2.16'
 ```
 
 And then execute:

data/lib/address.rb

@@ -0,0 +1,3 @@
+require 'blake2b'
+require 'base58'
+

data/lib/common.rb

@@ -0,0 +1,163 @@
+require 'xxhash'
+require 'blake2b'
+require 'base58'
+
+class Array
+  def bytes_to_hex
+    raise "Not a byte array" unless self.is_byte_array?
+    '0x' + self.map { |b| b.to_s(16).rjust(2, '0') }.join
+  end
+
+  def bytes_to_bin
+    raise "Not a byte array" unless self.is_byte_array?
+    '0b' + self.map { |b| b.to_s(2).rjust(8, '0') }.join
+  end
+
+  def bytes_to_bin
+    raise "Not a byte array" unless self.is_byte_array?
+    self.map { |b| b.to_s(2).rjust(8, '0') }
+  end
+
+  def bytes_to_utf8
+    raise "Not a byte array" unless self.is_byte_array?
+    self.pack('C*').force_encoding('utf-8')
+  end
+
+  def is_byte_array?
+    self.all? {|e| e >= 0 and e <= 255 }
+  end
+end
+
+class String
+  def constantize2
+    Object.const_get(self)
+  end
+
+  def hex_to_bytes
+    data = self.start_with?('0x') ? self[2..] : self
+    raise "Not valid hex string" if data.length % 2 != 0
+    data.scan(/../).map(&:hex)
+  end
+end
+
+module Crypto
+  def self.identity(bytes)
+    bytes.bytes_to_hex[2..]
+  end
+
+  def self.twox64(data)
+    result = XXhash.xxh64 data, 0
+    bytes = result.to_s(16).rjust(16, '0').hex_to_bytes.reverse
+    bytes.bytes_to_hex[2..]
+  end
+
+  def self.twox128(data)
+    bytes = []
+    2.times do |i|
+      result = XXhash.xxh64 data, i
+      bytes = bytes + result.to_s(16).rjust(16, '0').hex_to_bytes.reverse
+    end
+    bytes.bytes_to_hex[2..]
+  end
+
+  def self.twox64_concat(bytes)
+    data = bytes.bytes_to_utf8
+    twox64(data) + bytes.bytes_to_hex[2..]
+  end
+
+  def self.blake2_128(bytes)
+    Blake2b.hex bytes, 16
+  end
+
+  def self.blake2_256(bytes)
+    Blake2b.hex bytes, 32
+  end
+
+  def self.blake2_128_concat(bytes)
+    blake2_128(bytes) + bytes.bytes_to_hex[2..]
+  end
+end
+
+class Address
+  SS58_PREFIX = 'SS58PRE'
+
+  TYPES = [
+    # Polkadot Live (SS58, AccountId)
+    0, 1,
+    # Polkadot Canary (SS58, AccountId)
+    2, 3,
+    # Kulupu (SS58, Reserved)
+    16, 17,
+    # Darwinia Live
+    18,
+    # Dothereum (SS58, AccountId)
+    20, 21, 
+    # Generic Substrate wildcard (SS58, AccountId)
+    42, 43,
+
+    # Schnorr/Ristretto 25519 ("S/R 25519") key
+    48,
+    # Edwards Ed25519 key
+    49,
+    # ECDSA SECP256k1 key
+    50,
+
+    # Reserved for future address format extensions.
+    *64..255
+  ]
+
+  class << self
+
+    def array_to_hex_string(arr)
+      body = arr.map { |i| i.to_s(16).rjust(2, '0') }.join
+      "0x#{body}"
+    end
+
+    def decode(address, addr_type = 42, ignore_checksum = true)
+      decoded = Base58.base58_to_binary(address, :bitcoin)
+      is_pubkey = decoded.size == 35
+
+      size = decoded.size - ( is_pubkey ? 2 : 1 )
+
+      prefix = decoded[0, 1].unpack("C*").first
+
+      raise "Invalid address type" unless TYPES.include?(addr_type)
+      
+      hash_bytes = make_hash(decoded[0, size])
+      if is_pubkey
+        is_valid_checksum = decoded[-2].unpack("C*").first == hash_bytes[0] && decoded[-1].unpack("C*").first == hash_bytes[1]
+      else
+        is_valid_checksum = decoded[-1].unpack("C*").first == hash_bytes[0]
+      end
+
+      raise "Invalid decoded address checksum" unless is_valid_checksum && ignore_checksum
+
+      decoded[1...size].unpack("H*").first
+    end
+
+
+    def encode(pubkey, addr_type = 42)
+      pubkey = pubkey[2..-1] if pubkey =~ /^0x/i
+      key = [pubkey].pack("H*")
+
+      u8_array = key.bytes
+
+      u8_array.unshift(addr_type)
+
+      bytes = make_hash(u8_array.pack("C*"))
+      
+      checksum = bytes[0, key.size == 32 ? 2 : 1]
+
+      u8_array.push(*checksum)
+
+      input = u8_array.pack("C*")
+
+      Base58.binary_to_base58(input, :bitcoin)
+    end
+
+    def make_hash(body)
+      Blake2b.bytes("#{SS58_PREFIX}#{body}", Blake2b::Key.none, 64)
+    end
+
+  end
+end

data/lib/helper.rb

@@ -0,0 +1,128 @@
+
+class SubstrateClient::Helper
+  class << self
+    def generate_storage_key_from_metadata(metadata, module_name, storage_name, params = nil)
+      # find the storage item from metadata
+      metadata_modules = metadata.value.value[:metadata][:modules]
+      metadata_module = metadata_modules.detect { |mm| mm[:name] == module_name }
+      raise "Module '#{module_name}' not exist" unless metadata_module
+      storage_item = metadata_module[:storage][:items].detect { |item| item[:name] == storage_name }
+      raise "Storage item '#{storage_name}' not exist. \n#{metadata_module.inspect}" unless storage_item
+
+      if storage_item[:type][:Plain]
+        return_type = storage_item[:type][:Plain]
+      elsif map = storage_item[:type][:Map]
+        raise "Storage call of type \"Map\" requires 1 parameter" if params.nil? || params.length != 1
+
+        hasher = map[:hasher]
+        return_type = map[:value]
+        # TODO: decode to account id if param is address
+        # params[0] = decode(params[0]) if map[:key] == "AccountId"
+        type = Scale::Types.get(map[:key])
+        params[0] = type.new(params[0]).encode
+      elsif map = storage_item[:type][:DoubleMap]
+        raise "Storage call of type \"DoubleMapType\" requires 2 parameters" if params.nil? || params.length != 2
+
+        hasher = map[:hasher]
+        hasher2 = map[:key2Hasher]
+        return_type = map[:value]
+        params[0] = Scale::Types.get(map[:key1]).new(params[0]).encode
+        params[1] = Scale::Types.get(map[:key2]).new(params[1]).encode
+      else
+        raise NotImplementedError
+      end
+
+      storage_prefix = metadata_module[:storage][:prefix]
+      storage_key = generate_storage_key(
+        storage_prefix.nil? ? module_name : storage_prefix,
+        storage_name,
+        params,
+        hasher,
+        hasher2,
+        metadata.value.value[:metadata][:version]
+      )
+      [storage_key, return_type]
+    end
+
+    def generate_storage_key(module_name, storage_name, params = nil, hasher = nil, hasher2 = nil, metadata_version = nil)
+      metadata_version = 12 if metadata_version.nil?
+      if metadata_version and metadata_version >= 9
+        storage_key = Crypto.twox128(module_name) + Crypto.twox128(storage_name)
+
+        params&.each_with_index do |param, index|
+          if index == 0
+            param_hasher = hasher
+          elsif index == 1
+            param_hasher = hasher2
+          else
+            raise "Unexpected third parameter for storage call"
+          end
+
+          param_key = if param.class == String && param.start_with?("0x")
+            param.hex_to_bytes
+          else
+            param.encode().hex_to_bytes
+          end
+          param_hasher = "Twox128" if param_hasher.nil?
+          storage_key += Crypto.send(param_hasher.underscore2, param_key)
+        end
+
+        "0x#{storage_key}"
+      else
+        # TODO: add test
+        storage_key = module_name + " " + storage_name
+
+        unless params.nil?
+          params = [params] if params.class != ::Array
+          params_key = params.join("")
+          hasher = "Twox128" if hasher.nil?
+          storage_key += params_key.hex_to_bytes.bytes_to_utf8 
+        end
+
+        "0x#{Crypto.send( hasher.underscore2, storage_key )}"
+      end
+    end
+
+    def compose_call_from_metadata(metadata, module_name, call_name, params)
+      call = metadata.get_module_call(module_name, call_name)
+
+      value = {
+        call_index: call[:lookup],
+        module_name: module_name,
+        call_name: call_name,
+        params: []
+      }
+
+      params.keys.each_with_index do |call_param_name, i|
+        param_value = params[call_param_name]
+        value[:params] << {
+          name: call_param_name.to_s,
+          type: call[:args][i][:type],
+          value: param_value
+        }
+      end
+
+      Scale::Types::Extrinsic.new(value).encode
+    end
+
+    def decode_block(block)
+      block["block"]["header"]["number"] = block["block"]["header"]["number"].to_i(16)
+
+      block["block"]["extrinsics_decoded"] = []
+      block["block"]["extrinsics"].each_with_index do |hex, i|
+        scale_bytes = Scale::Bytes.new(hex)
+        block["block"]["extrinsics_decoded"][i] = Scale::Types::Extrinsic.decode(scale_bytes).to_human
+      end
+
+      block['block']['header']["digest"]["logs_decoded"] = []
+      block['block']['header']["digest"]["logs"].each_with_index do |hex, i|
+        scale_bytes = Scale::Bytes.new(hex)
+        log = Scale::Types::LogDigest.decode(scale_bytes).to_human
+        block['block']['header']["digest"]["logs_decoded"][i] = log
+      end
+
+      block
+    end
+
+  end
+end

data/lib/metadata/metadata.rb

@@ -7,7 +7,7 @@ module Scale
         bytes = scale_bytes.get_next_bytes(4)
         if bytes.bytes_to_utf8 == "meta"
           metadata_version = Scale::Types.type_of("Enum", %w[MetadataV0 MetadataV1 MetadataV2 MetadataV3 MetadataV4 MetadataV5 MetadataV6 MetadataV7 MetadataV8 MetadataV9 MetadataV10 MetadataV11 MetadataV12]).decode(scale_bytes).value
-          metadata = Metadata.new "Scale::Types::#{metadata_version}".constantize.decode(scale_bytes)
+          metadata = Metadata.new "Scale::Types::#{metadata_version}".constantize2.decode(scale_bytes)
           metadata.version = metadata_version[9..].to_i
         else
           scale_bytes.reset_offset
@@ -35,6 +35,16 @@ module Scale
           end
         end
       end
+
+      def get_module_storage(module_name, storage_name)
+        the_module = get_module(module_name)
+        if the_module[:storage].class == Array
+          storages = the_module[:storage]
+        else
+          storages = the_module[:storage][:items]
+        end
+        storages.find {|storage| storage[:name] == storage_name}
+      end
     end
 
     class MetadataModule
@@ -68,6 +78,10 @@ module Scale
 
         MetadataModule.new(result)
       end
+
+      def get_storage(storage_name)
+        self.value[:storage].find { |storage| storage[:name].downcase == storage_name.downcase }
+      end
     end
 
     class MetadataModuleStorage