scale.rb 0.2.19 → 0.3.0

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.19
+  version: 0.3.0
 platform: ruby
 authors:
 - Wu Minzhe
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-04-13 00:00:00.000000000 Z
+date: 2021-08-11 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,15 +225,15 @@ 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
 metadata:
   allowed_push_host: https://rubygems.org
   homepage_uri: https://github.com/itering/scale.rb
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -244,8 +248,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: Ruby SCALE Codec Library
 test_files: []

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));
-}