mirror of
https://github.com/pezkuwichain/pezkuwi-subxt.git
synced 2026-05-31 00:31:02 +00:00
Hernando Castano
a6048bca59
* Support multiple "best headers" from different forks * Update the name of a test * Add note about multiple scheduled changes * Disallow multiple scheduled authority set changes * Return multiple best headers from Runtime APIs * Remove invalid test write-up * Add some sketch-ups of test scenarios * Clean up test scenarios * Add module for testing forks * Write headers to storage * Add way to check expected outcome for header imports * Add support for importing finality proofs * Support importing headers which schedule changes * Write out test scenario using new framework * Map authority set changes across forks Gets all the tests in the `forks` module passing * Remove basic tests These were used when working on the initial test helper * Prevent multiple pending set changes on the same fork * Remove old test which allowed imports past unfinalized header * Ignore failing test (for now) * Rewrite `if` comparison using `match` and `cmp` Fixes Clippy warning: `comparison_chain` * Add helper for writing test headers with default characteristics * Fix test that checked authority set updates * Make note about importing headers on different unfinalized fork * Perform some cleanup on the fork module * Fix Clippy complaints * Provide list of unfinalized headers to Runtime APIs * Add proofs to expect() calls * Make tests the focus of the forks module * Allow specific errors to be checked in fork tests * Remove unused method * Replace unreachable() statement with expect() * Rename storage `unfinalized_headers() `to make its purpose more clear * Update Runtime API name in relayer to match pallet * Commit `unfinalized_headers` changes I forgot to add * Rename ChainTipHeight to BestHeight * Make schedule_next_set_change require a mutable reference * Remove check for key when enacting authority set We only expect to take the happy-path in the pallet anyways, so this check to save ourselves the time spent decoding the entry isn't really used. * Clear justification set when writing headers to storage * Clarify why we only allow one set change per fork * Change best_headers() to return HeaderIDs Prevents us from returning full headers (which are more expensive to get from storage) since we only care about header IDs (number, hash) anyways. * Fix Clippy complaint * Make note about equivocations * Use HeaderIds when returning incomplete headers This change stops returning full headers which are more expensive to get from storage than header Ids (number, hash) are. Clients likely don't need the full header anyways which is why this change is fine. * Introduce HeaderId type to reduce type complexity * Add signal hash to storage during genesis config * Return error instead of expect()-ing * Fix Clippy lint about `ok_or` fn call * Rename `forks` module to indicate that it's for testing * Use `const` for `expect()` proofs * Remove check that key exists before `kill`-ing value Co-authored-by: Svyatoslav Nikolsky <svyatonik@gmail.com>
111 lines
4.4 KiB
Rust
111 lines
4.4 KiB
Rust
// Copyright 2019-2020 Parity Technologies (UK) Ltd.
|
|
// This file is part of Parity Bridges Common.
|
|
|
|
// Parity Bridges Common 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.
|
|
|
|
// Parity Bridges Common 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 Parity Bridges Common. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
#![cfg_attr(not(feature = "std"), no_std)]
|
|
// RuntimeApi generated functions
|
|
#![allow(clippy::too_many_arguments)]
|
|
// Runtime-generated DecodeLimit::decode_all_With_depth_limit
|
|
#![allow(clippy::unnecessary_mut_passed)]
|
|
|
|
use bp_runtime::Chain;
|
|
use frame_support::{weights::Weight, RuntimeDebug};
|
|
use sp_core::Hasher as HasherT;
|
|
use sp_runtime::{
|
|
traits::{BlakeTwo256, IdentifyAccount, Verify},
|
|
MultiSignature, MultiSigner,
|
|
};
|
|
use sp_std::prelude::*;
|
|
|
|
/// Maximal weight of single Millau block.
|
|
pub const MAXIMUM_BLOCK_WEIGHT: Weight = 2_000_000_000_000;
|
|
/// Portion of block reserved for regular transactions.
|
|
pub const AVAILABLE_BLOCK_RATIO: u32 = 75;
|
|
/// Maximal weight of single Millau extrinsic (65% of maximum block weight = 75% for regular
|
|
/// transactions minus 10% for initialization).
|
|
pub const MAXIMUM_EXTRINSIC_WEIGHT: Weight = MAXIMUM_BLOCK_WEIGHT / 100 * (AVAILABLE_BLOCK_RATIO as Weight - 10);
|
|
|
|
/// Block number type used in Millau.
|
|
pub type BlockNumber = u32;
|
|
|
|
/// Hash type used in Millau.
|
|
pub type Hash = <BlakeTwo256 as HasherT>::Out;
|
|
|
|
/// The type of an object that can produce hashes on Millau.
|
|
pub type Hasher = BlakeTwo256;
|
|
|
|
/// The header type used by Millau.
|
|
pub type Header = sp_runtime::generic::Header<BlockNumber, Hasher>;
|
|
|
|
/// Millau chain.
|
|
#[derive(RuntimeDebug)]
|
|
pub struct Millau;
|
|
|
|
impl Chain for Millau {
|
|
type BlockNumber = BlockNumber;
|
|
type Hash = Hash;
|
|
type Hasher = Hasher;
|
|
type Header = Header;
|
|
}
|
|
|
|
/// Name of the `MillauHeaderApi::best_block` runtime method.
|
|
pub const BEST_MILLAU_BLOCKS_METHOD: &str = "MillauHeaderApi_best_blocks";
|
|
/// Name of the `MillauHeaderApi::finalized_block` runtime method.
|
|
pub const FINALIZED_MILLAU_BLOCK_METHOD: &str = "MillauHeaderApi_finalized_block";
|
|
/// Name of the `MillauHeaderApi::is_known_block` runtime method.
|
|
pub const IS_KNOWN_MILLAU_BLOCK_METHOD: &str = "MillauHeaderApi_is_known_block";
|
|
/// Name of the `MillauHeaderApi::incomplete_headers` runtime method.
|
|
pub const INCOMPLETE_MILLAU_HEADERS_METHOD: &str = "MillauHeaderApi_incomplete_headers";
|
|
|
|
/// Alias to 512-bit hash when used in the context of a transaction signature on the chain.
|
|
pub type Signature = MultiSignature;
|
|
|
|
/// Some way of identifying an account on the chain. We intentionally make it equivalent
|
|
/// to the public key of our transaction signing scheme.
|
|
pub type AccountId = <<Signature as Verify>::Signer as IdentifyAccount>::AccountId;
|
|
|
|
/// Public key of the chain account that may be used to verify signatures.
|
|
pub type AccountSigner = MultiSigner;
|
|
|
|
/// Balance of an account.
|
|
pub type Balance = u128;
|
|
|
|
sp_api::decl_runtime_apis! {
|
|
/// API for querying information about Millau headers from the Bridge Pallet instance.
|
|
///
|
|
/// This API is implemented by runtimes that are bridging with Millau chain, not the
|
|
/// Millau runtime itself.
|
|
pub trait MillauHeaderApi {
|
|
/// Returns number and hash of the best blocks known to the bridge module.
|
|
///
|
|
/// Will return multiple headers if there are many headers at the same "best" height.
|
|
///
|
|
/// The caller should only submit an `import_header` transaction that makes
|
|
/// (or leads to making) other header the best one.
|
|
fn best_blocks() -> Vec<(BlockNumber, Hash)>;
|
|
/// Returns number and hash of the best finalized block known to the bridge module.
|
|
fn finalized_block() -> (BlockNumber, Hash);
|
|
/// Returns numbers and hashes of headers that require finality proofs.
|
|
///
|
|
/// An empty response means that there are no headers which currently require a
|
|
/// finality proof.
|
|
fn incomplete_headers() -> Vec<(BlockNumber, Hash)>;
|
|
/// Returns true if the header is known to the runtime.
|
|
fn is_known_block(hash: Hash) -> bool;
|
|
/// Returns true if the header is considered finalized by the runtime.
|
|
fn is_finalized_block(hash: Hash) -> bool;
|
|
}
|
|
}
|