scale.rb 0.2.13 → 0.2.18

data/lib/type_registry/default.json

@@ -228,7 +228,7 @@
         ]
       ]
     },
-    "RefCount": "u8",
+    "RefCount": "u32",
     "Moment": "u64",
     "AccountData": {
       "type": "struct",
@@ -259,7 +259,7 @@
           "Index"
         ],
         [
-          "refcount",
+          "c",
           "RefCount"
         ],
         [

data/lib/type_registry/pangolin.json

@@ -0,0 +1,332 @@
+{
+  "types": {
+    "BalanceLock": {
+      "type": "struct",
+      "type_mapping": [
+        ["id", "LockIdentifier"],
+        ["lock_for", "LockFor"],
+        ["lock_reasons", "LockReasons"],
+        ["amount", "Balance"],
+        ["reasons", "Reasons"]
+      ]
+    },
+    "LockFor": {
+      "type": "enum",
+      "type_mapping": [
+        ["Common", "Common"],
+        ["Staking", "StakingLock"]
+      ]
+    },
+    "Common": {
+      "type": "struct",
+      "type_mapping": [
+        ["amount", "Balance"]
+      ]
+    },
+    "StakingLock": {
+      "type": "struct",
+      "type_mapping": [
+        ["staking_amount", "Balance"],
+        ["unbondings", "Vec<Unbonding>"]
+      ]
+    },
+    "LockReasons": {
+      "type": "enum",
+      "type_mapping": [
+        ["Fee", "Null"],
+        ["Misc", "Null"],
+        ["All", "Null"]
+      ]
+    },
+    "Unbonding": {
+      "type": "struct",
+      "type_mapping": [
+        ["amount", "Balance"],
+        ["until", "BlockNumber"]
+      ]
+    },
+    "AccountData": {
+      "type": "struct",
+      "type_mapping": [
+        ["free", "Balance"],
+        ["reserved", "Balance"],
+        ["free_kton", "Balance"],
+        ["reserved_kton", "Balance"],
+        ["misc_frozen", "Balance"],
+        ["fee_frozen", "Balance"]
+      ]
+    },
+    "RingBalance": "Balance",
+    "KtonBalance": "Balance",
+    "TsInMs": "u64",
+    "Power": "u32",
+    "DepositId": "U256",
+    "StakingBalanceT": {
+      "type": "enum",
+      "type_mapping": [
+        ["RingBalance", "Balance"],
+        ["KtonBalance", "Balance"]
+      ]
+    },
+    "StakingLedgerT": {
+      "type": "struct",
+      "type_mapping": [
+        ["stash", "AccountId"],
+        ["active_ring", "Compact<Balance>"],
+        ["active_deposit_ring", "Compact<Balance>"],
+        ["active_kton", "Compact<Balance>"],
+        ["deposit_items", "Vec<TimeDepositItem>"],
+        ["ring_staking_lock", "StakingLock"],
+        ["kton_staking_lock", "StakingLock"],
+        ["claimed_rewards", "Vec<EraIndex>"],
+        ["total", "Compact<Balance>"],
+        ["active", "Compact<Balance>"],
+        ["unlocking", "Vec<UnlockChunk>"]
+      ]
+    },
+    "TimeDepositItem": {
+      "type": "struct",
+      "type_mapping": [
+        ["value", "Compact<Balance>"],
+        ["start_time", "Compact<TsInMs>"],
+        ["expire_time", "Compact<TsInMs>"]
+      ]
+    },
+    "ExposureT": {
+      "type": "struct",
+      "type_mapping": [
+        ["own_ring_balance", "Compact<Balance>"],
+        ["own_kton_balance", "Compact<Balance>"],
+        ["own_power", "Power"],
+        ["total_power", "Power"],
+        ["others", "Vec<IndividualExposure>"]
+      ]
+    },
+    "IndividualExposure": {
+      "type": "struct",
+      "type_mapping": [
+        ["who", "AccountId"],
+        ["ring_balance", "Compact<Balance>"],
+        ["kton_balance", "Compact<Balance>"],
+        ["power", "Power"],
+        ["value", "Compact<Balance>"]
+      ]
+    },
+    "ElectionResultT": {
+      "type": "struct",
+      "type_mapping": [
+        ["elected_stashes", "Vec<AccountId>"],
+        ["exposures", "Vec<(AccountId, ExposureT)>"],
+        ["compute", "ElectionCompute"]
+      ]
+    },
+    "RKT": {
+      "type": "struct",
+      "type_mapping": [
+        ["r", "Balance"],
+        ["k", "Balance"]
+      ]
+    },
+    "SpanRecord": {
+      "type": "struct",
+      "type_mapping": [
+        ["slashed", "RKT"],
+        ["paid_out", "RKT"]
+      ]
+    },
+    "UnappliedSlash": {
+      "type": "struct",
+      "type_mapping": [
+        ["validator", "AccountId"],
+        ["own", "RKT"],
+        ["others", "Vec<(AccountId, RKT)>"],
+        ["reporters", "Vec<AccountId>"],
+        ["payout", "RKT"]
+      ]
+    },
+    "TreasuryProposal": {
+      "type": "struct",
+      "type_mapping": [
+        ["proposer", "AccountId"],
+        ["beneficiary", "AccountId"],
+        ["ring_value", "Balance"],
+        ["kton_value", "Balance"],
+        ["ring_bond", "Balance"],
+        ["kton_bond", "Balance"]
+      ]
+    },
+    "MappedRing": "u128",
+    "EthereumTransactionIndex": "(H256, u64)",
+    "EthereumBlockNumber": "u64",
+    "EthereumHeader": {
+      "type": "struct",
+      "type_mapping": [
+        ["parent_hash", "H256"],
+        ["timestamp", "u64"],
+        ["number", "EthereumBlockNumber"],
+        ["author", "EthereumAddress"],
+        ["transactions_root", "H256"],
+        ["uncles_hash", "H256"],
+        ["extra_data", "Bytes"],
+        ["state_root", "H256"],
+        ["receipts_root", "H256"],
+        ["log_bloom", "Bloom"],
+        ["gas_used", "U256"],
+        ["gas_limit", "U256"],
+        ["difficulty", "U256"],
+        ["seal", "Vec<Bytes>"],
+        ["hash", "Option<H256>"]
+      ]
+    },
+    "EthereumAddress": "H160",
+    "EcdsaMessage": "[u8; 32]",
+    "Bloom": "[u8; 256]",
+    "H128": "[u8; 16]",
+    "EthashProof": {
+      "type": "struct",
+      "type_mapping": [
+        ["dag_nodes", "(H512, H512)"],
+        ["proof", "Vec<H128>"]
+      ]
+    },
+    "EthereumReceipt": {
+      "type": "struct",
+      "type_mapping": [
+        ["gas_used", "U256"],
+        ["log_bloom", "Bloom"],
+        ["logs", "Vec<LogEntry>"],
+        ["outcome", "TransactionOutcome"]
+      ]
+    },
+    "EthereumNetworkType": {
+      "type": "enum",
+      "type_mapping": [
+        ["Mainnet", "Null"],
+        ["Ropsten", "Null"]
+      ]
+    },
+    "RedeemFor": {
+      "type": "enum",
+      "type_mapping": [
+        ["Token", "Null"],
+        ["Deposit", "Null"]
+      ]
+    },
+    "EthereumReceiptProof": {
+      "type": "struct",
+      "type_mapping": [
+        ["index", "u64"],
+        ["proof", "Bytes"],
+        ["header_hash", "H256"]
+      ]
+    },
+    "EthereumReceiptProofThing": "(EthereumHeader, EthereumReceiptProof, MMRProof)",
+    "MMRProof": {
+      "type": "struct",
+      "type_mapping": [
+        ["member_leaf_index", "u64"],
+        ["last_leaf_index", "u64"],
+        ["proof", "Vec<H256>"]
+      ]
+    },
+    "EthereumRelayHeaderParcel": {
+      "type": "struct",
+      "type_mapping": [
+        ["header", "EthereumHeader"],
+        ["parent_mmr_root", "H256"]
+      ]
+    },
+    "EthereumRelayProofs": {
+      "type": "struct",
+      "type_mapping": [
+        ["ethash_proof", "Vec<EthashProof>"],
+        ["mmr_proof", "Vec<H256>"]
+      ]
+    },
+    "RelayAuthoritySigner": "EthereumAddress",
+    "RelayAuthorityMessage": "EcdsaMessage",
+    "RelayAuthoritySignature": "EcdsaSignature",
+    "OtherSignature": {
+      "type": "enum",
+      "type_mapping": [
+        ["Eth", "EcdsaSignature"],
+        ["Tron", "EcdsaSignature"]
+      ]
+    },
+    "EcdsaSignature": "[u8; 65]",
+    "OtherAddress": {
+      "type": "enum",
+      "type_mapping": [
+        ["Eth", "[u8; 20]"],
+        ["Tron", "[u8; 20]"]
+      ]
+    },
+    "AddressT": "[u8; 20]",
+    "MerkleMountainRangeRootLog": {
+      "type": "struct",
+      "type_mapping": [
+        ["prefix", "[u8; 4]"],
+        ["parent_mmr_root", "Hash"]
+      ]
+    },
+    "OpCode": "[u8; 4]",
+    "Term": "u32",
+    "RelayHeaderId": "EthereumBlockNumber",
+    "RelayHeaderParcel": "EthereumRelayHeaderParcel",
+    "RelayProofs": "EthereumRelayProofs",
+    "RelayAffirmationId": {
+      "type": "struct",
+      "type_mapping": [
+        ["game_id", "EthereumBlockNumber"],
+        ["round", "u32"],
+        ["index", "u32"]
+      ]
+    },
+    "RelayAffirmationT": {
+      "type": "struct",
+      "type_mapping": [
+        ["relayer", "AccountId"],
+        ["relay_header_parcels", "EthereumRelayHeaderParcel"],
+        ["bond", "Balance"],
+        ["maybe_extended_relay_affirmation_id", "Option<RelayAffirmationId>"],
+        ["verified", "bool"]
+      ]
+    },
+    "RelayVotingState": {
+      "type": "struct",
+      "type_mapping": [
+        ["ayes", "Vec<AccountId>"],
+        ["nays", "Vec<AccountId>"]
+      ]
+    },
+    "RelayAuthorityT": {
+      "type": "struct",
+      "type_mapping": [
+        ["account_id", "AccountId"],
+        ["signer", "Signer"],
+        ["stake", "Balance"],
+        ["term", "BlockNumber"]
+      ]
+    },
+    "ScheduledAuthoritiesChangeT": {
+      "type": "struct",
+      "type_mapping": [
+        ["next_authorities", "Vec<RelayAuthorityT>"],
+        ["deadline", "BlockNumber"]
+      ]
+    },
+    "MMRRoot": "Hash",
+    "BalancesRuntimeDispatchInfo": {
+      "type": "struct",
+      "type_mapping": [
+        ["usable_balance", "Balance"]
+      ]
+    },
+    "StakingRuntimeDispatchInfo": {
+      "type": "struct",
+      "type_mapping": [
+        ["power", "Power"]
+      ]
+    }
+  }
+}

data/scale.gemspec

@@ -33,14 +33,16 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "substrate_common.rb", "~> 0.1.9"
+  spec.add_dependency "blake2b_rs", "~> 0.1.2"
+  spec.add_dependency "xxhash"
+  spec.add_dependency "base58"
   spec.add_dependency "json", "~> 2.3.0"
-  spec.add_dependency "activesupport", ">= 4.0.0"
-  spec.add_dependency "thor", "~> 0.19.0"
+  spec.add_dependency "faye-websocket"
+  spec.add_dependency "thor", '~> 1.0'
 
-  spec.add_development_dependency "bundler", "~> 1.17"
+  spec.add_development_dependency "bundler"
   spec.add_development_dependency "pry"
   spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rspec", "~> 3.2"
-  spec.add_development_dependency "ffi", "~> 1.12"
+  spec.add_development_dependency "ffi", "~> 1.15.0"
 end

data/scripts/block_events.rb

@@ -2,7 +2,6 @@ require "scale"
 
 
 client = SubstrateClient.new("ws://127.0.0.1:9944/")
-client.init
 metadata = client.get_metadata nil
 
 the_module = metadata.get_module("CertificateModule")
@@ -23,7 +22,7 @@ puts "CertificateModule storages:"
 puts "---------------------------------------"
 puts the_module[:storage][:items]
 
-# Scale::TypeRegistry.instance.metadata = metadata.value
+# Scale::TypeRegistry.instance.metadata = metadata
 # puts metadata.value.event_index["0400"][1]
 # puts metadata.value.event_index["0401"][1]
 # puts metadata.value.event_index["0402"][1]
@@ -31,4 +30,4 @@ puts the_module[:storage][:items]
 # scale_bytes = Scale::Bytes.new(hex_events)
 # Scale::Types.get("Vec<EventRecord>").decode(scale_bytes).value.each do |er|
 #   puts er.value
-# end
+# end

data/src/lib.rs

@@ -1,6 +1,17 @@
 extern crate parity_scale_codec;
 use std::slice;
-use parity_scale_codec::{Decode};
+use parity_scale_codec::{Encode, Decode};
+use frame_support::Twox128;
+use frame_support::Blake2_128Concat;
+use frame_support::StorageHasher;
+
+fn to_u8_vec(v_pointer: *const u8, len: usize) -> Vec<u8> {
+	let data_slice = unsafe {
+		assert!(!v_pointer.is_null());
+		slice::from_raw_parts(v_pointer, len)
+	};
+	data_slice.to_vec()
+}
 
 fn decode_from_raw_parts<T: Decode + PartialEq + std::fmt::Debug>(v_pointer: *const u8, len: usize) -> T {
     let data_slice = unsafe {
@@ -49,6 +60,36 @@ pub extern fn parse_opt_bool(v_pointer: *const u8, len: usize, inner_value: bool
     assert_eq!(decode_from_raw_parts::<Option<bool>>(v_pointer, len), expectation);
 }
 
+#[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);
+}
+
+#[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);
+}
+
 #[test]
 fn opt_bool_is_broken()
 {