mirror of
https://github.com/pezkuwichain/pezkuwi-subxt.git
synced 2026-06-11 21:11:07 +00:00
Add documentation to SubmitSignedTransaction and actually make it work (#4200)
* Add documentation to signed transactions and actually make them work. * Fix naming and bounds. * Forgotten import. * Remove warning. * Make accounts optional, fix logic. * Split the method to avoid confusing type error message. * Move executor tests to integration. * Add submit transactions tests. * Make `submit_transaction` tests compile * Remove a file that was accidently committed * Add can_sign helper function. * Fix compilation. * Add a key to keystore. * Fix the tests. * Remove env_logger. * Fix sending multiple transactions. * Remove commented code. * Bring back criterion. * Remove stray debug log. * Apply suggestions from code review Co-Authored-By: Bastian Köcher <bkchr@users.noreply.github.com> * Make sure to initialize block correctly. * Initialize block for offchain workers. * Add test for transaction validity. * Fix tests. * Review suggestions. * Remove redundant comment. * Make sure to use correct block number of authoring. * Change the runtime API. * Support both versions. * Bump spec version, fix RPC test. Co-authored-by: Hernando Castano <HCastano@users.noreply.github.com> Co-authored-by: Gavin Wood <github@gavwood.com> Co-authored-by: Bastian Köcher <bkchr@users.noreply.github.com>
This commit is contained in:
Tomasz Drwięga
committed by
Gavin Wood
Gavin Wood
parent
a1e0076aa8
commit
74d6e660c6
Generated
+2
@@ -3096,6 +3096,7 @@ dependencies = [
|
||||
"pallet-balances 2.0.0",
|
||||
"pallet-contracts 2.0.0",
|
||||
"pallet-grandpa 2.0.0",
|
||||
"pallet-im-online 2.0.0",
|
||||
"pallet-indices 2.0.0",
|
||||
"pallet-session 2.0.0",
|
||||
"pallet-timestamp 2.0.0",
|
||||
@@ -3103,6 +3104,7 @@ dependencies = [
|
||||
"pallet-treasury 2.0.0",
|
||||
"parity-scale-codec 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"sc-executor 2.0.0",
|
||||
"sp-application-crypto 2.0.0",
|
||||
"sp-core 2.0.0",
|
||||
"sp-io 2.0.0",
|
||||
"sp-runtime 2.0.0",
|
||||
|
||||
@@ -15,7 +15,7 @@ use sp_runtime::{
|
||||
impl_opaque_keys, MultiSignature
|
||||
};
|
||||
use sp_runtime::traits::{
|
||||
NumberFor, BlakeTwo256, Block as BlockT, StaticLookup, Verify, ConvertInto, IdentifyAccount
|
||||
BlakeTwo256, Block as BlockT, StaticLookup, Verify, ConvertInto, IdentifyAccount
|
||||
};
|
||||
use sp_api::impl_runtime_apis;
|
||||
use sp_consensus_aura::sr25519::AuthorityId as AuraId;
|
||||
@@ -341,8 +341,8 @@ impl_runtime_apis! {
|
||||
}
|
||||
|
||||
impl sp_offchain::OffchainWorkerApi<Block> for Runtime {
|
||||
fn offchain_worker(number: NumberFor<Block>) {
|
||||
Executive::offchain_worker(number)
|
||||
fn offchain_worker(header: &<Block as BlockT>::Header) {
|
||||
Executive::offchain_worker(header)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -6,32 +6,34 @@ description = "Substrate node implementation in Rust."
|
||||
edition = "2018"
|
||||
|
||||
[dependencies]
|
||||
trie-root = "0.15.2"
|
||||
codec = { package = "parity-scale-codec", version = "1.0.0" }
|
||||
sp-io = { version = "2.0.0", path = "../../../primitives/io" }
|
||||
sp-state-machine = { version = "2.0.0", path = "../../../primitives/state-machine" }
|
||||
sc-executor = { version = "2.0.0", path = "../../../client/executor" }
|
||||
sp-core = { version = "2.0.0", path = "../../../primitives/core" }
|
||||
sp-trie = { version = "2.0.0", path = "../../../primitives/trie" }
|
||||
node-primitives = { version = "2.0.0", path = "../primitives" }
|
||||
node-runtime = { version = "2.0.0", path = "../runtime" }
|
||||
sc-executor = { version = "2.0.0", path = "../../../client/executor" }
|
||||
sp-core = { version = "2.0.0", path = "../../../primitives/core" }
|
||||
sp-io = { version = "2.0.0", path = "../../../primitives/io" }
|
||||
sp-state-machine = { version = "2.0.0", path = "../../../primitives/state-machine" }
|
||||
sp-trie = { version = "2.0.0", path = "../../../primitives/trie" }
|
||||
trie-root = "0.15.2"
|
||||
|
||||
[dev-dependencies]
|
||||
node-testing = { version = "2.0.0", path = "../testing" }
|
||||
substrate-test-client = { version = "2.0.0", path = "../../../test-utils/client" }
|
||||
sp-runtime = { version = "2.0.0", path = "../../../primitives/runtime" }
|
||||
criterion = "0.3.0"
|
||||
frame-support = { version = "2.0.0", path = "../../../frame/support" }
|
||||
pallet-balances = { version = "2.0.0", path = "../../../frame/balances" }
|
||||
pallet-transaction-payment = { version = "2.0.0", path = "../../../frame/transaction-payment" }
|
||||
pallet-session = { version = "2.0.0", path = "../../../frame/session" }
|
||||
frame-system = { version = "2.0.0", path = "../../../frame/system" }
|
||||
pallet-timestamp = { version = "2.0.0", path = "../../../frame/timestamp" }
|
||||
pallet-treasury = { version = "2.0.0", path = "../../../frame/treasury" }
|
||||
node-testing = { version = "2.0.0", path = "../testing" }
|
||||
pallet-balances = { version = "2.0.0", path = "../../../frame/balances" }
|
||||
pallet-contracts = { version = "2.0.0", path = "../../../frame/contracts" }
|
||||
pallet-grandpa = { version = "2.0.0", path = "../../../frame/grandpa" }
|
||||
pallet-im-online = { version = "2.0.0", path = "../../../frame/im-online" }
|
||||
pallet-indices = { version = "2.0.0", path = "../../../frame/indices" }
|
||||
pallet-session = { version = "2.0.0", path = "../../../frame/session" }
|
||||
pallet-timestamp = { version = "2.0.0", path = "../../../frame/timestamp" }
|
||||
pallet-transaction-payment = { version = "2.0.0", path = "../../../frame/transaction-payment" }
|
||||
pallet-treasury = { version = "2.0.0", path = "../../../frame/treasury" }
|
||||
sp-application-crypto = { version = "2.0.0", path = "../../../primitives/application-crypto" }
|
||||
sp-runtime = { version = "2.0.0", path = "../../../primitives/runtime" }
|
||||
substrate-test-client = { version = "2.0.0", path = "../../../test-utils/client" }
|
||||
wabt = "0.9.2"
|
||||
criterion = "0.3.0"
|
||||
|
||||
[features]
|
||||
wasmtime = [
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,836 @@
|
||||
// Copyright 2018-2020 Parity Technologies (UK) Ltd.
|
||||
// This file is part of Substrate.
|
||||
|
||||
// Substrate is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
|
||||
// Substrate is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with Substrate. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
use codec::{Encode, Decode, Joiner};
|
||||
use frame_support::{
|
||||
StorageValue, StorageMap,
|
||||
traits::Currency,
|
||||
weights::{GetDispatchInfo, DispatchInfo, DispatchClass},
|
||||
};
|
||||
use sp_core::{
|
||||
Blake2Hasher, NeverNativeValue, map,
|
||||
traits::Externalities,
|
||||
storage::{well_known_keys, Storage},
|
||||
};
|
||||
use sp_runtime::{
|
||||
ApplyExtrinsicResult, Fixed64,
|
||||
traits::{Hash as HashT, Convert},
|
||||
transaction_validity::InvalidTransaction,
|
||||
};
|
||||
use pallet_contracts::ContractAddressFor;
|
||||
use frame_system::{self, EventRecord, Phase};
|
||||
|
||||
use node_runtime::{
|
||||
Header, Block, UncheckedExtrinsic, CheckedExtrinsic, Call, Runtime, Balances,
|
||||
System, TransactionPayment, Event,
|
||||
TransferFee, TransactionBaseFee, TransactionByteFee,
|
||||
constants::currency::*,
|
||||
};
|
||||
use node_primitives::{Balance, Hash};
|
||||
use wabt;
|
||||
use node_testing::keyring::*;
|
||||
|
||||
mod common;
|
||||
use self::common::{*, sign};
|
||||
|
||||
/// The wasm runtime binary which hasn't undergone the compacting process.
|
||||
///
|
||||
/// The idea here is to pass it as the current runtime code to the executor so the executor will
|
||||
/// have to execute provided wasm code instead of the native equivalent. This trick is used to
|
||||
/// test code paths that differ between native and wasm versions.
|
||||
pub const BLOATY_CODE: &[u8] = node_runtime::WASM_BINARY_BLOATY;
|
||||
|
||||
/// Default transfer fee
|
||||
fn transfer_fee<E: Encode>(extrinsic: &E, fee_multiplier: Fixed64) -> Balance {
|
||||
let length_fee = TransactionByteFee::get() * (extrinsic.encode().len() as Balance);
|
||||
|
||||
let weight = default_transfer_call().get_dispatch_info().weight;
|
||||
let weight_fee = <Runtime as pallet_transaction_payment::Trait>
|
||||
::WeightToFee::convert(weight);
|
||||
|
||||
let base_fee = TransactionBaseFee::get();
|
||||
base_fee + fee_multiplier.saturated_multiply_accumulate(length_fee + weight_fee) + TransferFee::get()
|
||||
}
|
||||
|
||||
fn xt() -> UncheckedExtrinsic {
|
||||
sign(CheckedExtrinsic {
|
||||
signed: Some((alice(), signed_extra(0, 0))),
|
||||
function: Call::Balances(default_transfer_call()),
|
||||
})
|
||||
}
|
||||
|
||||
fn set_heap_pages<E: Externalities>(ext: &mut E, heap_pages: u64) {
|
||||
ext.place_storage(well_known_keys::HEAP_PAGES.to_vec(), Some(heap_pages.encode()));
|
||||
}
|
||||
|
||||
fn changes_trie_block() -> (Vec<u8>, Hash) {
|
||||
construct_block(
|
||||
&mut new_test_ext(COMPACT_CODE, true),
|
||||
1,
|
||||
GENESIS_HASH.into(),
|
||||
vec![
|
||||
CheckedExtrinsic {
|
||||
signed: None,
|
||||
function: Call::Timestamp(pallet_timestamp::Call::set(42 * 1000)),
|
||||
},
|
||||
CheckedExtrinsic {
|
||||
signed: Some((alice(), signed_extra(0, 0))),
|
||||
function: Call::Balances(pallet_balances::Call::transfer(bob().into(), 69 * DOLLARS)),
|
||||
},
|
||||
]
|
||||
)
|
||||
}
|
||||
|
||||
|
||||
/// block 1 and 2 must be created together to ensure transactions are only signed once (since they
|
||||
/// are not guaranteed to be deterministic) and to ensure that the correct state is propagated
|
||||
/// from block1's execution to block2 to derive the correct storage_root.
|
||||
fn blocks() -> ((Vec<u8>, Hash), (Vec<u8>, Hash)) {
|
||||
let mut t = new_test_ext(COMPACT_CODE, false);
|
||||
let block1 = construct_block(
|
||||
&mut t,
|
||||
1,
|
||||
GENESIS_HASH.into(),
|
||||
vec![
|
||||
CheckedExtrinsic {
|
||||
signed: None,
|
||||
function: Call::Timestamp(pallet_timestamp::Call::set(42 * 1000)),
|
||||
},
|
||||
CheckedExtrinsic {
|
||||
signed: Some((alice(), signed_extra(0, 0))),
|
||||
function: Call::Balances(pallet_balances::Call::transfer(bob().into(), 69 * DOLLARS)),
|
||||
},
|
||||
]
|
||||
);
|
||||
let block2 = construct_block(
|
||||
&mut t,
|
||||
2,
|
||||
block1.1.clone(),
|
||||
vec![
|
||||
CheckedExtrinsic {
|
||||
signed: None,
|
||||
function: Call::Timestamp(pallet_timestamp::Call::set(52 * 1000)),
|
||||
},
|
||||
CheckedExtrinsic {
|
||||
signed: Some((bob(), signed_extra(0, 0))),
|
||||
function: Call::Balances(pallet_balances::Call::transfer(alice().into(), 5 * DOLLARS)),
|
||||
},
|
||||
CheckedExtrinsic {
|
||||
signed: Some((alice(), signed_extra(1, 0))),
|
||||
function: Call::Balances(pallet_balances::Call::transfer(bob().into(), 15 * DOLLARS)),
|
||||
}
|
||||
]
|
||||
);
|
||||
|
||||
// session change => consensus authorities change => authorities change digest item appears
|
||||
let digest = Header::decode(&mut &block2.0[..]).unwrap().digest;
|
||||
assert_eq!(digest.logs().len(), 0);
|
||||
|
||||
(block1, block2)
|
||||
}
|
||||
|
||||
fn block_with_size(time: u64, nonce: u32, size: usize) -> (Vec<u8>, Hash) {
|
||||
construct_block(
|
||||
&mut new_test_ext(COMPACT_CODE, false),
|
||||
1,
|
||||
GENESIS_HASH.into(),
|
||||
vec![
|
||||
CheckedExtrinsic {
|
||||
signed: None,
|
||||
function: Call::Timestamp(pallet_timestamp::Call::set(time * 1000)),
|
||||
},
|
||||
CheckedExtrinsic {
|
||||
signed: Some((alice(), signed_extra(nonce, 0))),
|
||||
function: Call::System(frame_system::Call::remark(vec![0; size])),
|
||||
}
|
||||
]
|
||||
)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn panic_execution_with_foreign_code_gives_error() {
|
||||
let mut t = TestExternalities::<Blake2Hasher>::new_with_code(BLOATY_CODE, Storage {
|
||||
top: map![
|
||||
<pallet_balances::FreeBalance<Runtime>>::hashed_key_for(alice()) => {
|
||||
69_u128.encode()
|
||||
},
|
||||
<pallet_balances::TotalIssuance<Runtime>>::hashed_key().to_vec() => {
|
||||
69_u128.encode()
|
||||
},
|
||||
<pallet_indices::NextEnumSet<Runtime>>::hashed_key().to_vec() => {
|
||||
0_u128.encode()
|
||||
},
|
||||
<frame_system::BlockHash<Runtime>>::hashed_key_for(0) => {
|
||||
vec![0u8; 32]
|
||||
}
|
||||
],
|
||||
children: map![],
|
||||
});
|
||||
|
||||
let r = executor_call::<NeverNativeValue, fn() -> _>(
|
||||
&mut t,
|
||||
"Core_initialize_block",
|
||||
&vec![].and(&from_block_number(1u32)),
|
||||
true,
|
||||
None,
|
||||
).0;
|
||||
assert!(r.is_ok());
|
||||
let v = executor_call::<NeverNativeValue, fn() -> _>(
|
||||
&mut t,
|
||||
"BlockBuilder_apply_extrinsic",
|
||||
&vec![].and(&xt()),
|
||||
true,
|
||||
None,
|
||||
).0.unwrap();
|
||||
let r = ApplyExtrinsicResult::decode(&mut &v.as_encoded()[..]).unwrap();
|
||||
assert_eq!(r, Err(InvalidTransaction::Payment.into()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bad_extrinsic_with_native_equivalent_code_gives_error() {
|
||||
let mut t = TestExternalities::<Blake2Hasher>::new_with_code(COMPACT_CODE, Storage {
|
||||
top: map![
|
||||
<pallet_balances::FreeBalance<Runtime>>::hashed_key_for(alice()) => {
|
||||
69_u128.encode()
|
||||
},
|
||||
<pallet_balances::TotalIssuance<Runtime>>::hashed_key().to_vec() => {
|
||||
69_u128.encode()
|
||||
},
|
||||
<pallet_indices::NextEnumSet<Runtime>>::hashed_key().to_vec() => {
|
||||
0_u128.encode()
|
||||
},
|
||||
<frame_system::BlockHash<Runtime>>::hashed_key_for(0) => {
|
||||
vec![0u8; 32]
|
||||
}
|
||||
],
|
||||
children: map![],
|
||||
});
|
||||
|
||||
let r = executor_call::<NeverNativeValue, fn() -> _>(
|
||||
&mut t,
|
||||
"Core_initialize_block",
|
||||
&vec![].and(&from_block_number(1u32)),
|
||||
true,
|
||||
None,
|
||||
).0;
|
||||
assert!(r.is_ok());
|
||||
let v = executor_call::<NeverNativeValue, fn() -> _>(
|
||||
&mut t,
|
||||
"BlockBuilder_apply_extrinsic",
|
||||
&vec![].and(&xt()),
|
||||
true,
|
||||
None,
|
||||
).0.unwrap();
|
||||
let r = ApplyExtrinsicResult::decode(&mut &v.as_encoded()[..]).unwrap();
|
||||
assert_eq!(r, Err(InvalidTransaction::Payment.into()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn successful_execution_with_native_equivalent_code_gives_ok() {
|
||||
let mut t = TestExternalities::<Blake2Hasher>::new_with_code(COMPACT_CODE, Storage {
|
||||
top: map![
|
||||
<pallet_balances::FreeBalance<Runtime>>::hashed_key_for(alice()) => {
|
||||
(111 * DOLLARS).encode()
|
||||
},
|
||||
<pallet_balances::TotalIssuance<Runtime>>::hashed_key().to_vec() => {
|
||||
(111 * DOLLARS).encode()
|
||||
},
|
||||
<pallet_indices::NextEnumSet<Runtime>>::hashed_key().to_vec() => vec![0u8; 16],
|
||||
<frame_system::BlockHash<Runtime>>::hashed_key_for(0) => vec![0u8; 32]
|
||||
],
|
||||
children: map![],
|
||||
});
|
||||
|
||||
let r = executor_call::<NeverNativeValue, fn() -> _>(
|
||||
&mut t,
|
||||
"Core_initialize_block",
|
||||
&vec![].and(&from_block_number(1u32)),
|
||||
true,
|
||||
None,
|
||||
).0;
|
||||
assert!(r.is_ok());
|
||||
|
||||
let fm = t.execute_with(TransactionPayment::next_fee_multiplier);
|
||||
|
||||
let r = executor_call::<NeverNativeValue, fn() -> _>(
|
||||
&mut t,
|
||||
"BlockBuilder_apply_extrinsic",
|
||||
&vec![].and(&xt()),
|
||||
true,
|
||||
None,
|
||||
).0;
|
||||
assert!(r.is_ok());
|
||||
|
||||
t.execute_with(|| {
|
||||
assert_eq!(Balances::total_balance(&alice()), 42 * DOLLARS - transfer_fee(&xt(), fm));
|
||||
assert_eq!(Balances::total_balance(&bob()), 69 * DOLLARS);
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn successful_execution_with_foreign_code_gives_ok() {
|
||||
let mut t = TestExternalities::<Blake2Hasher>::new_with_code(BLOATY_CODE, Storage {
|
||||
top: map![
|
||||
<pallet_balances::FreeBalance<Runtime>>::hashed_key_for(alice()) => {
|
||||
(111 * DOLLARS).encode()
|
||||
},
|
||||
<pallet_balances::TotalIssuance<Runtime>>::hashed_key().to_vec() => {
|
||||
(111 * DOLLARS).encode()
|
||||
},
|
||||
<pallet_indices::NextEnumSet<Runtime>>::hashed_key().to_vec() => vec![0u8; 16],
|
||||
<frame_system::BlockHash<Runtime>>::hashed_key_for(0) => vec![0u8; 32]
|
||||
],
|
||||
children: map![],
|
||||
});
|
||||
|
||||
let r = executor_call::<NeverNativeValue, fn() -> _>(
|
||||
&mut t,
|
||||
"Core_initialize_block",
|
||||
&vec![].and(&from_block_number(1u32)),
|
||||
true,
|
||||
None,
|
||||
).0;
|
||||
assert!(r.is_ok());
|
||||
|
||||
let fm = t.execute_with(TransactionPayment::next_fee_multiplier);
|
||||
|
||||
let r = executor_call::<NeverNativeValue, fn() -> _>(
|
||||
&mut t,
|
||||
"BlockBuilder_apply_extrinsic",
|
||||
&vec![].and(&xt()),
|
||||
true,
|
||||
None,
|
||||
).0;
|
||||
assert!(r.is_ok());
|
||||
|
||||
t.execute_with(|| {
|
||||
assert_eq!(Balances::total_balance(&alice()), 42 * DOLLARS - transfer_fee(&xt(), fm));
|
||||
assert_eq!(Balances::total_balance(&bob()), 69 * DOLLARS);
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn full_native_block_import_works() {
|
||||
let mut t = new_test_ext(COMPACT_CODE, false);
|
||||
|
||||
let (block1, block2) = blocks();
|
||||
|
||||
let mut alice_last_known_balance: Balance = Default::default();
|
||||
let mut fm = t.execute_with(TransactionPayment::next_fee_multiplier);
|
||||
|
||||
executor_call::<NeverNativeValue, fn() -> _>(
|
||||
&mut t,
|
||||
"Core_execute_block",
|
||||
&block1.0,
|
||||
true,
|
||||
None,
|
||||
).0.unwrap();
|
||||
|
||||
t.execute_with(|| {
|
||||
assert_eq!(Balances::total_balance(&alice()), 42 * DOLLARS - transfer_fee(&xt(), fm));
|
||||
assert_eq!(Balances::total_balance(&bob()), 169 * DOLLARS);
|
||||
alice_last_known_balance = Balances::total_balance(&alice());
|
||||
let events = vec![
|
||||
EventRecord {
|
||||
phase: Phase::ApplyExtrinsic(0),
|
||||
event: Event::system(frame_system::Event::ExtrinsicSuccess(
|
||||
DispatchInfo { weight: 10000, class: DispatchClass::Operational, pays_fee: true }
|
||||
)),
|
||||
topics: vec![],
|
||||
},
|
||||
EventRecord {
|
||||
phase: Phase::ApplyExtrinsic(1),
|
||||
event: Event::pallet_treasury(pallet_treasury::RawEvent::Deposit(1984800000000)),
|
||||
topics: vec![],
|
||||
},
|
||||
EventRecord {
|
||||
phase: Phase::ApplyExtrinsic(1),
|
||||
event: Event::pallet_balances(pallet_balances::RawEvent::Transfer(
|
||||
alice().into(),
|
||||
bob().into(),
|
||||
69 * DOLLARS,
|
||||
1 * CENTS,
|
||||
)),
|
||||
topics: vec![],
|
||||
},
|
||||
EventRecord {
|
||||
phase: Phase::ApplyExtrinsic(1),
|
||||
event: Event::system(frame_system::Event::ExtrinsicSuccess(
|
||||
DispatchInfo { weight: 1000000, class: DispatchClass::Normal, pays_fee: true }
|
||||
)),
|
||||
topics: vec![],
|
||||
},
|
||||
];
|
||||
assert_eq!(System::events(), events);
|
||||
});
|
||||
|
||||
fm = t.execute_with(TransactionPayment::next_fee_multiplier);
|
||||
|
||||
executor_call::<NeverNativeValue, fn() -> _>(
|
||||
&mut t,
|
||||
"Core_execute_block",
|
||||
&block2.0,
|
||||
true,
|
||||
None,
|
||||
).0.unwrap();
|
||||
|
||||
t.execute_with(|| {
|
||||
assert_eq!(
|
||||
Balances::total_balance(&alice()),
|
||||
alice_last_known_balance - 10 * DOLLARS - transfer_fee(&xt(), fm),
|
||||
);
|
||||
assert_eq!(
|
||||
Balances::total_balance(&bob()),
|
||||
179 * DOLLARS - transfer_fee(&xt(), fm),
|
||||
);
|
||||
let events = vec![
|
||||
EventRecord {
|
||||
phase: Phase::ApplyExtrinsic(0),
|
||||
event: Event::system(frame_system::Event::ExtrinsicSuccess(
|
||||
DispatchInfo { weight: 10000, class: DispatchClass::Operational, pays_fee: true }
|
||||
)),
|
||||
topics: vec![],
|
||||
},
|
||||
EventRecord {
|
||||
phase: Phase::ApplyExtrinsic(1),
|
||||
event: Event::pallet_treasury(pallet_treasury::RawEvent::Deposit(1984788199392)),
|
||||
topics: vec![],
|
||||
},
|
||||
EventRecord {
|
||||
phase: Phase::ApplyExtrinsic(1),
|
||||
event: Event::pallet_balances(
|
||||
pallet_balances::RawEvent::Transfer(
|
||||
bob().into(),
|
||||
alice().into(),
|
||||
5 * DOLLARS,
|
||||
1 * CENTS,
|
||||
)
|
||||
),
|
||||
topics: vec![],
|
||||
},
|
||||
EventRecord {
|
||||
phase: Phase::ApplyExtrinsic(1),
|
||||
event: Event::system(frame_system::Event::ExtrinsicSuccess(
|
||||
DispatchInfo { weight: 1000000, class: DispatchClass::Normal, pays_fee: true }
|
||||
)),
|
||||
topics: vec![],
|
||||
},
|
||||
EventRecord {
|
||||
phase: Phase::ApplyExtrinsic(2),
|
||||
event: Event::pallet_treasury(pallet_treasury::RawEvent::Deposit(1984788199392)),
|
||||
topics: vec![],
|
||||
},
|
||||
EventRecord {
|
||||
phase: Phase::ApplyExtrinsic(2),
|
||||
event: Event::pallet_balances(
|
||||
pallet_balances::RawEvent::Transfer(
|
||||
alice().into(),
|
||||
bob().into(),
|
||||
15 * DOLLARS,
|
||||
1 * CENTS,
|
||||
)
|
||||
),
|
||||
topics: vec![],
|
||||
},
|
||||
EventRecord {
|
||||
phase: Phase::ApplyExtrinsic(2),
|
||||
event: Event::system(frame_system::Event::ExtrinsicSuccess(
|
||||
DispatchInfo { weight: 1000000, class: DispatchClass::Normal, pays_fee: true }
|
||||
)),
|
||||
topics: vec![],
|
||||
},
|
||||
];
|
||||
assert_eq!(System::events(), events);
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn full_wasm_block_import_works() {
|
||||
let mut t = new_test_ext(COMPACT_CODE, false);
|
||||
|
||||
let (block1, block2) = blocks();
|
||||
|
||||
let mut alice_last_known_balance: Balance = Default::default();
|
||||
let mut fm = t.execute_with(TransactionPayment::next_fee_multiplier);
|
||||
|
||||
executor_call::<NeverNativeValue, fn() -> _>(
|
||||
&mut t,
|
||||
"Core_execute_block",
|
||||
&block1.0,
|
||||
false,
|
||||
None,
|
||||
).0.unwrap();
|
||||
|
||||
t.execute_with(|| {
|
||||
assert_eq!(Balances::total_balance(&alice()), 42 * DOLLARS - transfer_fee(&xt(), fm));
|
||||
assert_eq!(Balances::total_balance(&bob()), 169 * DOLLARS);
|
||||
alice_last_known_balance = Balances::total_balance(&alice());
|
||||
});
|
||||
|
||||
fm = t.execute_with(TransactionPayment::next_fee_multiplier);
|
||||
|
||||
executor_call::<NeverNativeValue, fn() -> _>(
|
||||
&mut t,
|
||||
"Core_execute_block",
|
||||
&block2.0,
|
||||
false,
|
||||
None,
|
||||
).0.unwrap();
|
||||
|
||||
t.execute_with(|| {
|
||||
assert_eq!(
|
||||
Balances::total_balance(&alice()),
|
||||
alice_last_known_balance - 10 * DOLLARS - transfer_fee(&xt(), fm),
|
||||
);
|
||||
assert_eq!(
|
||||
Balances::total_balance(&bob()),
|
||||
179 * DOLLARS - 1 * transfer_fee(&xt(), fm),
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
const CODE_TRANSFER: &str = r#"
|
||||
(module
|
||||
;; ext_call(
|
||||
;; callee_ptr: u32,
|
||||
;; callee_len: u32,
|
||||
;; gas: u64,
|
||||
;; value_ptr: u32,
|
||||
;; value_len: u32,
|
||||
;; input_data_ptr: u32,
|
||||
;; input_data_len: u32
|
||||
;; ) -> u32
|
||||
(import "env" "ext_call" (func $ext_call (param i32 i32 i64 i32 i32 i32 i32) (result i32)))
|
||||
(import "env" "ext_scratch_size" (func $ext_scratch_size (result i32)))
|
||||
(import "env" "ext_scratch_read" (func $ext_scratch_read (param i32 i32 i32)))
|
||||
(import "env" "memory" (memory 1 1))
|
||||
(func (export "deploy")
|
||||
)
|
||||
(func (export "call")
|
||||
(block $fail
|
||||
;; load and check the input data (which is stored in the scratch buffer).
|
||||
;; fail if the input size is not != 4
|
||||
(br_if $fail
|
||||
(i32.ne
|
||||
(i32.const 4)
|
||||
(call $ext_scratch_size)
|
||||
)
|
||||
)
|
||||
|
||||
(call $ext_scratch_read
|
||||
(i32.const 0)
|
||||
(i32.const 0)
|
||||
(i32.const 4)
|
||||
)
|
||||
|
||||
|
||||
(br_if $fail
|
||||
(i32.ne
|
||||
(i32.load8_u (i32.const 0))
|
||||
(i32.const 0)
|
||||
)
|
||||
)
|
||||
(br_if $fail
|
||||
(i32.ne
|
||||
(i32.load8_u (i32.const 1))
|
||||
(i32.const 1)
|
||||
)
|
||||
)
|
||||
(br_if $fail
|
||||
(i32.ne
|
||||
(i32.load8_u (i32.const 2))
|
||||
(i32.const 2)
|
||||
)
|
||||
)
|
||||
(br_if $fail
|
||||
(i32.ne
|
||||
(i32.load8_u (i32.const 3))
|
||||
(i32.const 3)
|
||||
)
|
||||
)
|
||||
|
||||
(drop
|
||||
(call $ext_call
|
||||
(i32.const 4) ;; Pointer to "callee" address.
|
||||
(i32.const 32) ;; Length of "callee" address.
|
||||
(i64.const 0) ;; How much gas to devote for the execution. 0 = all.
|
||||
(i32.const 36) ;; Pointer to the buffer with value to transfer
|
||||
(i32.const 16) ;; Length of the buffer with value to transfer.
|
||||
(i32.const 0) ;; Pointer to input data buffer address
|
||||
(i32.const 0) ;; Length of input data buffer
|
||||
)
|
||||
)
|
||||
|
||||
(return)
|
||||
)
|
||||
unreachable
|
||||
)
|
||||
;; Destination AccountId to transfer the funds.
|
||||
;; Represented by H256 (32 bytes long) in little endian.
|
||||
(data (i32.const 4)
|
||||
"\09\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00"
|
||||
"\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00"
|
||||
"\00\00\00\00"
|
||||
)
|
||||
;; Amount of value to transfer.
|
||||
;; Represented by u128 (16 bytes long) in little endian.
|
||||
(data (i32.const 36)
|
||||
"\06\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00"
|
||||
"\00\00"
|
||||
)
|
||||
)
|
||||
"#;
|
||||
|
||||
#[test]
|
||||
fn deploying_wasm_contract_should_work() {
|
||||
let transfer_code = wabt::wat2wasm(CODE_TRANSFER).unwrap();
|
||||
let transfer_ch = <Runtime as frame_system::Trait>::Hashing::hash(&transfer_code);
|
||||
|
||||
let addr = <Runtime as pallet_contracts::Trait>::DetermineContractAddress::contract_address_for(
|
||||
&transfer_ch,
|
||||
&[],
|
||||
&charlie(),
|
||||
);
|
||||
|
||||
let b = construct_block(
|
||||
&mut new_test_ext(COMPACT_CODE, false),
|
||||
1,
|
||||
GENESIS_HASH.into(),
|
||||
vec![
|
||||
CheckedExtrinsic {
|
||||
signed: None,
|
||||
function: Call::Timestamp(pallet_timestamp::Call::set(42 * 1000)),
|
||||
},
|
||||
CheckedExtrinsic {
|
||||
signed: Some((charlie(), signed_extra(0, 0))),
|
||||
function: Call::Contracts(
|
||||
pallet_contracts::Call::put_code::<Runtime>(10_000, transfer_code)
|
||||
),
|
||||
},
|
||||
CheckedExtrinsic {
|
||||
signed: Some((charlie(), signed_extra(1, 0))),
|
||||
function: Call::Contracts(
|
||||
pallet_contracts::Call::instantiate::<Runtime>(1 * DOLLARS, 10_000, transfer_ch, Vec::new())
|
||||
),
|
||||
},
|
||||
CheckedExtrinsic {
|
||||
signed: Some((charlie(), signed_extra(2, 0))),
|
||||
function: Call::Contracts(
|
||||
pallet_contracts::Call::call::<Runtime>(
|
||||
pallet_indices::address::Address::Id(addr.clone()),
|
||||
10,
|
||||
10_000,
|
||||
vec![0x00, 0x01, 0x02, 0x03]
|
||||
)
|
||||
),
|
||||
},
|
||||
]
|
||||
);
|
||||
|
||||
let mut t = new_test_ext(COMPACT_CODE, false);
|
||||
|
||||
executor_call::<NeverNativeValue, fn() -> _>(
|
||||
&mut t,
|
||||
"Core_execute_block",
|
||||
&b.0,
|
||||
false,
|
||||
None,
|
||||
).0.unwrap();
|
||||
|
||||
t.execute_with(|| {
|
||||
// Verify that the contract constructor worked well and code of TRANSFER contract is actually deployed.
|
||||
assert_eq!(
|
||||
&pallet_contracts::ContractInfoOf::<Runtime>::get(addr)
|
||||
.and_then(|c| c.get_alive())
|
||||
.unwrap()
|
||||
.code_hash,
|
||||
&transfer_ch
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wasm_big_block_import_fails() {
|
||||
let mut t = new_test_ext(COMPACT_CODE, false);
|
||||
|
||||
set_heap_pages(&mut t.ext(), 4);
|
||||
|
||||
let result = executor_call::<NeverNativeValue, fn() -> _>(
|
||||
&mut t,
|
||||
"Core_execute_block",
|
||||
&block_with_size(42, 0, 120_000).0,
|
||||
false,
|
||||
None,
|
||||
).0;
|
||||
assert!(result.is_err()); // Err(Wasmi(Trap(Trap { kind: Host(AllocatorOutOfSpace) })))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn native_big_block_import_succeeds() {
|
||||
let mut t = new_test_ext(COMPACT_CODE, false);
|
||||
|
||||
executor_call::<NeverNativeValue, fn() -> _>(
|
||||
&mut t,
|
||||
"Core_execute_block",
|
||||
&block_with_size(42, 0, 120_000).0,
|
||||
true,
|
||||
None,
|
||||
).0.unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn native_big_block_import_fails_on_fallback() {
|
||||
let mut t = new_test_ext(COMPACT_CODE, false);
|
||||
|
||||
assert!(
|
||||
executor_call::<NeverNativeValue, fn() -> _>(
|
||||
&mut t,
|
||||
"Core_execute_block",
|
||||
&block_with_size(42, 0, 120_000).0,
|
||||
false,
|
||||
None,
|
||||
).0.is_err()
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn panic_execution_gives_error() {
|
||||
let mut t = TestExternalities::<Blake2Hasher>::new_with_code(BLOATY_CODE, Storage {
|
||||
top: map![
|
||||
<pallet_balances::FreeBalance<Runtime>>::hashed_key_for(alice()) => {
|
||||
0_u128.encode()
|
||||
},
|
||||
<pallet_balances::TotalIssuance<Runtime>>::hashed_key().to_vec() => {
|
||||
0_u128.encode()
|
||||
},
|
||||
<pallet_indices::NextEnumSet<Runtime>>::hashed_key().to_vec() => vec![0u8; 16],
|
||||
<frame_system::BlockHash<Runtime>>::hashed_key_for(0) => vec![0u8; 32]
|
||||
],
|
||||
children: map![],
|
||||
});
|
||||
|
||||
let r = executor_call::<NeverNativeValue, fn() -> _>(
|
||||
&mut t,
|
||||
"Core_initialize_block",
|
||||
&vec![].and(&from_block_number(1u32)),
|
||||
false,
|
||||
None,
|
||||
).0;
|
||||
assert!(r.is_ok());
|
||||
let r = executor_call::<NeverNativeValue, fn() -> _>(
|
||||
&mut t,
|
||||
"BlockBuilder_apply_extrinsic",
|
||||
&vec![].and(&xt()),
|
||||
false,
|
||||
None,
|
||||
).0.unwrap().into_encoded();
|
||||
let r = ApplyExtrinsicResult::decode(&mut &r[..]).unwrap();
|
||||
assert_eq!(r, Err(InvalidTransaction::Payment.into()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn successful_execution_gives_ok() {
|
||||
let mut t = TestExternalities::<Blake2Hasher>::new_with_code(COMPACT_CODE, Storage {
|
||||
top: map![
|
||||
<pallet_balances::FreeBalance<Runtime>>::hashed_key_for(alice()) => {
|
||||
(111 * DOLLARS).encode()
|
||||
},
|
||||
<pallet_balances::TotalIssuance<Runtime>>::hashed_key().to_vec() => {
|
||||
(111 * DOLLARS).encode()
|
||||
},
|
||||
<pallet_indices::NextEnumSet<Runtime>>::hashed_key().to_vec() => vec![0u8; 16],
|
||||
<frame_system::BlockHash<Runtime>>::hashed_key_for(0) => vec![0u8; 32]
|
||||
],
|
||||
children: map![],
|
||||
});
|
||||
|
||||
let r = executor_call::<NeverNativeValue, fn() -> _>(
|
||||
&mut t,
|
||||
"Core_initialize_block",
|
||||
&vec![].and(&from_block_number(1u32)),
|
||||
false,
|
||||
None,
|
||||
).0;
|
||||
assert!(r.is_ok());
|
||||
let fm = t.execute_with(TransactionPayment::next_fee_multiplier);
|
||||
let r = executor_call::<NeverNativeValue, fn() -> _>(
|
||||
&mut t,
|
||||
"BlockBuilder_apply_extrinsic",
|
||||
&vec![].and(&xt()),
|
||||
false,
|
||||
None,
|
||||
).0.unwrap().into_encoded();
|
||||
ApplyExtrinsicResult::decode(&mut &r[..])
|
||||
.unwrap()
|
||||
.expect("Extrinsic could be applied")
|
||||
.expect("Extrinsic did not fail");
|
||||
|
||||
t.execute_with(|| {
|
||||
assert_eq!(Balances::total_balance(&alice()), 42 * DOLLARS - 1 * transfer_fee(&xt(), fm));
|
||||
assert_eq!(Balances::total_balance(&bob()), 69 * DOLLARS);
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn full_native_block_import_works_with_changes_trie() {
|
||||
let block1 = changes_trie_block();
|
||||
let block_data = block1.0;
|
||||
let block = Block::decode(&mut &block_data[..]).unwrap();
|
||||
|
||||
let mut t = new_test_ext(COMPACT_CODE, true);
|
||||
executor_call::<NeverNativeValue, fn() -> _>(
|
||||
&mut t,
|
||||
"Core_execute_block",
|
||||
&block.encode(),
|
||||
true,
|
||||
None,
|
||||
).0.unwrap();
|
||||
|
||||
assert!(t.ext().storage_changes_root(&GENESIS_HASH).unwrap().is_some());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn full_wasm_block_import_works_with_changes_trie() {
|
||||
let block1 = changes_trie_block();
|
||||
|
||||
let mut t = new_test_ext(COMPACT_CODE, true);
|
||||
executor_call::<NeverNativeValue, fn() -> _>(
|
||||
&mut t,
|
||||
"Core_execute_block",
|
||||
&block1.0,
|
||||
false,
|
||||
None,
|
||||
).0.unwrap();
|
||||
|
||||
assert!(t.ext().storage_changes_root(&GENESIS_HASH).unwrap().is_some());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn should_import_block_with_test_client() {
|
||||
use node_testing::client::{
|
||||
ClientExt, TestClientBuilderExt, TestClientBuilder,
|
||||
sp_consensus::BlockOrigin,
|
||||
};
|
||||
|
||||
let client = TestClientBuilder::new().build();
|
||||
let block1 = changes_trie_block();
|
||||
let block_data = block1.0;
|
||||
let block = node_primitives::Block::decode(&mut &block_data[..]).unwrap();
|
||||
|
||||
client.import(BlockOrigin::Own, block).unwrap();
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,154 @@
|
||||
// Copyright 2018-2020 Parity Technologies (UK) Ltd.
|
||||
// This file is part of Substrate.
|
||||
|
||||
// Substrate is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
|
||||
// Substrate is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with Substrate. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
use codec::{Encode, Decode};
|
||||
use frame_support::{
|
||||
Hashable,
|
||||
};
|
||||
use sp_state_machine::TestExternalities as CoreTestExternalities;
|
||||
use sp_core::{
|
||||
Blake2Hasher, NeverNativeValue, NativeOrEncoded,
|
||||
traits::CodeExecutor,
|
||||
};
|
||||
use sp_runtime::traits::{Header as HeaderT};
|
||||
use sc_executor::{NativeExecutor, WasmExecutionMethod};
|
||||
use sc_executor::error::Result;
|
||||
|
||||
use node_executor::Executor;
|
||||
use node_runtime::{
|
||||
Header, Block, UncheckedExtrinsic, CheckedExtrinsic, Runtime, BuildStorage,
|
||||
constants::currency::*,
|
||||
};
|
||||
use node_primitives::{Hash, BlockNumber};
|
||||
use node_testing::keyring::*;
|
||||
|
||||
/// The wasm runtime code.
|
||||
///
|
||||
/// `compact` since it is after post-processing with wasm-gc which performs tree-shaking thus
|
||||
/// making the binary slimmer. There is a convention to use compact version of the runtime
|
||||
/// as canonical. This is why `native_executor_instance` also uses the compact version of the
|
||||
/// runtime.
|
||||
pub const COMPACT_CODE: &[u8] = node_runtime::WASM_BINARY;
|
||||
|
||||
pub const GENESIS_HASH: [u8; 32] = [69u8; 32];
|
||||
|
||||
pub const VERSION: u32 = node_runtime::VERSION.spec_version;
|
||||
|
||||
pub type TestExternalities<H> = CoreTestExternalities<H, u64>;
|
||||
|
||||
pub fn sign(xt: CheckedExtrinsic) -> UncheckedExtrinsic {
|
||||
node_testing::keyring::sign(xt, VERSION, GENESIS_HASH)
|
||||
}
|
||||
|
||||
pub fn default_transfer_call() -> pallet_balances::Call<Runtime> {
|
||||
pallet_balances::Call::transfer::<Runtime>(bob().into(), 69 * DOLLARS)
|
||||
}
|
||||
|
||||
pub fn from_block_number(n: u32) -> Header {
|
||||
Header::new(n, Default::default(), Default::default(), [69; 32].into(), Default::default())
|
||||
}
|
||||
|
||||
pub fn executor() -> NativeExecutor<Executor> {
|
||||
NativeExecutor::new(WasmExecutionMethod::Interpreted, None)
|
||||
}
|
||||
|
||||
pub fn executor_call<
|
||||
R:Decode + Encode + PartialEq,
|
||||
NC: FnOnce() -> std::result::Result<R, String> + std::panic::UnwindSafe
|
||||
>(
|
||||
t: &mut TestExternalities<Blake2Hasher>,
|
||||
method: &str,
|
||||
data: &[u8],
|
||||
use_native: bool,
|
||||
native_call: Option<NC>,
|
||||
) -> (Result<NativeOrEncoded<R>>, bool) {
|
||||
let mut t = t.ext();
|
||||
executor().call::<_, R, NC>(
|
||||
&mut t,
|
||||
method,
|
||||
data,
|
||||
use_native,
|
||||
native_call,
|
||||
)
|
||||
}
|
||||
|
||||
pub fn new_test_ext(code: &[u8], support_changes_trie: bool) -> TestExternalities<Blake2Hasher> {
|
||||
let mut ext = TestExternalities::new_with_code(
|
||||
code,
|
||||
node_testing::genesis::config(support_changes_trie, Some(code)).build_storage().unwrap(),
|
||||
);
|
||||
ext.changes_trie_storage().insert(0, GENESIS_HASH.into(), Default::default());
|
||||
ext
|
||||
}
|
||||
|
||||
pub fn construct_block(
|
||||
env: &mut TestExternalities<Blake2Hasher>,
|
||||
number: BlockNumber,
|
||||
parent_hash: Hash,
|
||||
extrinsics: Vec<CheckedExtrinsic>,
|
||||
) -> (Vec<u8>, Hash) {
|
||||
use sp_trie::{TrieConfiguration, trie_types::Layout};
|
||||
|
||||
// sign extrinsics.
|
||||
let extrinsics = extrinsics.into_iter().map(sign).collect::<Vec<_>>();
|
||||
|
||||
// calculate the header fields that we can.
|
||||
let extrinsics_root = Layout::<Blake2Hasher>::ordered_trie_root(
|
||||
extrinsics.iter().map(Encode::encode)
|
||||
).to_fixed_bytes()
|
||||
.into();
|
||||
|
||||
let header = Header {
|
||||
parent_hash,
|
||||
number,
|
||||
extrinsics_root,
|
||||
state_root: Default::default(),
|
||||
digest: Default::default(),
|
||||
};
|
||||
|
||||
// execute the block to get the real header.
|
||||
executor_call::<NeverNativeValue, fn() -> _>(
|
||||
env,
|
||||
"Core_initialize_block",
|
||||
&header.encode(),
|
||||
true,
|
||||
None,
|
||||
).0.unwrap();
|
||||
|
||||
for i in extrinsics.iter() {
|
||||
executor_call::<NeverNativeValue, fn() -> _>(
|
||||
env,
|
||||
"BlockBuilder_apply_extrinsic",
|
||||
&i.encode(),
|
||||
true,
|
||||
None,
|
||||
).0.unwrap();
|
||||
}
|
||||
|
||||
let header = match executor_call::<NeverNativeValue, fn() -> _>(
|
||||
env,
|
||||
"BlockBuilder_finalize_block",
|
||||
&[0u8;0],
|
||||
true,
|
||||
None,
|
||||
).0.unwrap() {
|
||||
NativeOrEncoded::Native(_) => unreachable!(),
|
||||
NativeOrEncoded::Encoded(h) => Header::decode(&mut &h[..]).unwrap(),
|
||||
};
|
||||
|
||||
let hash = header.blake2_256();
|
||||
(Block { header, extrinsics }.encode(), hash.into())
|
||||
}
|
||||
@@ -0,0 +1,332 @@
|
||||
// Copyright 2018-2020 Parity Technologies (UK) Ltd.
|
||||
// This file is part of Substrate.
|
||||
|
||||
// Substrate is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
|
||||
// Substrate is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with Substrate. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
use codec::{Encode, Joiner};
|
||||
use frame_support::{
|
||||
StorageValue, StorageMap,
|
||||
traits::Currency,
|
||||
weights::GetDispatchInfo,
|
||||
};
|
||||
use sp_core::{
|
||||
Blake2Hasher, NeverNativeValue, map,
|
||||
storage::Storage,
|
||||
};
|
||||
use sp_runtime::{
|
||||
Fixed64,
|
||||
traits::Convert,
|
||||
};
|
||||
use node_runtime::{
|
||||
CheckedExtrinsic, Call, Runtime, Balances,
|
||||
TransactionPayment, TransferFee, TransactionBaseFee, TransactionByteFee,
|
||||
WeightFeeCoefficient, constants::currency::*,
|
||||
};
|
||||
use node_runtime::impls::LinearWeightToFee;
|
||||
use node_primitives::Balance;
|
||||
use node_testing::keyring::*;
|
||||
|
||||
mod common;
|
||||
use self::common::{*, sign};
|
||||
|
||||
#[test]
|
||||
fn fee_multiplier_increases_and_decreases_on_big_weight() {
|
||||
let mut t = new_test_ext(COMPACT_CODE, false);
|
||||
|
||||
// initial fee multiplier must be zero
|
||||
let mut prev_multiplier = Fixed64::from_parts(0);
|
||||
|
||||
t.execute_with(|| {
|
||||
assert_eq!(TransactionPayment::next_fee_multiplier(), prev_multiplier);
|
||||
});
|
||||
|
||||
let mut tt = new_test_ext(COMPACT_CODE, false);
|
||||
|
||||
// big one in terms of weight.
|
||||
let block1 = construct_block(
|
||||
&mut tt,
|
||||
1,
|
||||
GENESIS_HASH.into(),
|
||||
vec![
|
||||
CheckedExtrinsic {
|
||||
signed: None,
|
||||
function: Call::Timestamp(pallet_timestamp::Call::set(42 * 1000)),
|
||||
},
|
||||
CheckedExtrinsic {
|
||||
signed: Some((charlie(), signed_extra(0, 0))),
|
||||
function: Call::System(frame_system::Call::fill_block()),
|
||||
}
|
||||
]
|
||||
);
|
||||
|
||||
// small one in terms of weight.
|
||||
let block2 = construct_block(
|
||||
&mut tt,
|
||||
2,
|
||||
block1.1.clone(),
|
||||
vec![
|
||||
CheckedExtrinsic {
|
||||
signed: None,
|
||||
function: Call::Timestamp(pallet_timestamp::Call::set(52 * 1000)),
|
||||
},
|
||||
CheckedExtrinsic {
|
||||
signed: Some((charlie(), signed_extra(1, 0))),
|
||||
function: Call::System(frame_system::Call::remark(vec![0; 1])),
|
||||
}
|
||||
]
|
||||
);
|
||||
|
||||
println!("++ Block 1 size: {} / Block 2 size {}", block1.0.encode().len(), block2.0.encode().len());
|
||||
|
||||
// execute a big block.
|
||||
executor_call::<NeverNativeValue, fn() -> _>(
|
||||
&mut t,
|
||||
"Core_execute_block",
|
||||
&block1.0,
|
||||
true,
|
||||
None,
|
||||
).0.unwrap();
|
||||
|
||||
// weight multiplier is increased for next block.
|
||||
t.execute_with(|| {
|
||||
let fm = TransactionPayment::next_fee_multiplier();
|
||||
println!("After a big block: {:?} -> {:?}", prev_multiplier, fm);
|
||||
assert!(fm > prev_multiplier);
|
||||
prev_multiplier = fm;
|
||||
});
|
||||
|
||||
// execute a big block.
|
||||
executor_call::<NeverNativeValue, fn() -> _>(
|
||||
&mut t,
|
||||
"Core_execute_block",
|
||||
&block2.0,
|
||||
true,
|
||||
None,
|
||||
).0.unwrap();
|
||||
|
||||
// weight multiplier is increased for next block.
|
||||
t.execute_with(|| {
|
||||
let fm = TransactionPayment::next_fee_multiplier();
|
||||
println!("After a small block: {:?} -> {:?}", prev_multiplier, fm);
|
||||
assert!(fm < prev_multiplier);
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn transaction_fee_is_correct_ultimate() {
|
||||
// This uses the exact values of substrate-node.
|
||||
//
|
||||
// weight of transfer call as of now: 1_000_000
|
||||
// if weight of the cheapest weight would be 10^7, this would be 10^9, which is:
|
||||
// - 1 MILLICENTS in substrate node.
|
||||
// - 1 milli-dot based on current polkadot runtime.
|
||||
// (this baed on assigning 0.1 CENT to the cheapest tx with `weight = 100`)
|
||||
let mut t = TestExternalities::<Blake2Hasher>::new_with_code(COMPACT_CODE, Storage {
|
||||
top: map![
|
||||
<pallet_balances::FreeBalance<Runtime>>::hashed_key_for(alice()) => {
|
||||
(100 * DOLLARS).encode()
|
||||
},
|
||||
<pallet_balances::FreeBalance<Runtime>>::hashed_key_for(bob()) => {
|
||||
(10 * DOLLARS).encode()
|
||||
},
|
||||
<pallet_balances::TotalIssuance<Runtime>>::hashed_key().to_vec() => {
|
||||
(110 * DOLLARS).encode()
|
||||
},
|
||||
<pallet_indices::NextEnumSet<Runtime>>::hashed_key().to_vec() => vec![0u8; 16],
|
||||
<frame_system::BlockHash<Runtime>>::hashed_key_for(0) => vec![0u8; 32]
|
||||
],
|
||||
children: map![],
|
||||
});
|
||||
|
||||
let tip = 1_000_000;
|
||||
let xt = sign(CheckedExtrinsic {
|
||||
signed: Some((alice(), signed_extra(0, tip))),
|
||||
function: Call::Balances(default_transfer_call()),
|
||||
});
|
||||
|
||||
let r = executor_call::<NeverNativeValue, fn() -> _>(
|
||||
&mut t,
|
||||
"Core_initialize_block",
|
||||
&vec![].and(&from_block_number(1u32)),
|
||||
true,
|
||||
None,
|
||||
).0;
|
||||
|
||||
assert!(r.is_ok());
|
||||
let r = executor_call::<NeverNativeValue, fn() -> _>(
|
||||
&mut t,
|
||||
"BlockBuilder_apply_extrinsic",
|
||||
&vec![].and(&xt.clone()),
|
||||
true,
|
||||
None,
|
||||
).0;
|
||||
assert!(r.is_ok());
|
||||
|
||||
t.execute_with(|| {
|
||||
assert_eq!(Balances::total_balance(&bob()), (10 + 69) * DOLLARS);
|
||||
// Components deducted from alice's balances:
|
||||
// - Weight fee
|
||||
// - Length fee
|
||||
// - Tip
|
||||
// - Creation-fee of bob's account.
|
||||
let mut balance_alice = (100 - 69) * DOLLARS;
|
||||
|
||||
let length_fee = TransactionBaseFee::get() +
|
||||
TransactionByteFee::get() *
|
||||
(xt.clone().encode().len() as Balance);
|
||||
balance_alice -= length_fee;
|
||||
|
||||
let weight = default_transfer_call().get_dispatch_info().weight;
|
||||
let weight_fee = LinearWeightToFee::<WeightFeeCoefficient>::convert(weight);
|
||||
|
||||
// we know that weight to fee multiplier is effect-less in block 1.
|
||||
assert_eq!(weight_fee as Balance, MILLICENTS);
|
||||
balance_alice -= weight_fee;
|
||||
|
||||
balance_alice -= tip;
|
||||
balance_alice -= TransferFee::get();
|
||||
|
||||
assert_eq!(Balances::total_balance(&alice()), balance_alice);
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
#[cfg(feature = "stress-test")]
|
||||
fn block_weight_capacity_report() {
|
||||
// Just report how many transfer calls you could fit into a block. The number should at least
|
||||
// be a few hundred (250 at the time of writing but can change over time). Runs until panic.
|
||||
use node_primitives::Index;
|
||||
|
||||
// execution ext.
|
||||
let mut t = new_test_ext(COMPACT_CODE, false);
|
||||
// setup ext.
|
||||
let mut tt = new_test_ext(COMPACT_CODE, false);
|
||||
|
||||
let factor = 50;
|
||||
let mut time = 10;
|
||||
let mut nonce: Index = 0;
|
||||
let mut block_number = 1;
|
||||
let mut previous_hash: Hash = GENESIS_HASH.into();
|
||||
|
||||
loop {
|
||||
let num_transfers = block_number * factor;
|
||||
let mut xts = (0..num_transfers).map(|i| CheckedExtrinsic {
|
||||
signed: Some((charlie(), signed_extra(nonce + i as Index, 0))),
|
||||
function: Call::Balances(pallet_balances::Call::transfer(bob().into(), 0)),
|
||||
}).collect::<Vec<CheckedExtrinsic>>();
|
||||
|
||||
xts.insert(0, CheckedExtrinsic {
|
||||
signed: None,
|
||||
function: Call::Timestamp(pallet_timestamp::Call::set(time * 1000)),
|
||||
});
|
||||
|
||||
// NOTE: this is super slow. Can probably be improved.
|
||||
let block = construct_block(
|
||||
&mut tt,
|
||||
block_number,
|
||||
previous_hash,
|
||||
xts
|
||||
);
|
||||
|
||||
let len = block.0.len();
|
||||
print!(
|
||||
"++ Executing block with {} transfers. Block size = {} bytes / {} kb / {} mb",
|
||||
num_transfers,
|
||||
len,
|
||||
len / 1024,
|
||||
len / 1024 / 1024,
|
||||
);
|
||||
|
||||
let r = executor_call::<NeverNativeValue, fn() -> _>(
|
||||
&mut t,
|
||||
"Core_execute_block",
|
||||
&block.0,
|
||||
true,
|
||||
None,
|
||||
).0;
|
||||
|
||||
println!(" || Result = {:?}", r);
|
||||
assert!(r.is_ok());
|
||||
|
||||
previous_hash = block.1;
|
||||
nonce += num_transfers;
|
||||
time += 10;
|
||||
block_number += 1;
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
#[cfg(feature = "stress-test")]
|
||||
fn block_length_capacity_report() {
|
||||
// Just report how big a block can get. Executes until panic. Should be ignored unless if
|
||||
// manually inspected. The number should at least be a few megabytes (5 at the time of
|
||||
// writing but can change over time).
|
||||
use node_primitives::Index;
|
||||
|
||||
// execution ext.
|
||||
let mut t = new_test_ext(COMPACT_CODE, false);
|
||||
// setup ext.
|
||||
let mut tt = new_test_ext(COMPACT_CODE, false);
|
||||
|
||||
let factor = 256 * 1024;
|
||||
let mut time = 10;
|
||||
let mut nonce: Index = 0;
|
||||
let mut block_number = 1;
|
||||
let mut previous_hash: Hash = GENESIS_HASH.into();
|
||||
|
||||
loop {
|
||||
// NOTE: this is super slow. Can probably be improved.
|
||||
let block = construct_block(
|
||||
&mut tt,
|
||||
block_number,
|
||||
previous_hash,
|
||||
vec![
|
||||
CheckedExtrinsic {
|
||||
signed: None,
|
||||
function: Call::Timestamp(pallet_timestamp::Call::set(time * 1000)),
|
||||
},
|
||||
CheckedExtrinsic {
|
||||
signed: Some((charlie(), signed_extra(nonce, 0))),
|
||||
function: Call::System(frame_system::Call::remark(vec![0u8; (block_number * factor) as usize])),
|
||||
},
|
||||
]
|
||||
);
|
||||
|
||||
let len = block.0.len();
|
||||
print!(
|
||||
"++ Executing block with big remark. Block size = {} bytes / {} kb / {} mb",
|
||||
len,
|
||||
len / 1024,
|
||||
len / 1024 / 1024,
|
||||
);
|
||||
|
||||
let r = executor_call::<NeverNativeValue, fn() -> _>(
|
||||
&mut t,
|
||||
"Core_execute_block",
|
||||
&block.0,
|
||||
true,
|
||||
None,
|
||||
).0;
|
||||
|
||||
println!(" || Result = {:?}", r);
|
||||
assert!(r.is_ok());
|
||||
|
||||
previous_hash = block.1;
|
||||
nonce += 1;
|
||||
time += 10;
|
||||
block_number += 1;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,184 @@
|
||||
// Copyright 2018-2020 Parity Technologies (UK) Ltd.
|
||||
// This file is part of Substrate.
|
||||
|
||||
// Substrate is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
|
||||
// Substrate is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with Substrate. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
use node_runtime::{
|
||||
Call, Executive, Indices, Runtime, SubmitTransaction, UncheckedExtrinsic,
|
||||
};
|
||||
use sp_application_crypto::AppKey;
|
||||
use sp_core::testing::KeyStore;
|
||||
use sp_core::traits::KeystoreExt;
|
||||
use sp_core::offchain::{
|
||||
TransactionPoolExt,
|
||||
testing::TestTransactionPoolExt,
|
||||
};
|
||||
use frame_system::offchain::{SubmitSignedTransaction, SubmitUnsignedTransaction};
|
||||
use pallet_im_online::sr25519::AuthorityPair as Key;
|
||||
use codec::Decode;
|
||||
|
||||
mod common;
|
||||
use self::common::*;
|
||||
|
||||
#[test]
|
||||
fn should_submit_unsigned_transaction() {
|
||||
let mut t = new_test_ext(COMPACT_CODE, false);
|
||||
let (pool, state) = TestTransactionPoolExt::new();
|
||||
t.register_extension(TransactionPoolExt::new(pool));
|
||||
|
||||
t.execute_with(|| {
|
||||
let signature = Default::default();
|
||||
let heartbeat_data = pallet_im_online::Heartbeat {
|
||||
block_number: 1,
|
||||
network_state: Default::default(),
|
||||
session_index: 1,
|
||||
authority_index: 0,
|
||||
};
|
||||
|
||||
let call = pallet_im_online::Call::heartbeat(heartbeat_data, signature);
|
||||
<SubmitTransaction as SubmitUnsignedTransaction<Runtime, Call>>
|
||||
::submit_unsigned(call)
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(state.read().transactions.len(), 1)
|
||||
});
|
||||
}
|
||||
|
||||
const PHRASE: &str = "news slush supreme milk chapter athlete soap sausage put clutch what kitten";
|
||||
|
||||
#[test]
|
||||
fn should_submit_signed_transaction() {
|
||||
let mut t = new_test_ext(COMPACT_CODE, false);
|
||||
let (pool, state) = TestTransactionPoolExt::new();
|
||||
t.register_extension(TransactionPoolExt::new(pool));
|
||||
|
||||
let keystore = KeyStore::new();
|
||||
keystore.write().sr25519_generate_new(Key::ID, Some(&format!("{}/hunter1", PHRASE))).unwrap();
|
||||
keystore.write().sr25519_generate_new(Key::ID, Some(&format!("{}/hunter2", PHRASE))).unwrap();
|
||||
keystore.write().sr25519_generate_new(Key::ID, Some(&format!("{}/hunter3", PHRASE))).unwrap();
|
||||
t.register_extension(KeystoreExt(keystore));
|
||||
|
||||
t.execute_with(|| {
|
||||
let keys = <SubmitTransaction as SubmitSignedTransaction<Runtime, Call>>
|
||||
::find_all_local_keys();
|
||||
assert_eq!(keys.len(), 3, "Missing keys: {:?}", keys);
|
||||
|
||||
let can_sign = <SubmitTransaction as SubmitSignedTransaction<Runtime, Call>>
|
||||
::can_sign();
|
||||
assert!(can_sign, "Since there are keys, `can_sign` should return true");
|
||||
|
||||
let call = pallet_balances::Call::transfer(Default::default(), Default::default());
|
||||
let results =
|
||||
<SubmitTransaction as SubmitSignedTransaction<Runtime, Call>>::submit_signed(call);
|
||||
|
||||
let len = results.len();
|
||||
assert_eq!(len, 3);
|
||||
assert_eq!(results.into_iter().filter_map(|x| x.1.ok()).count(), len);
|
||||
assert_eq!(state.read().transactions.len(), len);
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn should_submit_signed_twice_from_the_same_account() {
|
||||
let mut t = new_test_ext(COMPACT_CODE, false);
|
||||
let (pool, state) = TestTransactionPoolExt::new();
|
||||
t.register_extension(TransactionPoolExt::new(pool));
|
||||
|
||||
let keystore = KeyStore::new();
|
||||
keystore.write().sr25519_generate_new(Key::ID, Some(&format!("{}/hunter1", PHRASE))).unwrap();
|
||||
t.register_extension(KeystoreExt(keystore));
|
||||
|
||||
t.execute_with(|| {
|
||||
let call = pallet_balances::Call::transfer(Default::default(), Default::default());
|
||||
let results =
|
||||
<SubmitTransaction as SubmitSignedTransaction<Runtime, Call>>::submit_signed(call);
|
||||
|
||||
let len = results.len();
|
||||
assert_eq!(len, 1);
|
||||
assert_eq!(results.into_iter().filter_map(|x| x.1.ok()).count(), len);
|
||||
assert_eq!(state.read().transactions.len(), 1);
|
||||
|
||||
// submit another one from the same account. The nonce should be incremented.
|
||||
let call = pallet_balances::Call::transfer(Default::default(), Default::default());
|
||||
let results =
|
||||
<SubmitTransaction as SubmitSignedTransaction<Runtime, Call>>::submit_signed(call);
|
||||
|
||||
let len = results.len();
|
||||
assert_eq!(len, 1);
|
||||
assert_eq!(results.into_iter().filter_map(|x| x.1.ok()).count(), len);
|
||||
assert_eq!(state.read().transactions.len(), 2);
|
||||
|
||||
// now check that the transaction nonces are not equal
|
||||
let s = state.read();
|
||||
fn nonce(tx: UncheckedExtrinsic) -> frame_system::CheckNonce<Runtime> {
|
||||
let extra = tx.signature.unwrap().2;
|
||||
extra.3
|
||||
}
|
||||
let nonce1 = nonce(UncheckedExtrinsic::decode(&mut &*s.transactions[0]).unwrap());
|
||||
let nonce2 = nonce(UncheckedExtrinsic::decode(&mut &*s.transactions[1]).unwrap());
|
||||
assert!(
|
||||
nonce1 != nonce2,
|
||||
"Transactions should have different nonces. Got: {:?}", nonce1
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn submitted_transaction_should_be_valid() {
|
||||
use codec::Encode;
|
||||
use frame_support::storage::StorageMap;
|
||||
use sp_runtime::transaction_validity::ValidTransaction;
|
||||
use sp_runtime::traits::StaticLookup;
|
||||
|
||||
let mut t = new_test_ext(COMPACT_CODE, false);
|
||||
let (pool, state) = TestTransactionPoolExt::new();
|
||||
t.register_extension(TransactionPoolExt::new(pool));
|
||||
|
||||
let keystore = KeyStore::new();
|
||||
keystore.write().sr25519_generate_new(Key::ID, Some(&format!("{}/hunter1", PHRASE))).unwrap();
|
||||
t.register_extension(KeystoreExt(keystore));
|
||||
|
||||
t.execute_with(|| {
|
||||
let call = pallet_balances::Call::transfer(Default::default(), Default::default());
|
||||
let results =
|
||||
<SubmitTransaction as SubmitSignedTransaction<Runtime, Call>>::submit_signed(call);
|
||||
let len = results.len();
|
||||
assert_eq!(len, 1);
|
||||
assert_eq!(results.into_iter().filter_map(|x| x.1.ok()).count(), len);
|
||||
});
|
||||
|
||||
// check that transaction is valid, but reset environment storage,
|
||||
// since CreateTransaction increments the nonce
|
||||
let tx0 = state.read().transactions[0].clone();
|
||||
let mut t = new_test_ext(COMPACT_CODE, false);
|
||||
t.execute_with(|| {
|
||||
let extrinsic = UncheckedExtrinsic::decode(&mut &*tx0).unwrap();
|
||||
// add balance to the account
|
||||
let author = extrinsic.signature.clone().unwrap().0;
|
||||
let address = Indices::lookup(author).unwrap();
|
||||
<pallet_balances::FreeBalance<Runtime, _>>::insert(&address, 5_000_000_000_000);
|
||||
|
||||
// check validity
|
||||
let res = Executive::validate_transaction(extrinsic);
|
||||
|
||||
assert_eq!(res.unwrap(), ValidTransaction {
|
||||
priority: 2_411_002_000_000,
|
||||
requires: vec![],
|
||||
provides: vec![(address, 0).encode()],
|
||||
longevity: 127,
|
||||
propagate: true,
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
@@ -22,7 +22,7 @@
|
||||
|
||||
use sp_std::prelude::*;
|
||||
use frame_support::{
|
||||
construct_runtime, parameter_types,
|
||||
construct_runtime, parameter_types, debug,
|
||||
weights::Weight,
|
||||
traits::{SplitTwoWays, Currency, Randomness},
|
||||
};
|
||||
@@ -35,7 +35,7 @@ use sp_runtime::{
|
||||
use sp_runtime::curve::PiecewiseLinear;
|
||||
use sp_runtime::transaction_validity::TransactionValidity;
|
||||
use sp_runtime::traits::{
|
||||
self, BlakeTwo256, Block as BlockT, NumberFor, StaticLookup, SaturatedConversion,
|
||||
self, BlakeTwo256, Block as BlockT, StaticLookup, SaturatedConversion,
|
||||
OpaqueKeys,
|
||||
};
|
||||
use sp_version::RuntimeVersion;
|
||||
@@ -448,7 +448,8 @@ impl pallet_sudo::Trait for Runtime {
|
||||
type Proposal = Call;
|
||||
}
|
||||
|
||||
type SubmitTransaction = TransactionSubmitter<ImOnlineId, Runtime, UncheckedExtrinsic>;
|
||||
/// A runtime transaction submitter.
|
||||
pub type SubmitTransaction = TransactionSubmitter<ImOnlineId, Runtime, UncheckedExtrinsic>;
|
||||
|
||||
parameter_types! {
|
||||
pub const SessionDuration: BlockNumber = EPOCH_DURATION_IN_SLOTS as _;
|
||||
@@ -517,7 +518,11 @@ impl frame_system::offchain::CreateTransaction<Runtime, UncheckedExtrinsic> for
|
||||
.checked_next_power_of_two()
|
||||
.map(|c| c / 2)
|
||||
.unwrap_or(2) as u64;
|
||||
let current_block = System::block_number().saturated_into::<u64>();
|
||||
let current_block = System::block_number()
|
||||
.saturated_into::<u64>()
|
||||
// The `System::block_number` is initialized with `n+1`,
|
||||
// so the actual block number is `n`.
|
||||
.saturating_sub(1);
|
||||
let tip = 0;
|
||||
let extra: SignedExtra = (
|
||||
frame_system::CheckVersion::<Runtime>::new(),
|
||||
@@ -528,7 +533,9 @@ impl frame_system::offchain::CreateTransaction<Runtime, UncheckedExtrinsic> for
|
||||
pallet_transaction_payment::ChargeTransactionPayment::<Runtime>::from(tip),
|
||||
Default::default(),
|
||||
);
|
||||
let raw_payload = SignedPayload::new(call, extra).ok()?;
|
||||
let raw_payload = SignedPayload::new(call, extra).map_err(|e| {
|
||||
debug::warn!("Unable to create signed payload: {:?}", e);
|
||||
}).ok()?;
|
||||
let signature = TSigner::sign(public, &raw_payload)?;
|
||||
let address = Indices::unlookup(account);
|
||||
let (call, extra, _) = raw_payload.deconstruct();
|
||||
@@ -649,8 +656,8 @@ impl_runtime_apis! {
|
||||
}
|
||||
|
||||
impl sp_offchain::OffchainWorkerApi<Block> for Runtime {
|
||||
fn offchain_worker(number: NumberFor<Block>) {
|
||||
Executive::offchain_worker(number)
|
||||
fn offchain_worker(header: &<Block as BlockT>::Header) {
|
||||
Executive::offchain_worker(header)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -750,22 +757,29 @@ impl_runtime_apis! {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use frame_system::offchain::SubmitSignedTransaction;
|
||||
|
||||
fn is_submit_signed_transaction<T>(_arg: T) where
|
||||
T: SubmitSignedTransaction<
|
||||
Runtime,
|
||||
Call,
|
||||
Extrinsic=UncheckedExtrinsic,
|
||||
CreateTransaction=Runtime,
|
||||
Signer=ImOnlineId,
|
||||
>,
|
||||
{}
|
||||
use frame_system::offchain::{SignAndSubmitTransaction, SubmitSignedTransaction};
|
||||
|
||||
#[test]
|
||||
fn validate_bounds() {
|
||||
let x = SubmitTransaction::default();
|
||||
is_submit_signed_transaction(x);
|
||||
fn validate_transaction_submitter_bounds() {
|
||||
fn is_submit_signed_transaction<T>() where
|
||||
T: SubmitSignedTransaction<
|
||||
Runtime,
|
||||
Call,
|
||||
>,
|
||||
{}
|
||||
|
||||
fn is_sign_and_submit_transaction<T>() where
|
||||
T: SignAndSubmitTransaction<
|
||||
Runtime,
|
||||
Call,
|
||||
Extrinsic=UncheckedExtrinsic,
|
||||
CreateTransaction=Runtime,
|
||||
Signer=ImOnlineId,
|
||||
>,
|
||||
{}
|
||||
|
||||
is_submit_signed_transaction::<SubmitTransaction>();
|
||||
is_sign_and_submit_transaction::<SubmitTransaction>();
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -23,7 +23,9 @@ use sp_runtime::generic::Era;
|
||||
use codec::Encode;
|
||||
|
||||
/// Alice's account id.
|
||||
pub fn alice() -> AccountId { AccountKeyring::Alice.into() }
|
||||
pub fn alice() -> AccountId {
|
||||
AccountKeyring::Alice.into()
|
||||
}
|
||||
|
||||
/// Bob's account id.
|
||||
pub fn bob() -> AccountId {
|
||||
|
||||
@@ -42,7 +42,7 @@ use futures::future::Future;
|
||||
use log::{debug, warn};
|
||||
use sc_network::NetworkStateInfo;
|
||||
use sp_core::{offchain::{self, OffchainStorage}, ExecutionContext};
|
||||
use sp_runtime::{generic::BlockId, traits::{self, ProvideRuntimeApi}};
|
||||
use sp_runtime::{generic::BlockId, traits::{self, ProvideRuntimeApi, Header}};
|
||||
|
||||
mod api;
|
||||
|
||||
@@ -92,33 +92,47 @@ impl<Client, Storage, Block> OffchainWorkers<
|
||||
#[must_use]
|
||||
pub fn on_block_imported(
|
||||
&self,
|
||||
number: &<Block::Header as traits::Header>::Number,
|
||||
header: &Block::Header,
|
||||
network_state: Arc<dyn NetworkStateInfo + Send + Sync>,
|
||||
is_validator: bool,
|
||||
) -> impl Future<Output = ()> {
|
||||
let runtime = self.client.runtime_api();
|
||||
let at = BlockId::number(*number);
|
||||
let has_api = runtime.has_api::<dyn OffchainWorkerApi<Block, Error = ()>>(&at);
|
||||
debug!("Checking offchain workers at {:?}: {:?}", at, has_api);
|
||||
let at = BlockId::number(*header.number());
|
||||
let has_api_v1 = runtime.has_api_with::<dyn OffchainWorkerApi<Block, Error = ()>, _>(
|
||||
&at, |v| v == 1
|
||||
);
|
||||
let has_api_v2 = runtime.has_api::<dyn OffchainWorkerApi<Block, Error = ()>>(&at);
|
||||
let version = match (has_api_v1, has_api_v2) {
|
||||
(_, Ok(true)) => 2,
|
||||
(Ok(true), _) => 1,
|
||||
_ => 0,
|
||||
};
|
||||
|
||||
if has_api.unwrap_or(false) {
|
||||
debug!("Checking offchain workers at {:?}: version:{}", at, version);
|
||||
if version > 0 {
|
||||
let (api, runner) = api::AsyncApi::new(
|
||||
self.db.clone(),
|
||||
network_state.clone(),
|
||||
is_validator,
|
||||
);
|
||||
debug!("Spawning offchain workers at {:?}", at);
|
||||
let number = *number;
|
||||
let header = header.clone();
|
||||
let client = self.client.clone();
|
||||
self.spawn_worker(move || {
|
||||
let runtime = client.runtime_api();
|
||||
let api = Box::new(api);
|
||||
debug!("Running offchain workers at {:?}", at);
|
||||
let run = runtime.offchain_worker_with_context(
|
||||
&at,
|
||||
ExecutionContext::OffchainCall(Some((api, offchain::Capabilities::all()))),
|
||||
number,
|
||||
);
|
||||
let context = ExecutionContext::OffchainCall(Some(
|
||||
(api, offchain::Capabilities::all())
|
||||
));
|
||||
let run = if version == 2 {
|
||||
runtime.offchain_worker_with_context(&at, context, &header)
|
||||
} else {
|
||||
#[allow(deprecated)]
|
||||
runtime.offchain_worker_before_version_2_with_context(
|
||||
&at, context, *header.number()
|
||||
)
|
||||
};
|
||||
if let Err(e) = run {
|
||||
log::error!("Error running offchain workers at {:?}: {:?}", at, e);
|
||||
}
|
||||
@@ -150,6 +164,7 @@ mod tests {
|
||||
use substrate_test_runtime_client::runtime::Block;
|
||||
use sc_transaction_pool::{BasicPool, FullChainApi};
|
||||
use sp_transaction_pool::{TransactionPool, InPoolTransaction};
|
||||
use sp_runtime::{generic::Header, traits::Header as _};
|
||||
|
||||
struct MockNetworkStateInfo();
|
||||
|
||||
@@ -169,7 +184,7 @@ mod tests {
|
||||
fn submit_at(
|
||||
&self,
|
||||
at: &BlockId<Block>,
|
||||
extrinsic: <Block as sp_runtime::traits::Block>::Extrinsic,
|
||||
extrinsic: <Block as traits::Block>::Extrinsic,
|
||||
) -> Result<(), ()> {
|
||||
futures::executor::block_on(self.0.submit_one(&at, extrinsic))
|
||||
.map(|_| ())
|
||||
@@ -187,10 +202,17 @@ mod tests {
|
||||
.register_transaction_pool(Arc::downgrade(&pool.clone()) as _);
|
||||
let db = sc_client_db::offchain::LocalStorage::new_test();
|
||||
let network_state = Arc::new(MockNetworkStateInfo());
|
||||
let header = Header::new(
|
||||
0u64,
|
||||
Default::default(),
|
||||
Default::default(),
|
||||
Default::default(),
|
||||
Default::default(),
|
||||
);
|
||||
|
||||
// when
|
||||
let offchain = OffchainWorkers::new(client, db);
|
||||
futures::executor::block_on(offchain.on_block_imported(&0u64, network_state, false));
|
||||
futures::executor::block_on(offchain.on_block_imported(&header, network_state, false));
|
||||
|
||||
// then
|
||||
assert_eq!(pool.0.status().ready, 1);
|
||||
|
||||
@@ -400,7 +400,7 @@ fn should_return_runtime_version() {
|
||||
\"specVersion\":1,\"implVersion\":1,\"apis\":[[\"0xdf6acb689907609b\",2],\
|
||||
[\"0x37e397fc7c91f5e4\",1],[\"0xd2bc9897eed08f15\",1],[\"0x40fe3ad401f8959a\",4],\
|
||||
[\"0xc6e9a76309f39b09\",1],[\"0xdd718d5cc53262d4\",1],[\"0xcbca25e39f142387\",1],\
|
||||
[\"0xf78b278be53f454c\",1],[\"0xab3c0572291feb8b\",1],[\"0xbc9d89904f5b923f\",1]]}";
|
||||
[\"0xf78b278be53f454c\",2],[\"0xab3c0572291feb8b\",1],[\"0xbc9d89904f5b923f\",1]]}";
|
||||
|
||||
let runtime_version = api.runtime_version(None.into()).wait().unwrap();
|
||||
let serialized = serde_json::to_string(&runtime_version).unwrap();
|
||||
|
||||
@@ -43,7 +43,7 @@ use sc_rpc;
|
||||
use sp_api::ConstructRuntimeApi;
|
||||
use sp_runtime::generic::BlockId;
|
||||
use sp_runtime::traits::{
|
||||
Block as BlockT, ProvideRuntimeApi, NumberFor, Header, SaturatedConversion,
|
||||
Block as BlockT, ProvideRuntimeApi, NumberFor, SaturatedConversion,
|
||||
};
|
||||
use sc_executor::{NativeExecutor, NativeExecutionDispatch};
|
||||
use std::{
|
||||
@@ -867,7 +867,6 @@ ServiceBuilder<
|
||||
let events = client.import_notification_stream()
|
||||
.map(|v| Ok::<_, ()>(v)).compat()
|
||||
.for_each(move |notification| {
|
||||
let number = *notification.header.number();
|
||||
let txpool = txpool.upgrade();
|
||||
|
||||
if let Some(txpool) = txpool.as_ref() {
|
||||
@@ -880,8 +879,11 @@ ServiceBuilder<
|
||||
|
||||
let offchain = offchain.as_ref().and_then(|o| o.upgrade());
|
||||
if let Some(offchain) = offchain {
|
||||
let future = offchain.on_block_imported(&number, network_state_info.clone(), is_validator)
|
||||
.map(|()| Ok(()));
|
||||
let future = offchain.on_block_imported(
|
||||
¬ification.header,
|
||||
network_state_info.clone(),
|
||||
is_validator
|
||||
).map(|()| Ok(()));
|
||||
let _ = to_spawn_tx_.unbounded_send(Box::new(Compat::new(future)));
|
||||
}
|
||||
|
||||
|
||||
@@ -571,14 +571,22 @@ mod tests {
|
||||
inner: vec![seal_header(create_header(0, Default::default(), Default::default()), 999)],
|
||||
};
|
||||
|
||||
let initialize_block = |number, hash: H256| System::initialize(
|
||||
&number,
|
||||
&hash,
|
||||
&Default::default(),
|
||||
&Default::default(),
|
||||
Default::default()
|
||||
);
|
||||
|
||||
for number in 1..8 {
|
||||
System::initialize(&number, &canon_chain.best_hash(), &Default::default(), &Default::default());
|
||||
initialize_block(number, canon_chain.best_hash());
|
||||
let header = seal_header(System::finalize(), author_a);
|
||||
canon_chain.push(header);
|
||||
}
|
||||
|
||||
// initialize so system context is set up correctly.
|
||||
System::initialize(&8, &canon_chain.best_hash(), &Default::default(), &Default::default());
|
||||
initialize_block(8, canon_chain.best_hash());
|
||||
|
||||
// 2 of the same uncle at once
|
||||
{
|
||||
@@ -663,7 +671,13 @@ mod tests {
|
||||
);
|
||||
|
||||
header.digest_mut().pop(); // pop the seal off.
|
||||
System::initialize(&1, &Default::default(), &Default::default(), header.digest());
|
||||
System::initialize(
|
||||
&1,
|
||||
&Default::default(),
|
||||
&Default::default(),
|
||||
header.digest(),
|
||||
Default::default(),
|
||||
);
|
||||
|
||||
assert_eq!(Authorship::author(), author);
|
||||
});
|
||||
|
||||
@@ -81,7 +81,13 @@ fn first_block_epoch_zero_start() {
|
||||
);
|
||||
|
||||
assert_eq!(Babe::genesis_slot(), 0);
|
||||
System::initialize(&1, &Default::default(), &Default::default(), &pre_digest);
|
||||
System::initialize(
|
||||
&1,
|
||||
&Default::default(),
|
||||
&Default::default(),
|
||||
&pre_digest,
|
||||
Default::default(),
|
||||
);
|
||||
|
||||
// see implementation of the function for details why: we issue an
|
||||
// epoch-change digest but don't do it via the normal session mechanism.
|
||||
|
||||
@@ -861,6 +861,16 @@ fn storage_size() {
|
||||
});
|
||||
}
|
||||
|
||||
fn initialize_block(number: u64) {
|
||||
System::initialize(
|
||||
&number,
|
||||
&[0u8; 32].into(),
|
||||
&[0u8; 32].into(),
|
||||
&Default::default(),
|
||||
Default::default(),
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deduct_blocks() {
|
||||
let (wasm, code_hash) = compile_module::<Test>(CODE_SET_RENT).unwrap();
|
||||
@@ -881,7 +891,7 @@ fn deduct_blocks() {
|
||||
assert_eq!(bob_contract.rent_allowance, 1_000);
|
||||
|
||||
// Advance 4 blocks
|
||||
System::initialize(&5, &[0u8; 32].into(), &[0u8; 32].into(), &Default::default());
|
||||
initialize_block(5);
|
||||
|
||||
// Trigger rent through call
|
||||
assert_ok!(Contract::call(Origin::signed(ALICE), BOB, 0, 100_000, call::null()));
|
||||
@@ -896,7 +906,7 @@ fn deduct_blocks() {
|
||||
assert_eq!(Balances::free_balance(BOB), 30_000 - rent);
|
||||
|
||||
// Advance 7 blocks more
|
||||
System::initialize(&12, &[0u8; 32].into(), &[0u8; 32].into(), &Default::default());
|
||||
initialize_block(12);
|
||||
|
||||
// Trigger rent through call
|
||||
assert_ok!(Contract::call(Origin::signed(ALICE), BOB, 0, 100_000, call::null()));
|
||||
@@ -971,7 +981,7 @@ fn claim_surcharge(blocks: u64, trigger_call: impl Fn() -> bool, removes: bool)
|
||||
));
|
||||
|
||||
// Advance blocks
|
||||
System::initialize(&blocks, &[0u8; 32].into(), &[0u8; 32].into(), &Default::default());
|
||||
initialize_block(blocks);
|
||||
|
||||
// Trigger rent through call
|
||||
assert!(trigger_call());
|
||||
@@ -1011,7 +1021,7 @@ fn removals(trigger_call: impl Fn() -> bool) {
|
||||
assert_eq!(Balances::free_balance(&BOB), 100);
|
||||
|
||||
// Advance blocks
|
||||
System::initialize(&10, &[0u8; 32].into(), &[0u8; 32].into(), &Default::default());
|
||||
initialize_block(10);
|
||||
|
||||
// Trigger rent through call
|
||||
assert!(trigger_call());
|
||||
@@ -1019,7 +1029,7 @@ fn removals(trigger_call: impl Fn() -> bool) {
|
||||
assert_eq!(Balances::free_balance(&BOB), subsistence_threshold);
|
||||
|
||||
// Advance blocks
|
||||
System::initialize(&20, &[0u8; 32].into(), &[0u8; 32].into(), &Default::default());
|
||||
initialize_block(20);
|
||||
|
||||
// Trigger rent must have no effect
|
||||
assert!(trigger_call());
|
||||
@@ -1045,7 +1055,7 @@ fn removals(trigger_call: impl Fn() -> bool) {
|
||||
assert_eq!(Balances::free_balance(&BOB), 1_000);
|
||||
|
||||
// Advance blocks
|
||||
System::initialize(&10, &[0u8; 32].into(), &[0u8; 32].into(), &Default::default());
|
||||
initialize_block(10);
|
||||
|
||||
// Trigger rent through call
|
||||
assert!(trigger_call());
|
||||
@@ -1054,7 +1064,7 @@ fn removals(trigger_call: impl Fn() -> bool) {
|
||||
assert_eq!(Balances::free_balance(&BOB), 900);
|
||||
|
||||
// Advance blocks
|
||||
System::initialize(&20, &[0u8; 32].into(), &[0u8; 32].into(), &Default::default());
|
||||
initialize_block(20);
|
||||
|
||||
// Trigger rent must have no effect
|
||||
assert!(trigger_call());
|
||||
@@ -1085,7 +1095,7 @@ fn removals(trigger_call: impl Fn() -> bool) {
|
||||
assert_eq!(Balances::free_balance(&BOB), Balances::minimum_balance());
|
||||
|
||||
// Advance blocks
|
||||
System::initialize(&10, &[0u8; 32].into(), &[0u8; 32].into(), &Default::default());
|
||||
initialize_block(10);
|
||||
|
||||
// Trigger rent through call
|
||||
assert!(trigger_call());
|
||||
@@ -1093,7 +1103,7 @@ fn removals(trigger_call: impl Fn() -> bool) {
|
||||
assert_eq!(Balances::free_balance(&BOB), Balances::minimum_balance());
|
||||
|
||||
// Advance blocks
|
||||
System::initialize(&20, &[0u8; 32].into(), &[0u8; 32].into(), &Default::default());
|
||||
initialize_block(20);
|
||||
|
||||
// Trigger rent must have no effect
|
||||
assert!(trigger_call());
|
||||
@@ -1122,7 +1132,7 @@ fn call_removed_contract() {
|
||||
assert_ok!(Contract::call(Origin::signed(ALICE), BOB, 0, 100_000, call::null()));
|
||||
|
||||
// Advance blocks
|
||||
System::initialize(&10, &[0u8; 32].into(), &[0u8; 32].into(), &Default::default());
|
||||
initialize_block(10);
|
||||
|
||||
// Calling contract should remove contract and fail.
|
||||
assert_err!(
|
||||
@@ -1209,7 +1219,7 @@ fn default_rent_allowance_on_instantiate() {
|
||||
assert_eq!(bob_contract.rent_allowance, <BalanceOf<Test>>::max_value());
|
||||
|
||||
// Advance blocks
|
||||
System::initialize(&5, &[0u8; 32].into(), &[0u8; 32].into(), &Default::default());
|
||||
initialize_block(5);
|
||||
|
||||
// Trigger rent through call
|
||||
assert_ok!(Contract::call(Origin::signed(ALICE), BOB, 0, 100_000, call::null()));
|
||||
@@ -1355,7 +1365,7 @@ fn restoration(test_different_storage: bool, test_restore_to_with_dirty_storage:
|
||||
}
|
||||
|
||||
// Advance 4 blocks, to the 5th.
|
||||
System::initialize(&5, &[0u8; 32].into(), &[0u8; 32].into(), &Default::default());
|
||||
initialize_block(5);
|
||||
|
||||
// Call `BOB`, which makes it pay rent. Since the rent allowance is set to 0
|
||||
// we expect that it will get removed leaving tombstone.
|
||||
@@ -1384,7 +1394,7 @@ fn restoration(test_different_storage: bool, test_restore_to_with_dirty_storage:
|
||||
|
||||
if !test_restore_to_with_dirty_storage {
|
||||
// Advance 1 block, to the 6th.
|
||||
System::initialize(&6, &[0u8; 32].into(), &[0u8; 32].into(), &Default::default());
|
||||
initialize_block(6);
|
||||
}
|
||||
|
||||
// Perform a call to `DJANGO`. This should either perform restoration successfully or
|
||||
|
||||
@@ -5,13 +5,13 @@ authors = ["Parity Technologies <admin@parity.io>"]
|
||||
edition = "2018"
|
||||
|
||||
[dependencies]
|
||||
serde = { version = "1.0.101", optional = true }
|
||||
codec = { package = "parity-scale-codec", version = "1.0.0", default-features = false, features = ["derive"] }
|
||||
sp-std = { version = "2.0.0", default-features = false, path = "../../primitives/std" }
|
||||
sp-io ={ path = "../../primitives/io", default-features = false }
|
||||
sp-runtime = { version = "2.0.0", default-features = false, path = "../../primitives/runtime" }
|
||||
frame-support = { version = "2.0.0", default-features = false, path = "../support" }
|
||||
frame-system = { version = "2.0.0", default-features = false, path = "../system" }
|
||||
serde = { version = "1.0.101", optional = true }
|
||||
sp-io ={ path = "../../primitives/io", default-features = false }
|
||||
sp-runtime = { version = "2.0.0", default-features = false, path = "../../primitives/runtime" }
|
||||
sp-std = { version = "2.0.0", default-features = false, path = "../../primitives/std" }
|
||||
|
||||
[dev-dependencies]
|
||||
hex-literal = "0.2.1"
|
||||
@@ -23,11 +23,11 @@ pallet-transaction-payment = { version = "2.0.0", path = "../transaction-payment
|
||||
[features]
|
||||
default = ["std"]
|
||||
std = [
|
||||
"sp-std/std",
|
||||
"frame-support/std",
|
||||
"serde",
|
||||
"codec/std",
|
||||
"sp-runtime/std",
|
||||
"sp-io/std",
|
||||
"frame-support/std",
|
||||
"frame-system/std",
|
||||
"serde",
|
||||
"sp-io/std",
|
||||
"sp-runtime/std",
|
||||
"sp-std/std",
|
||||
]
|
||||
|
||||
@@ -82,7 +82,7 @@ use sp_runtime::{
|
||||
generic::Digest, ApplyExtrinsicResult,
|
||||
traits::{
|
||||
self, Header, Zero, One, Checkable, Applyable, CheckEqual, OnFinalize, OnInitialize,
|
||||
NumberFor, Block as BlockT, OffchainWorker, Dispatchable,
|
||||
NumberFor, Block as BlockT, OffchainWorker, Dispatchable, Saturating,
|
||||
},
|
||||
transaction_validity::TransactionValidity,
|
||||
};
|
||||
@@ -154,9 +154,23 @@ where
|
||||
{
|
||||
/// Start the execution of a particular block.
|
||||
pub fn initialize_block(header: &System::Header) {
|
||||
let mut digests = <DigestOf<System>>::default();
|
||||
header.digest().logs().iter().for_each(|d| if d.as_pre_runtime().is_some() { digests.push(d.clone()) });
|
||||
Self::initialize_block_impl(header.number(), header.parent_hash(), header.extrinsics_root(), &digests);
|
||||
let digests = Self::extract_pre_digest(&header);
|
||||
Self::initialize_block_impl(
|
||||
header.number(),
|
||||
header.parent_hash(),
|
||||
header.extrinsics_root(),
|
||||
&digests
|
||||
);
|
||||
}
|
||||
|
||||
fn extract_pre_digest(header: &System::Header) -> DigestOf<System> {
|
||||
let mut digest = <DigestOf<System>>::default();
|
||||
header.digest().logs()
|
||||
.iter()
|
||||
.for_each(|d| if d.as_pre_runtime().is_some() {
|
||||
digest.push(d.clone())
|
||||
});
|
||||
digest
|
||||
}
|
||||
|
||||
fn initialize_block_impl(
|
||||
@@ -165,7 +179,13 @@ where
|
||||
extrinsics_root: &System::Hash,
|
||||
digest: &Digest<System::Hash>,
|
||||
) {
|
||||
<frame_system::Module<System>>::initialize(block_number, parent_hash, extrinsics_root, digest);
|
||||
<frame_system::Module<System>>::initialize(
|
||||
block_number,
|
||||
parent_hash,
|
||||
extrinsics_root,
|
||||
digest,
|
||||
frame_system::InitKind::Full,
|
||||
);
|
||||
<AllModules as OnInitialize<System::BlockNumber>>::on_initialize(*block_number);
|
||||
<frame_system::Module<System>>::register_extra_weight_unchecked(
|
||||
<AllModules as WeighBlock<System::BlockNumber>>::on_initialize(*block_number)
|
||||
@@ -310,8 +330,24 @@ where
|
||||
}
|
||||
|
||||
/// Start an offchain worker and generate extrinsics.
|
||||
pub fn offchain_worker(n: System::BlockNumber) {
|
||||
<AllModules as OffchainWorker<System::BlockNumber>>::offchain_worker(n)
|
||||
pub fn offchain_worker(header: &System::Header) {
|
||||
// We need to keep events available for offchain workers,
|
||||
// hence we initialize the block manually.
|
||||
// OffchainWorker RuntimeApi should skip initialization.
|
||||
let digests = Self::extract_pre_digest(header);
|
||||
|
||||
<frame_system::Module<System>>::initialize(
|
||||
header.number(),
|
||||
header.parent_hash(),
|
||||
header.extrinsics_root(),
|
||||
&digests,
|
||||
frame_system::InitKind::Inspection,
|
||||
);
|
||||
<AllModules as OffchainWorker<System::BlockNumber>>::offchain_worker(
|
||||
// to maintain backward compatibility we call module offchain workers
|
||||
// with parent block number.
|
||||
header.number().saturating_sub(1.into())
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -291,7 +291,13 @@ mod tests {
|
||||
TestExternalities::new(t).execute_with(|| {
|
||||
let mut parent_hash = System::parent_hash();
|
||||
for i in 2..106 {
|
||||
System::initialize(&i, &parent_hash, &Default::default(), &Default::default());
|
||||
System::initialize(
|
||||
&i,
|
||||
&parent_hash,
|
||||
&Default::default(),
|
||||
&Default::default(),
|
||||
Default::default()
|
||||
);
|
||||
FinalityTracker::on_finalize(i);
|
||||
let hdr = System::finalize();
|
||||
parent_hash = hdr.hash();
|
||||
@@ -310,7 +316,13 @@ mod tests {
|
||||
TestExternalities::new(t).execute_with(|| {
|
||||
let mut parent_hash = System::parent_hash();
|
||||
for i in 2..106 {
|
||||
System::initialize(&i, &parent_hash, &Default::default(), &Default::default());
|
||||
System::initialize(
|
||||
&i,
|
||||
&parent_hash,
|
||||
&Default::default(),
|
||||
&Default::default(),
|
||||
Default::default(),
|
||||
);
|
||||
assert_ok!(FinalityTracker::dispatch(
|
||||
Call::final_hint(i-1),
|
||||
Origin::NONE,
|
||||
|
||||
@@ -18,17 +18,27 @@
|
||||
|
||||
#![cfg(test)]
|
||||
|
||||
use sp_runtime::{testing::Digest, traits::{Header, OnFinalize}};
|
||||
use sp_runtime::{testing::{H256, Digest}, traits::{Header, OnFinalize}};
|
||||
use crate::mock::*;
|
||||
use frame_system::{EventRecord, Phase};
|
||||
use codec::{Decode, Encode};
|
||||
use fg_primitives::ScheduledChange;
|
||||
use super::*;
|
||||
|
||||
fn initialize_block(number: u64, parent_hash: H256) {
|
||||
System::initialize(
|
||||
&number,
|
||||
&parent_hash,
|
||||
&Default::default(),
|
||||
&Default::default(),
|
||||
Default::default(),
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn authorities_change_logged() {
|
||||
new_test_ext(vec![(1, 1), (2, 1), (3, 1)]).execute_with(|| {
|
||||
System::initialize(&1, &Default::default(), &Default::default(), &Default::default());
|
||||
initialize_block(1, Default::default());
|
||||
Grandpa::schedule_change(to_authorities(vec![(4, 1), (5, 1), (6, 1)]), 0, None).unwrap();
|
||||
|
||||
System::note_finished_extrinsics();
|
||||
@@ -56,7 +66,7 @@ fn authorities_change_logged() {
|
||||
#[test]
|
||||
fn authorities_change_logged_after_delay() {
|
||||
new_test_ext(vec![(1, 1), (2, 1), (3, 1)]).execute_with(|| {
|
||||
System::initialize(&1, &Default::default(), &Default::default(), &Default::default());
|
||||
initialize_block(1, Default::default());
|
||||
Grandpa::schedule_change(to_authorities(vec![(4, 1), (5, 1), (6, 1)]), 1, None).unwrap();
|
||||
Grandpa::on_finalize(1);
|
||||
let header = System::finalize();
|
||||
@@ -71,7 +81,7 @@ fn authorities_change_logged_after_delay() {
|
||||
// no change at this height.
|
||||
assert_eq!(System::events(), vec![]);
|
||||
|
||||
System::initialize(&2, &header.hash(), &Default::default(), &Default::default());
|
||||
initialize_block(2, header.hash());
|
||||
System::note_finished_extrinsics();
|
||||
Grandpa::on_finalize(2);
|
||||
|
||||
@@ -89,7 +99,7 @@ fn authorities_change_logged_after_delay() {
|
||||
#[test]
|
||||
fn cannot_schedule_change_when_one_pending() {
|
||||
new_test_ext(vec![(1, 1), (2, 1), (3, 1)]).execute_with(|| {
|
||||
System::initialize(&1, &Default::default(), &Default::default(), &Default::default());
|
||||
initialize_block(1, Default::default());
|
||||
Grandpa::schedule_change(to_authorities(vec![(4, 1), (5, 1), (6, 1)]), 1, None).unwrap();
|
||||
assert!(<PendingChange<Test>>::exists());
|
||||
assert!(Grandpa::schedule_change(to_authorities(vec![(5, 1)]), 1, None).is_err());
|
||||
@@ -97,14 +107,14 @@ fn cannot_schedule_change_when_one_pending() {
|
||||
Grandpa::on_finalize(1);
|
||||
let header = System::finalize();
|
||||
|
||||
System::initialize(&2, &header.hash(), &Default::default(), &Default::default());
|
||||
initialize_block(2, header.hash());
|
||||
assert!(<PendingChange<Test>>::exists());
|
||||
assert!(Grandpa::schedule_change(to_authorities(vec![(5, 1)]), 1, None).is_err());
|
||||
|
||||
Grandpa::on_finalize(2);
|
||||
let header = System::finalize();
|
||||
|
||||
System::initialize(&3, &header.hash(), &Default::default(), &Default::default());
|
||||
initialize_block(3, header.hash());
|
||||
assert!(!<PendingChange<Test>>::exists());
|
||||
assert!(Grandpa::schedule_change(to_authorities(vec![(5, 1)]), 1, None).is_ok());
|
||||
|
||||
@@ -132,7 +142,7 @@ fn new_decodes_from_old() {
|
||||
#[test]
|
||||
fn dispatch_forced_change() {
|
||||
new_test_ext(vec![(1, 1), (2, 1), (3, 1)]).execute_with(|| {
|
||||
System::initialize(&1, &Default::default(), &Default::default(), &Default::default());
|
||||
initialize_block(1, Default::default());
|
||||
Grandpa::schedule_change(
|
||||
to_authorities(vec![(4, 1), (5, 1), (6, 1)]),
|
||||
5,
|
||||
@@ -146,7 +156,7 @@ fn dispatch_forced_change() {
|
||||
let mut header = System::finalize();
|
||||
|
||||
for i in 2..7 {
|
||||
System::initialize(&i, &header.hash(), &Default::default(), &Default::default());
|
||||
initialize_block(i, header.hash());
|
||||
assert!(<PendingChange<Test>>::get().unwrap().forced.is_some());
|
||||
assert_eq!(Grandpa::next_forced(), Some(11));
|
||||
assert!(Grandpa::schedule_change(to_authorities(vec![(5, 1)]), 1, None).is_err());
|
||||
@@ -159,7 +169,7 @@ fn dispatch_forced_change() {
|
||||
// change has been applied at the end of block 6.
|
||||
// add a normal change.
|
||||
{
|
||||
System::initialize(&7, &header.hash(), &Default::default(), &Default::default());
|
||||
initialize_block(7, header.hash());
|
||||
assert!(!<PendingChange<Test>>::exists());
|
||||
assert_eq!(Grandpa::grandpa_authorities(), to_authorities(vec![(4, 1), (5, 1), (6, 1)]));
|
||||
assert!(Grandpa::schedule_change(to_authorities(vec![(5, 1)]), 1, None).is_ok());
|
||||
@@ -169,7 +179,7 @@ fn dispatch_forced_change() {
|
||||
|
||||
// run the normal change.
|
||||
{
|
||||
System::initialize(&8, &header.hash(), &Default::default(), &Default::default());
|
||||
initialize_block(8, header.hash());
|
||||
assert!(<PendingChange<Test>>::exists());
|
||||
assert_eq!(Grandpa::grandpa_authorities(), to_authorities(vec![(4, 1), (5, 1), (6, 1)]));
|
||||
assert!(Grandpa::schedule_change(to_authorities(vec![(5, 1)]), 1, None).is_err());
|
||||
@@ -180,7 +190,7 @@ fn dispatch_forced_change() {
|
||||
// normal change applied. but we can't apply a new forced change for some
|
||||
// time.
|
||||
for i in 9..11 {
|
||||
System::initialize(&i, &header.hash(), &Default::default(), &Default::default());
|
||||
initialize_block(i, header.hash());
|
||||
assert!(!<PendingChange<Test>>::exists());
|
||||
assert_eq!(Grandpa::grandpa_authorities(), to_authorities(vec![(5, 1)]));
|
||||
assert_eq!(Grandpa::next_forced(), Some(11));
|
||||
@@ -190,7 +200,7 @@ fn dispatch_forced_change() {
|
||||
}
|
||||
|
||||
{
|
||||
System::initialize(&11, &header.hash(), &Default::default(), &Default::default());
|
||||
initialize_block(11, header.hash());
|
||||
assert!(!<PendingChange<Test>>::exists());
|
||||
assert!(Grandpa::schedule_change(to_authorities(vec![(5, 1), (6, 1), (7, 1)]), 5, Some(0)).is_ok());
|
||||
assert_eq!(Grandpa::next_forced(), Some(21));
|
||||
@@ -205,7 +215,7 @@ fn dispatch_forced_change() {
|
||||
fn schedule_pause_only_when_live() {
|
||||
new_test_ext(vec![(1, 1), (2, 1), (3, 1)]).execute_with(|| {
|
||||
// we schedule a pause at block 1 with delay of 1
|
||||
System::initialize(&1, &Default::default(), &Default::default(), &Default::default());
|
||||
initialize_block(1, Default::default());
|
||||
Grandpa::schedule_pause(1).unwrap();
|
||||
|
||||
// we've switched to the pending pause state
|
||||
@@ -220,7 +230,7 @@ fn schedule_pause_only_when_live() {
|
||||
Grandpa::on_finalize(1);
|
||||
let _ = System::finalize();
|
||||
|
||||
System::initialize(&2, &Default::default(), &Default::default(), &Default::default());
|
||||
initialize_block(2, Default::default());
|
||||
|
||||
// signaling a pause now should fail
|
||||
assert!(Grandpa::schedule_pause(1).is_err());
|
||||
@@ -239,7 +249,7 @@ fn schedule_pause_only_when_live() {
|
||||
#[test]
|
||||
fn schedule_resume_only_when_paused() {
|
||||
new_test_ext(vec![(1, 1), (2, 1), (3, 1)]).execute_with(|| {
|
||||
System::initialize(&1, &Default::default(), &Default::default(), &Default::default());
|
||||
initialize_block(1, Default::default());
|
||||
|
||||
// the set is currently live, resuming it is an error
|
||||
assert!(Grandpa::schedule_resume(1).is_err());
|
||||
@@ -260,16 +270,16 @@ fn schedule_resume_only_when_paused() {
|
||||
);
|
||||
|
||||
// we schedule the set to go back live in 2 blocks
|
||||
System::initialize(&2, &Default::default(), &Default::default(), &Default::default());
|
||||
initialize_block(2, Default::default());
|
||||
Grandpa::schedule_resume(2).unwrap();
|
||||
Grandpa::on_finalize(2);
|
||||
let _ = System::finalize();
|
||||
|
||||
System::initialize(&3, &Default::default(), &Default::default(), &Default::default());
|
||||
initialize_block(3, Default::default());
|
||||
Grandpa::on_finalize(3);
|
||||
let _ = System::finalize();
|
||||
|
||||
System::initialize(&4, &Default::default(), &Default::default(), &Default::default());
|
||||
initialize_block(4, Default::default());
|
||||
Grandpa::on_finalize(4);
|
||||
let _ = System::finalize();
|
||||
|
||||
|
||||
@@ -171,10 +171,14 @@ pub type AuthIndex = u32;
|
||||
pub struct Heartbeat<BlockNumber>
|
||||
where BlockNumber: PartialEq + Eq + Decode + Encode,
|
||||
{
|
||||
block_number: BlockNumber,
|
||||
network_state: OpaqueNetworkState,
|
||||
session_index: SessionIndex,
|
||||
authority_index: AuthIndex,
|
||||
/// Block number at the time heartbeat is created..
|
||||
pub block_number: BlockNumber,
|
||||
/// A state of local network (peer id and external addresses)
|
||||
pub network_state: OpaqueNetworkState,
|
||||
/// Index of the current session.
|
||||
pub session_index: SessionIndex,
|
||||
/// An index of the authority on the list of validators.
|
||||
pub authority_index: AuthIndex,
|
||||
}
|
||||
|
||||
pub trait Trait: frame_system::Trait + pallet_session::historical::Trait {
|
||||
|
||||
@@ -210,7 +210,13 @@ mod tests {
|
||||
let mut parent_hash = System::parent_hash();
|
||||
|
||||
for i in 1 .. (blocks + 1) {
|
||||
System::initialize(&i, &parent_hash, &Default::default(), &Default::default());
|
||||
System::initialize(
|
||||
&i,
|
||||
&parent_hash,
|
||||
&Default::default(),
|
||||
&Default::default(),
|
||||
frame_system::InitKind::Full,
|
||||
);
|
||||
CollectiveFlip::on_initialize(i);
|
||||
|
||||
let header = System::finalize();
|
||||
|
||||
@@ -531,6 +531,27 @@ pub fn ensure_none<OuterOrigin, AccountId>(o: OuterOrigin) -> Result<(), BadOrig
|
||||
}
|
||||
}
|
||||
|
||||
/// A type of block initialization to perform.
|
||||
pub enum InitKind {
|
||||
/// Leave inspectable storage entries in state.
|
||||
///
|
||||
/// i.e. `Events` are not being reset.
|
||||
/// Should only be used for off-chain calls,
|
||||
/// regular block execution should clear those.
|
||||
Inspection,
|
||||
|
||||
/// Reset also inspectable storage entries.
|
||||
///
|
||||
/// This should be used for regular block execution.
|
||||
Full,
|
||||
}
|
||||
|
||||
impl Default for InitKind {
|
||||
fn default() -> Self {
|
||||
InitKind::Full
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: Trait> Module<T> {
|
||||
/// Deposits an event into this block's event record.
|
||||
pub fn deposit_event(event: impl Into<T::Event>) {
|
||||
@@ -633,6 +654,7 @@ impl<T: Trait> Module<T> {
|
||||
parent_hash: &T::Hash,
|
||||
txs_root: &T::Hash,
|
||||
digest: &DigestOf<T>,
|
||||
kind: InitKind,
|
||||
) {
|
||||
// populate environment
|
||||
storage::unhashed::put(well_known_keys::EXTRINSIC_INDEX, &0u32);
|
||||
@@ -641,9 +663,12 @@ impl<T: Trait> Module<T> {
|
||||
<ParentHash<T>>::put(parent_hash);
|
||||
<BlockHash<T>>::insert(*number - One::one(), parent_hash);
|
||||
<ExtrinsicsRoot<T>>::put(txs_root);
|
||||
<Events<T>>::kill();
|
||||
EventCount::kill();
|
||||
<EventTopics<T>>::remove_all();
|
||||
|
||||
if let InitKind::Full = kind {
|
||||
<Events<T>>::kill();
|
||||
EventCount::kill();
|
||||
<EventTopics<T>>::remove_all();
|
||||
}
|
||||
}
|
||||
|
||||
/// Remove temporary "environment" entries in storage.
|
||||
@@ -1220,7 +1245,13 @@ mod tests {
|
||||
#[test]
|
||||
fn deposit_event_should_work() {
|
||||
new_test_ext().execute_with(|| {
|
||||
System::initialize(&1, &[0u8; 32].into(), &[0u8; 32].into(), &Default::default());
|
||||
System::initialize(
|
||||
&1,
|
||||
&[0u8; 32].into(),
|
||||
&[0u8; 32].into(),
|
||||
&Default::default(),
|
||||
InitKind::Full,
|
||||
);
|
||||
System::note_finished_extrinsics();
|
||||
System::deposit_event(1u16);
|
||||
System::finalize();
|
||||
@@ -1235,7 +1266,13 @@ mod tests {
|
||||
]
|
||||
);
|
||||
|
||||
System::initialize(&2, &[0u8; 32].into(), &[0u8; 32].into(), &Default::default());
|
||||
System::initialize(
|
||||
&2,
|
||||
&[0u8; 32].into(),
|
||||
&[0u8; 32].into(),
|
||||
&Default::default(),
|
||||
InitKind::Full,
|
||||
);
|
||||
System::deposit_event(42u16);
|
||||
System::note_applied_extrinsic(&Ok(()), 0, Default::default());
|
||||
System::note_applied_extrinsic(&Err(DispatchError::BadOrigin), 0, Default::default());
|
||||
@@ -1264,6 +1301,7 @@ mod tests {
|
||||
&[0u8; 32].into(),
|
||||
&[0u8; 32].into(),
|
||||
&Default::default(),
|
||||
InitKind::Full,
|
||||
);
|
||||
System::note_finished_extrinsics();
|
||||
|
||||
@@ -1329,6 +1367,7 @@ mod tests {
|
||||
&[n as u8 - 1; 32].into(),
|
||||
&[0u8; 32].into(),
|
||||
&Default::default(),
|
||||
InitKind::Full,
|
||||
);
|
||||
|
||||
System::finalize();
|
||||
|
||||
@@ -14,49 +14,19 @@
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with Substrate. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
//! Module helpers for offchain calls.
|
||||
//! Module helpers for off-chain calls.
|
||||
|
||||
use codec::Encode;
|
||||
use sp_runtime::app_crypto::{self, RuntimeAppPublic};
|
||||
use sp_std::convert::TryInto;
|
||||
use sp_std::prelude::Vec;
|
||||
use sp_runtime::app_crypto::{RuntimeAppPublic, AppPublic, AppSignature};
|
||||
use sp_runtime::traits::{Extrinsic as ExtrinsicT, IdentifyAccount};
|
||||
use frame_support::debug;
|
||||
|
||||
/// A trait responsible for signing a payload using given account.
|
||||
pub trait Signer<Public, Signature> {
|
||||
/// Sign any encodable payload with given account and produce a signature.
|
||||
///
|
||||
/// Returns `Some` if signing succeeded and `None` in case the `account` couldn't be used.
|
||||
fn sign<Payload: Encode>(public: Public, payload: &Payload) -> Option<Signature>;
|
||||
}
|
||||
|
||||
/// A `Signer` implementation for any `AppPublic` type.
|
||||
/// Creates runtime-specific signed transaction.
|
||||
///
|
||||
/// This implementation additionaly supports conversion to/from multi-signature/multi-signer
|
||||
/// wrappers.
|
||||
/// If the wrapped crypto doesn't match `AppPublic`s crypto `None` is returned.
|
||||
impl<Public, Signature, AppPublic> Signer<Public, Signature> for AppPublic where
|
||||
AppPublic: RuntimeAppPublic
|
||||
+ app_crypto::AppPublic
|
||||
+ From<<AppPublic as app_crypto::AppPublic>::Generic>,
|
||||
<AppPublic as RuntimeAppPublic>::Signature: app_crypto::AppSignature,
|
||||
Signature: From<
|
||||
<<AppPublic as RuntimeAppPublic>::Signature as app_crypto::AppSignature>::Generic
|
||||
>,
|
||||
Public: sp_std::convert::TryInto<<AppPublic as app_crypto::AppPublic>::Generic>
|
||||
{
|
||||
fn sign<Payload: Encode>(public: Public, raw_payload: &Payload) -> Option<Signature> {
|
||||
raw_payload.using_encoded(|payload| {
|
||||
let public = public.try_into().ok()?;
|
||||
AppPublic::from(public).sign(&payload)
|
||||
.map(
|
||||
<<AppPublic as RuntimeAppPublic>::Signature as app_crypto::AppSignature>
|
||||
::Generic::from
|
||||
)
|
||||
.map(Signature::from)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// Creates a runtime-specific signed transaction.
|
||||
/// This trait should be implemented by your `Runtime` to be able
|
||||
/// to submit `SignedTransaction`s` to the pool from off-chain code.
|
||||
pub trait CreateTransaction<T: crate::Trait, Extrinsic: ExtrinsicT> {
|
||||
/// A `Public` key representing a particular `AccountId`.
|
||||
type Public: IdentifyAccount<AccountId=T::AccountId> + Clone;
|
||||
@@ -77,15 +47,67 @@ pub trait CreateTransaction<T: crate::Trait, Extrinsic: ExtrinsicT> {
|
||||
) -> Option<(Extrinsic::Call, Extrinsic::SignaturePayload)>;
|
||||
}
|
||||
|
||||
type PublicOf<T, Call, X> = <
|
||||
<X as SubmitSignedTransaction<T, Call>>::CreateTransaction as CreateTransaction<
|
||||
T,
|
||||
<X as SubmitSignedTransaction<T, Call>>::Extrinsic,
|
||||
>
|
||||
/// A trait responsible for signing a payload using given account.
|
||||
///
|
||||
/// This trait is usually going to represent a local public key
|
||||
/// that has ability to sign arbitrary `Payloads`.
|
||||
///
|
||||
/// NOTE: Most likely you don't need to implement this trait manually.
|
||||
/// It has a blanket implementation for all `RuntimeAppPublic` types,
|
||||
/// so it's enough to pass an application-specific crypto type.
|
||||
///
|
||||
/// To easily create `SignedTransaction`s have a look at the
|
||||
/// [`TransactionSubmitter`] type.
|
||||
pub trait Signer<Public, Signature> {
|
||||
/// Sign any encodable payload with given account and produce a signature.
|
||||
///
|
||||
/// Returns `Some` if signing succeeded and `None` in case the `account` couldn't
|
||||
/// be used (for instance we couldn't convert it to required application specific crypto).
|
||||
fn sign<Payload: Encode>(public: Public, payload: &Payload) -> Option<Signature>;
|
||||
}
|
||||
|
||||
/// A `Signer` implementation for any `AppPublic` type.
|
||||
///
|
||||
/// This implementation additionaly supports conversion to/from multi-signature/multi-signer
|
||||
/// wrappers.
|
||||
/// If the wrapped crypto doesn't match `AppPublic`s crypto `None` is returned.
|
||||
impl<Public, Signature, TAnyAppPublic> Signer<Public, Signature> for TAnyAppPublic where
|
||||
TAnyAppPublic: RuntimeAppPublic
|
||||
+ AppPublic
|
||||
+ From<<TAnyAppPublic as AppPublic>::Generic>,
|
||||
<TAnyAppPublic as RuntimeAppPublic>::Signature: AppSignature,
|
||||
Signature: From<
|
||||
<<TAnyAppPublic as RuntimeAppPublic>::Signature as AppSignature>::Generic
|
||||
>,
|
||||
Public: TryInto<<TAnyAppPublic as AppPublic>::Generic>
|
||||
{
|
||||
fn sign<Payload: Encode>(public: Public, raw_payload: &Payload) -> Option<Signature> {
|
||||
raw_payload.using_encoded(|payload| {
|
||||
let public = public.try_into().ok()?;
|
||||
TAnyAppPublic::from(public).sign(&payload)
|
||||
.map(
|
||||
<<TAnyAppPublic as RuntimeAppPublic>::Signature as AppSignature>
|
||||
::Generic::from
|
||||
)
|
||||
.map(Signature::from)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// Retrieves a public key type for given `SignAndSubmitTransaction`.
|
||||
pub type PublicOf<T, Call, X> = <
|
||||
<X as SignAndSubmitTransaction<T, Call>>::CreateTransaction
|
||||
as
|
||||
CreateTransaction<T, <X as SignAndSubmitTransaction<T, Call>>::Extrinsic>
|
||||
>::Public;
|
||||
|
||||
/// A trait to sign and submit transactions in offchain calls.
|
||||
pub trait SubmitSignedTransaction<T: crate::Trait, Call> {
|
||||
/// A trait to sign and submit transactions in off-chain calls.
|
||||
///
|
||||
/// NOTE: Most likely you should not implement this trait yourself.
|
||||
/// There is an implementation for
|
||||
/// [`TransactionSubmitter`] type, which
|
||||
/// you should use.
|
||||
pub trait SignAndSubmitTransaction<T: crate::Trait, Call> {
|
||||
/// Unchecked extrinsic type.
|
||||
type Extrinsic: ExtrinsicT<Call=Call> + codec::Encode;
|
||||
|
||||
@@ -107,15 +129,30 @@ pub trait SubmitSignedTransaction<T: crate::Trait, Call> {
|
||||
let call = call.into();
|
||||
let id = public.clone().into_account();
|
||||
let expected = <crate::Module<T>>::account_nonce(&id);
|
||||
debug::native::debug!(
|
||||
target: "offchain",
|
||||
"Creating signed transaction from account: {:?} (nonce: {:?})",
|
||||
id,
|
||||
expected,
|
||||
);
|
||||
let (call, signature_data) = Self::CreateTransaction
|
||||
::create_transaction::<Self::Signer>(call, public, id, expected)
|
||||
::create_transaction::<Self::Signer>(call, public, id.clone(), expected)
|
||||
.ok_or(())?;
|
||||
// increment the nonce. This is fine, since the code should always
|
||||
// be running in off-chain context, so we NEVER persists data.
|
||||
<crate::Module<T>>::inc_account_nonce(&id);
|
||||
|
||||
let xt = Self::Extrinsic::new(call, Some(signature_data)).ok_or(())?;
|
||||
sp_io::offchain::submit_transaction(xt.encode())
|
||||
}
|
||||
}
|
||||
|
||||
/// A trait to submit unsigned transactions in off-chain calls.
|
||||
///
|
||||
/// NOTE: Most likely you should not implement this trait yourself.
|
||||
/// There is an implementation for
|
||||
/// [`TransactionSubmitter`] type, which
|
||||
/// you should use.
|
||||
pub trait SubmitUnsignedTransaction<T: crate::Trait, Call> {
|
||||
/// Unchecked extrinsic type.
|
||||
type Extrinsic: ExtrinsicT<Call=Call> + codec::Encode;
|
||||
@@ -130,9 +167,114 @@ pub trait SubmitUnsignedTransaction<T: crate::Trait, Call> {
|
||||
}
|
||||
}
|
||||
|
||||
/// A utility trait to easily create signed transactions
|
||||
/// from accounts in node's local keystore.
|
||||
///
|
||||
/// NOTE: Most likely you should not implement this trait yourself.
|
||||
/// There is an implementation for
|
||||
/// [`TransactionSubmitter`] type, which
|
||||
/// you should use.
|
||||
pub trait SubmitSignedTransaction<T: crate::Trait, Call> {
|
||||
/// A `SignAndSubmitTransaction` implementation.
|
||||
type SignAndSubmit: SignAndSubmitTransaction<T, Call>;
|
||||
|
||||
/// Find local keys that match given list of accounts.
|
||||
///
|
||||
/// Technically it finds an intersection between given list of `AccountId`s
|
||||
/// and accounts that are represented by public keys in local keystore.
|
||||
/// If `None` is passed it returns all accounts in the keystore.
|
||||
///
|
||||
/// Returns both public keys and `AccountId`s of accounts that are available.
|
||||
/// Such accounts can later be used to sign a payload or send signed transactions.
|
||||
fn find_local_keys(accounts: Option<impl IntoIterator<Item = T::AccountId>>) -> Vec<(
|
||||
T::AccountId,
|
||||
PublicOf<T, Call, Self::SignAndSubmit>,
|
||||
)>;
|
||||
|
||||
/// Find all available local keys.
|
||||
///
|
||||
/// This is equivalent of calling `find_local_keys(None)`.
|
||||
fn find_all_local_keys() -> Vec<(T::AccountId, PublicOf<T, Call, Self::SignAndSubmit>)> {
|
||||
Self::find_local_keys(None as Option<Vec<_>>)
|
||||
}
|
||||
|
||||
/// Check if there are keys for any of given accounts that could be used to send a transaction.
|
||||
///
|
||||
/// This check can be used as an early-exit condition to avoid doing too
|
||||
/// much work, before we actually realise that there are no accounts that you
|
||||
/// we could use for signing.
|
||||
fn can_sign_with(accounts: Option<impl IntoIterator<Item = T::AccountId>>) -> bool {
|
||||
!Self::find_local_keys(accounts).is_empty()
|
||||
}
|
||||
|
||||
/// Check if there are any keys that could be used for signing.
|
||||
///
|
||||
/// This is equivalent of calling `can_sign_with(None)`.
|
||||
fn can_sign() -> bool {
|
||||
Self::can_sign_with(None as Option<Vec<_>>)
|
||||
}
|
||||
|
||||
/// Create and submit signed transactions from supported accounts.
|
||||
///
|
||||
/// This method should intersect given list of accounts with the ones
|
||||
/// supported locally and submit signed transaction containing given `Call`
|
||||
/// with every of them.
|
||||
///
|
||||
/// Returns a vector of results and account ids that were supported.
|
||||
#[must_use]
|
||||
fn submit_signed_from(
|
||||
call: impl Into<Call> + Clone,
|
||||
accounts: impl IntoIterator<Item = T::AccountId>,
|
||||
) -> Vec<(T::AccountId, Result<(), ()>)> {
|
||||
let keys = Self::find_local_keys(Some(accounts));
|
||||
keys.into_iter().map(|(account, pub_key)| {
|
||||
let call = call.clone().into();
|
||||
(
|
||||
account,
|
||||
Self::SignAndSubmit::sign_and_submit(call, pub_key)
|
||||
)
|
||||
}).collect()
|
||||
}
|
||||
|
||||
/// Create and submit signed transactions from all local accounts.
|
||||
///
|
||||
/// This method submits a signed transaction from all local accounts
|
||||
/// for given application crypto.
|
||||
///
|
||||
/// Returns a vector of results and account ids that were supported.
|
||||
#[must_use]
|
||||
fn submit_signed(
|
||||
call: impl Into<Call> + Clone,
|
||||
) -> Vec<(T::AccountId, Result<(), ()>)> {
|
||||
let keys = Self::find_all_local_keys();
|
||||
keys.into_iter().map(|(account, pub_key)| {
|
||||
let call = call.clone().into();
|
||||
(
|
||||
account,
|
||||
Self::SignAndSubmit::sign_and_submit(call, pub_key)
|
||||
)
|
||||
}).collect()
|
||||
}
|
||||
}
|
||||
|
||||
/// A default type used to submit transactions to the pool.
|
||||
pub struct TransactionSubmitter<S, C, E> {
|
||||
_signer: sp_std::marker::PhantomData<(S, C, E)>,
|
||||
///
|
||||
/// This is passed into each runtime as an opaque associated type that can have either of:
|
||||
/// - [`SignAndSubmitTransaction`]
|
||||
/// - [`SubmitUnsignedTransaction`]
|
||||
/// - [`SubmitSignedTransaction`]
|
||||
/// and used accordingly.
|
||||
///
|
||||
/// This struct should be constructed by providing the following generic parameters:
|
||||
/// * `Signer` - Usually the application specific key type (see `app_crypto`).
|
||||
/// * `CreateTransaction` - A type that is able to produce signed transactions,
|
||||
/// usually it's going to be the entire `Runtime` object.
|
||||
/// * `Extrinsic` - A runtime-specific type for in-block extrinsics.
|
||||
///
|
||||
/// If you only need the ability to submit unsigned transactions,
|
||||
/// you may substitute both `Signer` and `CreateTransaction` with any type.
|
||||
pub struct TransactionSubmitter<Signer, CreateTransaction, Extrinsic> {
|
||||
_signer: sp_std::marker::PhantomData<(Signer, CreateTransaction, Extrinsic)>,
|
||||
}
|
||||
|
||||
impl<S, C, E> Default for TransactionSubmitter<S, C, E> {
|
||||
@@ -144,7 +286,7 @@ impl<S, C, E> Default for TransactionSubmitter<S, C, E> {
|
||||
}
|
||||
|
||||
/// A blanket implementation to simplify creation of transaction signer & submitter in the runtime.
|
||||
impl<T, E, S, C, Call> SubmitSignedTransaction<T, Call> for TransactionSubmitter<S, C, E> where
|
||||
impl<T, E, S, C, Call> SignAndSubmitTransaction<T, Call> for TransactionSubmitter<S, C, E> where
|
||||
T: crate::Trait,
|
||||
C: CreateTransaction<T, E>,
|
||||
S: Signer<<C as CreateTransaction<T, E>>::Public, <C as CreateTransaction<T, E>>::Signature>,
|
||||
@@ -155,10 +297,68 @@ impl<T, E, S, C, Call> SubmitSignedTransaction<T, Call> for TransactionSubmitter
|
||||
type Signer = S;
|
||||
}
|
||||
|
||||
/// A blanket impl to use the same submitter for usigned transactions as well.
|
||||
/// A blanket implementation to use the same submitter for unsigned transactions as well.
|
||||
impl<T, E, S, C, Call> SubmitUnsignedTransaction<T, Call> for TransactionSubmitter<S, C, E> where
|
||||
T: crate::Trait,
|
||||
E: ExtrinsicT<Call=Call> + codec::Encode,
|
||||
{
|
||||
type Extrinsic = E;
|
||||
}
|
||||
|
||||
/// A blanket implementation to support local keystore of application-crypto types.
|
||||
impl<T, C, E, S, Call> SubmitSignedTransaction<T, Call> for TransactionSubmitter<S, C, E> where
|
||||
T: crate::Trait,
|
||||
C: CreateTransaction<T, E>,
|
||||
E: ExtrinsicT<Call=Call> + codec::Encode,
|
||||
S: Signer<<C as CreateTransaction<T, E>>::Public, <C as CreateTransaction<T, E>>::Signature>,
|
||||
// Make sure we can unwrap the app crypto key.
|
||||
S: RuntimeAppPublic + AppPublic + Into<<S as AppPublic>::Generic>,
|
||||
// Make sure we can convert from wrapped crypto to public key (e.g. `MultiSigner`)
|
||||
S::Generic: Into<PublicOf<T, Call, Self>>,
|
||||
// For simplicity we require the same trait to implement `SignAndSubmitTransaction` too.
|
||||
Self: SignAndSubmitTransaction<T, Call, Signer = S, Extrinsic = E, CreateTransaction = C>,
|
||||
{
|
||||
type SignAndSubmit = Self;
|
||||
|
||||
fn find_local_keys(accounts: Option<impl IntoIterator<Item = T::AccountId>>) -> Vec<(
|
||||
T::AccountId,
|
||||
PublicOf<T, Call, Self::SignAndSubmit>,
|
||||
)> {
|
||||
// Convert app-specific keys into generic ones.
|
||||
let local_accounts_and_keys = S::all()
|
||||
.into_iter()
|
||||
.map(|app_key| {
|
||||
// unwrap app-crypto
|
||||
let generic_pub_key: <S as AppPublic>::Generic = app_key.into();
|
||||
// convert to expected public key type (might be MultiSigner)
|
||||
let signer_pub_key: PublicOf<T, Call, Self::SignAndSubmit> = generic_pub_key.into();
|
||||
// lookup accountid for that pubkey
|
||||
let account = signer_pub_key.clone().into_account();
|
||||
(account, signer_pub_key)
|
||||
}).collect::<Vec<_>>();
|
||||
|
||||
if let Some(accounts) = accounts {
|
||||
let mut local_accounts_and_keys = local_accounts_and_keys;
|
||||
// sort by accountId to allow bin-search.
|
||||
local_accounts_and_keys.sort_by(|a, b| a.0.cmp(&b.0));
|
||||
|
||||
// get all the matching accounts
|
||||
accounts.into_iter().filter_map(|acc| {
|
||||
let idx = local_accounts_and_keys.binary_search_by(|a| a.0.cmp(&acc)).ok()?;
|
||||
local_accounts_and_keys.get(idx).cloned()
|
||||
}).collect()
|
||||
} else {
|
||||
// just return all account ids and keys
|
||||
local_accounts_and_keys
|
||||
}
|
||||
}
|
||||
|
||||
fn can_sign_with(accounts: Option<impl IntoIterator<Item = T::AccountId>>) -> bool {
|
||||
// early exit if we care about any account.
|
||||
if accounts.is_none() {
|
||||
!S::all().is_empty()
|
||||
} else {
|
||||
!Self::find_local_keys(accounts).is_empty()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -174,6 +174,7 @@ impl TryFrom<u32> for HttpRequestStatus {
|
||||
/// A blob to hold information about the local node's network state
|
||||
/// without committing to its format.
|
||||
#[derive(Clone, Eq, PartialEq, Encode, Decode, RuntimeDebug, PassByCodec)]
|
||||
#[cfg_attr(feature = "std", derive(Default))]
|
||||
pub struct OpaqueNetworkState {
|
||||
/// PeerId of the local node.
|
||||
pub peer_id: OpaquePeerId,
|
||||
|
||||
@@ -26,9 +26,15 @@ pub const STORAGE_PREFIX: &[u8] = b"storage";
|
||||
|
||||
sp_api::decl_runtime_apis! {
|
||||
/// The offchain worker api.
|
||||
#[api_version(2)]
|
||||
pub trait OffchainWorkerApi {
|
||||
/// Starts the off-chain task for given block number.
|
||||
#[skip_initialize_block]
|
||||
#[changed_in(2)]
|
||||
fn offchain_worker(number: NumberFor<Block>);
|
||||
|
||||
/// Starts the off-chain task for given block header.
|
||||
#[skip_initialize_block]
|
||||
fn offchain_worker(header: &Block::Header);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -23,7 +23,7 @@ use sp_io;
|
||||
use std::fmt::Display;
|
||||
#[cfg(feature = "std")]
|
||||
use serde::{Serialize, Deserialize, de::DeserializeOwned};
|
||||
use sp_core::{self, Hasher, Blake2Hasher, TypeId};
|
||||
use sp_core::{self, Hasher, Blake2Hasher, TypeId, RuntimeDebug};
|
||||
use crate::codec::{Codec, Encode, Decode};
|
||||
use crate::transaction_validity::{
|
||||
ValidTransaction, TransactionValidity, TransactionValidityError, UnknownTransaction,
|
||||
@@ -157,7 +157,7 @@ pub trait EnsureOrigin<OuterOrigin> {
|
||||
}
|
||||
|
||||
/// An error that indicates that a lookup failed.
|
||||
#[derive(Encode, Decode)]
|
||||
#[derive(Encode, Decode, RuntimeDebug)]
|
||||
pub struct LookupError;
|
||||
|
||||
impl From<LookupError> for &'static str {
|
||||
@@ -391,7 +391,7 @@ pub trait Hash: 'static + MaybeSerializeDeserialize + Debug + Clone + Eq + Parti
|
||||
}
|
||||
|
||||
/// Blake2-256 Hash implementation.
|
||||
#[derive(PartialEq, Eq, Clone, sp_core::RuntimeDebug)]
|
||||
#[derive(PartialEq, Eq, Clone, RuntimeDebug)]
|
||||
#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
|
||||
pub struct BlakeTwo256;
|
||||
|
||||
|
||||
@@ -163,6 +163,8 @@ pub trait TransactionPool: Send + Sync {
|
||||
/// Error type.
|
||||
type Error: From<crate::error::Error> + crate::error::IntoPoolError;
|
||||
|
||||
// Networking
|
||||
|
||||
/// Returns a future that imports a bunch of unverified transactions to the pool.
|
||||
fn submit_at(
|
||||
&self,
|
||||
@@ -183,6 +185,8 @@ pub trait TransactionPool: Send + Sync {
|
||||
Self::Error
|
||||
>> + Send + Unpin>;
|
||||
|
||||
// RPC
|
||||
|
||||
/// Returns a future that import a single transaction and starts to watch their progress in the pool.
|
||||
fn submit_and_watch(
|
||||
&self,
|
||||
@@ -190,23 +194,35 @@ pub trait TransactionPool: Send + Sync {
|
||||
xt: TransactionFor<Self>,
|
||||
) -> Box<dyn Future<Output=Result<Box<TransactionStatusStreamFor<Self>>, Self::Error>> + Send + Unpin>;
|
||||
|
||||
/// Remove transactions identified by given hashes (and dependent transactions) from the pool.
|
||||
fn remove_invalid(&self, hashes: &[TxHash<Self>]) -> Vec<Arc<Self::InPoolTransaction>>;
|
||||
|
||||
/// Returns pool status.
|
||||
fn status(&self) -> PoolStatus;
|
||||
// Block production / Networking
|
||||
|
||||
/// Get an iterator for ready transactions ordered by priority
|
||||
fn ready(&self) -> Box<dyn Iterator<Item=Arc<Self::InPoolTransaction>>>;
|
||||
|
||||
|
||||
// Block production
|
||||
|
||||
/// Remove transactions identified by given hashes (and dependent transactions) from the pool.
|
||||
fn remove_invalid(&self, hashes: &[TxHash<Self>]) -> Vec<Arc<Self::InPoolTransaction>>;
|
||||
|
||||
// logging
|
||||
|
||||
/// Returns pool status.
|
||||
fn status(&self) -> PoolStatus;
|
||||
|
||||
// logging / RPC / networking
|
||||
|
||||
/// Return an event stream of transactions imported to the pool.
|
||||
fn import_notification_stream(&self) -> ImportNotificationStream;
|
||||
|
||||
/// Returns transaction hash
|
||||
fn hash_of(&self, xt: &TransactionFor<Self>) -> TxHash<Self>;
|
||||
// networking
|
||||
|
||||
/// Notify the pool about transactions broadcast.
|
||||
fn on_broadcasted(&self, propagations: HashMap<TxHash<Self>, Vec<String>>);
|
||||
|
||||
/// Returns transaction hash
|
||||
fn hash_of(&self, xt: &TransactionFor<Self>) -> TxHash<Self>;
|
||||
}
|
||||
|
||||
/// An abstraction for transaction pool.
|
||||
|
||||
@@ -623,8 +623,8 @@ cfg_if! {
|
||||
}
|
||||
|
||||
impl sp_offchain::OffchainWorkerApi<Block> for Runtime {
|
||||
fn offchain_worker(block: u64) {
|
||||
let ex = Extrinsic::IncludeData(block.encode());
|
||||
fn offchain_worker(header: &<Block as BlockT>::Header) {
|
||||
let ex = Extrinsic::IncludeData(header.number.encode());
|
||||
sp_io::offchain::submit_transaction(ex.encode()).unwrap();
|
||||
}
|
||||
}
|
||||
@@ -839,8 +839,8 @@ cfg_if! {
|
||||
}
|
||||
|
||||
impl sp_offchain::OffchainWorkerApi<Block> for Runtime {
|
||||
fn offchain_worker(block: u64) {
|
||||
let ex = Extrinsic::IncludeData(block.encode());
|
||||
fn offchain_worker(header: &<Block as BlockT>::Header) {
|
||||
let ex = Extrinsic::IncludeData(header.number.encode());
|
||||
sp_io::offchain::submit_transaction(ex.encode()).unwrap()
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user