scale.rb 0.2.18 → 0.3.2

data/lib/type_registry.rb

@@ -0,0 +1,91 @@
+module Scale
+
+  class TypeRegistry
+    include Singleton
+
+    # init by load, and will not change
+    attr_reader :spec_name, :types
+    attr_reader :versioning, :custom_types # optional
+
+    # will change by different spec version
+    attr_accessor :spec_version # optional
+    attr_accessor :metadata
+
+    def load(spec_name: nil, custom_types: nil)
+      @spec_name = nil
+      @types = nil
+      @versioning = nil
+      @custom_types = nil
+
+      default_types, _, _ = load_chain_spec_types("default")
+
+      if spec_name
+        begin
+          @spec_name = spec_name
+          spec_types, @versioning, @spec_version = load_chain_spec_types(spec_name)
+          @types = default_types.merge(spec_types)
+        rescue => ex
+          # TODO: check different errors
+          Scale::Types.logger.error "There is no types json file named #{spec_name}"
+          @types = default_types
+        end
+      else
+        @spec_name = "default"
+        @types = default_types
+      end
+
+      self.custom_types = custom_types
+      true
+    end
+
+    def get(type_name)
+      all_types = self.all_types
+      type_traverse(type_name, all_types)
+    end
+
+    def custom_types=(custom_types)
+      @custom_types = custom_types.stringify_keys if (not custom_types.nil?) && custom_types.class.name == "Hash"
+    end
+
+    def all_types
+      all_types = {}.merge(@types)
+
+      if @spec_version && @versioning
+        @versioning.each do |item|
+          if @spec_version >= item["runtime_range"][0] && 
+              ( item["runtime_range"][1].nil? || @spec_version <= item["runtime_range"][1] )
+            all_types.merge!(item["types"])
+          end
+        end
+      end
+
+      all_types.merge!(@custom_types) if @custom_types
+      all_types
+    end
+
+    private
+
+      def load_chain_spec_types(spec_name)
+        file = File.join File.expand_path("../..", __FILE__), "lib", "type_registry", "#{spec_name}.json"
+        json_string = File.open(file).read
+        json = JSON.parse(json_string)
+
+        runtime_id = json["runtime_id"]
+
+        [json["types"], json["versioning"], runtime_id]
+      end
+
+      def type_traverse(type, types)
+        if type.class == ::String 
+          real_type = types[type]
+
+          return type if real_type.nil? || real_type == type
+
+          type_traverse(real_type, types)
+        else
+          type
+        end
+      end
+  end
+
+end

data/scripts/mmr_root_to_sign.rb

@@ -0,0 +1,10 @@
+client = SubstrateClient.new "wss://pangolin-rpc.darwinia.network"
+
+begin
+  block_number = Scale::Types.get("BlockNumberFor").new(670820)
+  puts client.get_storage("EthereumRelayAuthorities", "MmrRootsToSign", [block_number]).to_human
+rescue => ex
+  puts ex.message
+  puts ex.backtrace
+end
+

data/src/lib.rs

@@ -1,10 +1,15 @@
 extern crate parity_scale_codec;
 use std::slice;
-use parity_scale_codec::{Encode, Decode};
+use parity_scale_codec::Decode;
 use frame_support::Twox128;
+use frame_support::Twox64Concat;
+use frame_support::Identity;
 use frame_support::Blake2_128Concat;
 use frame_support::StorageHasher;
 
+use libc::c_char;
+use std::ffi::{CStr, CString};
+
 fn to_u8_vec(v_pointer: *const u8, len: usize) -> Vec<u8> {
 	let data_slice = unsafe {
 		assert!(!v_pointer.is_null());
@@ -13,6 +18,38 @@ fn to_u8_vec(v_pointer: *const u8, len: usize) -> Vec<u8> {
 	data_slice.to_vec()
 }
 
+fn to_string(str_p: *const c_char) -> String {
+	let s = unsafe {
+		assert!(!str_p.is_null());
+		CStr::from_ptr(str_p)
+	};
+
+	s.to_str().unwrap().to_string()
+}
+
+fn v8_vec_to_pointer(key: Vec<u8>) -> *const c_char {
+	let key = CString::new(hex::encode(key)).unwrap();
+	let result = key.as_ptr();
+	std::mem::forget(key);
+	result
+}
+
+fn gen_param_hash(param_pointer: *const u8, param_len: usize, param_hasher: *const c_char) -> Vec<u8> {
+	let param_hasher = to_string(param_hasher);
+	let param_hasher = param_hasher.as_str();
+	let param = to_u8_vec(param_pointer, param_len);
+
+	if param_hasher == "blake2_128_concat" {
+		Blake2_128Concat::hash(&param).to_vec()
+	} else if param_hasher == "twox64_concat" {
+		Twox64Concat::hash(&param).to_vec()
+	} else if param_hasher == "identity" {
+		Identity::hash(&param).to_vec()
+	} else {
+		panic!("Not supported hasher type")
+	} 
+}
+
 fn decode_from_raw_parts<T: Decode + PartialEq + std::fmt::Debug>(v_pointer: *const u8, len: usize) -> T {
     let data_slice = unsafe {
         assert!(!v_pointer.is_null());
@@ -61,33 +98,51 @@ pub extern fn parse_opt_bool(v_pointer: *const u8, len: usize, inner_value: bool
 }
 
 #[no_mangle]
-pub extern fn assert_storage_key_for_value(
-	mv_pointer: *const u8, mv_len: usize, 
-	sv_pointer: *const u8, sv_len: usize, 
-	ev_pointer: *const u8, ev_len: usize
-) {
-	let m = to_u8_vec(mv_pointer, mv_len);
-	let s = to_u8_vec(sv_pointer, sv_len);
-	let e = to_u8_vec(ev_pointer, ev_len);
-
-	let k = [Twox128::hash(&m), Twox128::hash(&s)].concat();
-	assert_eq!(k, e);
+pub extern fn get_storage_key_for_value(
+	module_name: *const c_char, 
+	storage_name: *const c_char, 
+) -> *const c_char {
+	let module_name = to_string(module_name);
+	let storage_name = to_string(storage_name);
+
+	let storage_key = [Twox128::hash(module_name.as_bytes()), Twox128::hash(storage_name.as_bytes())].concat();
+	v8_vec_to_pointer(storage_key)
+}
+
+#[no_mangle]
+pub extern fn get_storage_key_for_map(
+	module_name: *const c_char, 
+	storage_name: *const c_char, 
+	param_pointer: *const u8, param_len: usize, param_hasher: *const c_char,
+) -> *const c_char {
+	let module_name = to_string(module_name);
+	let storage_name = to_string(storage_name);
+	let mut storage_key = [Twox128::hash(module_name.as_bytes()), Twox128::hash(storage_name.as_bytes())].concat();
+
+	let param_hash = gen_param_hash(param_pointer, param_len, param_hasher);
+	storage_key.extend(param_hash);
+
+	v8_vec_to_pointer(storage_key)
 }
 
 #[no_mangle]
-pub extern fn assert_storage_key_for_map_black2128concat(
-	mv_pointer: *const u8, mv_len: usize, 
-	sv_pointer: *const u8, sv_len: usize, 
-	pv_pointer: *const u8, pv_len: usize, 
-	ev_pointer: *const u8, ev_len: usize,
-) {
-	let m = to_u8_vec(mv_pointer, mv_len);
-	let s = to_u8_vec(sv_pointer, sv_len);
-	let p = to_u8_vec(pv_pointer, pv_len);
-	let e = to_u8_vec(ev_pointer, ev_len);
-	let mut k = [Twox128::hash(&m), Twox128::hash(&s)].concat();
-	k.extend(p.using_encoded(Blake2_128Concat::hash));
-	assert_eq!(k, e);
+pub extern fn get_storage_key_for_double_map(
+	module_name: *const c_char, 
+	storage_name: *const c_char, 
+	param1_pointer: *const u8, param1_len: usize, param1_hasher: *const c_char,
+	param2_pointer: *const u8, param2_len: usize, param2_hasher: *const c_char,
+) -> *const c_char {
+	let module_name = to_string(module_name);
+	let storage_name = to_string(storage_name);
+	let mut storage_key = [Twox128::hash(module_name.as_bytes()), Twox128::hash(storage_name.as_bytes())].concat();
+
+	let param1_hash = gen_param_hash(param1_pointer, param1_len, param1_hasher);
+	storage_key.extend(param1_hash);
+
+	let param2_hash = gen_param_hash(param2_pointer, param2_len, param2_hasher);
+	storage_key.extend(param2_hash);
+
+	v8_vec_to_pointer(storage_key)
 }
 
 #[test]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scale.rb
 version: !ruby/object:Gem::Version
-  version: 0.2.18
+  version: 0.3.2
 platform: ruby
 authors:
 - Wu Minzhe
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-04-05 00:00:00.000000000 Z
+date: 2021-08-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: blake2b_rs
@@ -196,6 +196,7 @@ files:
 - lib/metadata/metadata_v10.rb
 - lib/metadata/metadata_v11.rb
 - lib/metadata/metadata_v12.rb
+- lib/metadata/metadata_v13.rb
 - lib/metadata/metadata_v2.rb
 - lib/metadata/metadata_v3.rb
 - lib/metadata/metadata_v4.rb
@@ -210,7 +211,10 @@ files:
 - lib/scale/trie.rb
 - lib/scale/types.rb
 - lib/scale/version.rb
+- lib/scale_bytes.rb
 - lib/substrate_client.rb
+- lib/type_builder.rb
+- lib/type_registry.rb
 - lib/type_registry/crab.json
 - lib/type_registry/darwinia.json
 - lib/type_registry/default.json
@@ -221,8 +225,8 @@ files:
 - scale.gemspec
 - scripts/block_events.rb
 - scripts/example.rb
+- scripts/mmr_root_to_sign.rb
 - src/lib.rs
-- src/storage_key.rs
 homepage: https://github.com/itering/scale.rb
 licenses:
 - MIT

data/src/storage_key.rs

@@ -1,41 +0,0 @@
-use frame_support::Twox128;
-use parity_scale_codec::Encode;
-use frame_support::{Identity, Blake2_128Concat, Twox64Concat};
-use frame_support::StorageHasher;
-
-pub fn to_hex_string(bytes: Vec<u8>) -> String {
-	let strs: Vec<String> = bytes.iter()
-		.map(|b| format!("{:02x}", b))
-		.collect();
-	strs.join("")
-}
-
-fn main() {
-	// value
-	let k = [Twox128::hash(b"Sudo"), Twox128::hash(b"Key")].concat();
-	println!("{}", to_hex_string(k));
-
-	// map
-	let mut k = [Twox128::hash(b"ModuleAbc"), Twox128::hash(b"Map1")].concat();
-	k.extend(vec![1u8, 0, 0, 0].using_encoded(Blake2_128Concat::hash));
-	println!("{}", to_hex_string(k));
-
-	let mut k = [Twox128::hash(b"ModuleAbc"), Twox128::hash(b"Map2")].concat();
-	k.extend(1u32.using_encoded(Twox64Concat::hash));
-	println!("{}", to_hex_string(k));
-
-	let mut k = [Twox128::hash(b"ModuleAbc"), Twox128::hash(b"Map3")].concat();
-	k.extend(1u32.using_encoded(Identity::hash));
-	println!("{}", to_hex_string(k));
-
-	// double map
-	let mut k = [Twox128::hash(b"ModuleAbc"), Twox128::hash(b"DoubleMap1")].concat();
-	k.extend(1u32.using_encoded(Blake2_128Concat::hash));
-	k.extend(2u32.using_encoded(Blake2_128Concat::hash));
-	println!("{}", to_hex_string(k));
-
-	let mut k = [Twox128::hash(b"ModuleAbc"), Twox128::hash(b"DoubleMap2")].concat();
-	k.extend(1u32.using_encoded(Blake2_128Concat::hash));
-	k.extend(2u32.using_encoded(Twox64Concat::hash));
-	println!("{}", to_hex_string(k));
-}