pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-05-30 10:31:03 +00:00
Code Issues Packages Projects Releases Wiki Activity

Make ParaId value of public paras non-discretionary (#2988)

Browse Source 
* Make ParaId value of public paras non-discretionary

* Fixes

* Fixes

* fix tests

* fix benchmark tests

* dont use hardcoded number

Co-authored-by: Shawn Tabrizi <shawntabrizi@gmail.com>
This commit is contained in:
Gavin Wood
2021-05-07 17:52:26 +02:00
committed by GitHub
parent c0df140ec6
commit ce4edd0398
5 changed files with 241 additions and 221 deletions
Download Patch File Download Diff File Expand all files Collapse all files
polkadot/parachain/src/primitives.rs
+12
View File
@@ -122,10 +122,14 @@ impl From<i32> for Id {
} }
const USER_INDEX_START: u32 = 1000; const USER_INDEX_START: u32 = 1000;
const PUBLIC_INDEX_START: u32 = 2000;
/// The ID of the first user (non-system) parachain. /// The ID of the first user (non-system) parachain.
pub const LOWEST_USER_ID: Id = Id(USER_INDEX_START); pub const LOWEST_USER_ID: Id = Id(USER_INDEX_START);
/// The ID of the first publicly registerable parachain.
pub const LOWEST_PUBLIC_ID: Id = Id(PUBLIC_INDEX_START);
impl Id { impl Id {
/// Create an `Id`. /// Create an `Id`.
pub const fn new(id: u32) -> Self { pub const fn new(id: u32) -> Self {
@@ -151,6 +155,14 @@ impl sp_std::ops::Add<u32> for Id {
} }
} }
impl sp_std::ops::Sub<u32> for Id {
type Output = Self;
fn sub(self, other: u32) -> Self {
Self(self.0 - other)
}
}
#[derive(Clone, Copy, Default, Encode, Decode, Eq, PartialEq, Ord, PartialOrd, RuntimeDebug)] #[derive(Clone, Copy, Default, Encode, Decode, Eq, PartialEq, Ord, PartialOrd, RuntimeDebug)]
pub struct Sibling(pub Id); pub struct Sibling(pub Id);
polkadot/primitives/src/v1/mod.rs
+1 -1
View File
@@ -38,7 +38,7 @@ pub use polkadot_core_primitives::v1::{
// Export some polkadot-parachain primitives // Export some polkadot-parachain primitives
pub use polkadot_parachain::primitives::{ pub use polkadot_parachain::primitives::{
Id, LOWEST_USER_ID, HrmpChannelId, UpwardMessage, HeadData, ValidationCode, Id, LOWEST_USER_ID, LOWEST_PUBLIC_ID, HrmpChannelId, UpwardMessage, HeadData, ValidationCode,
}; };
// Export some basic parachain primitives from v0. // Export some basic parachain primitives from v0.
polkadot/runtime/common/src/integration_tests.rs
+114 -109
View File
@@ -25,7 +25,7 @@ use sp_runtime::{
}, },
}; };
use sp_keystore::{KeystoreExt, testing::KeyStore}; use sp_keystore::{KeystoreExt, testing::KeyStore};
use primitives::v1::{BlockNumber, Header, Id as ParaId, ValidationCode, HeadData}; use primitives::v1::{BlockNumber, Header, Id as ParaId, ValidationCode, HeadData, LOWEST_PUBLIC_ID};
use frame_support::{ use frame_support::{
parameter_types, assert_ok, assert_noop, PalletId, parameter_types, assert_ok, assert_noop, PalletId,
storage::StorageMap, storage::StorageMap,
@@ -292,6 +292,8 @@ fn last_event() -> Event {
#[test] #[test]
fn basic_end_to_end_works() { fn basic_end_to_end_works() {
new_test_ext().execute_with(|| { new_test_ext().execute_with(|| {
let para_1 = LOWEST_PUBLIC_ID;
let para_2 = LOWEST_PUBLIC_ID + 1;
assert!(System::block_number().is_one()); assert!(System::block_number().is_one());
// User 1 and 2 will own parachains // User 1 and 2 will own parachains
Balances::make_free_balance_be(&1, 1_000); Balances::make_free_balance_be(&1, 1_000);
@@ -301,20 +303,20 @@ fn basic_end_to_end_works() {
let validation_code = Registrar::worst_validation_code(); let validation_code = Registrar::worst_validation_code();
assert_ok!(Registrar::register( assert_ok!(Registrar::register(
Origin::signed(1), Origin::signed(1),
ParaId::from(1001), ParaId::from(para_1),
genesis_head.clone(), genesis_head.clone(),
validation_code.clone(), validation_code.clone(),
)); ));
assert_ok!(Registrar::register( assert_ok!(Registrar::register(
Origin::signed(2), Origin::signed(2),
ParaId::from(1002), ParaId::from(2001),
genesis_head, genesis_head,
validation_code, validation_code,
)); ));
// Paras should be onboarding // Paras should be onboarding
assert_eq!(Paras::lifecycle(ParaId::from(1001)), Some(ParaLifecycle::Onboarding)); assert_eq!(Paras::lifecycle(ParaId::from(para_1)), Some(ParaLifecycle::Onboarding));
assert_eq!(Paras::lifecycle(ParaId::from(1002)), Some(ParaLifecycle::Onboarding)); assert_eq!(Paras::lifecycle(ParaId::from(para_2)), Some(ParaLifecycle::Onboarding));
// Start a new auction in the future // Start a new auction in the future
let duration = 99u32; let duration = 99u32;
@@ -323,21 +325,21 @@ fn basic_end_to_end_works() {
// 2 sessions later they are parathreads // 2 sessions later they are parathreads
run_to_session(2); run_to_session(2);
assert_eq!(Paras::lifecycle(ParaId::from(1001)), Some(ParaLifecycle::Parathread)); assert_eq!(Paras::lifecycle(ParaId::from(para_1)), Some(ParaLifecycle::Parathread));
assert_eq!(Paras::lifecycle(ParaId::from(1002)), Some(ParaLifecycle::Parathread)); assert_eq!(Paras::lifecycle(ParaId::from(para_2)), Some(ParaLifecycle::Parathread));
// Para 1 will bid directly for slot 1, 2 // Para 1 will bid directly for slot 1, 2
// Open a crowdloan for Para 2 for slot 3, 4 // Open a crowdloan for Para 2 for slot 3, 4
assert_ok!(Crowdloan::create( assert_ok!(Crowdloan::create(
Origin::signed(2), Origin::signed(2),
ParaId::from(1002), ParaId::from(para_2),
1_000, // Cap 1_000, // Cap
lease_period_index_start + 2, // First Slot lease_period_index_start + 2, // First Slot
lease_period_index_start + 3, // Last Slot lease_period_index_start + 3, // Last Slot
200, // Block End 200, // Block End
None, None,
)); ));
let crowdloan_account = Crowdloan::fund_account_id(ParaId::from(1002)); let crowdloan_account = Crowdloan::fund_account_id(ParaId::from(para_2));
// Auction ending begins on block 100, so we make a bid before then. // Auction ending begins on block 100, so we make a bid before then.
run_to_block(90); run_to_block(90);
@@ -348,7 +350,7 @@ fn basic_end_to_end_works() {
// User 10 will bid directly for parachain 1 // User 10 will bid directly for parachain 1
assert_ok!(Auctions::bid( assert_ok!(Auctions::bid(
Origin::signed(10), Origin::signed(10),
ParaId::from(1001), ParaId::from(para_1),
1, // Auction Index 1, // Auction Index
lease_period_index_start + 0, // First Slot lease_period_index_start + 0, // First Slot
lease_period_index_start + 1, // Last slot lease_period_index_start + 1, // Last slot
@@ -357,13 +359,13 @@ fn basic_end_to_end_works() {
// User 2 will be a contribute to crowdloan for parachain 2 // User 2 will be a contribute to crowdloan for parachain 2
Balances::make_free_balance_be(&2, 1_000); Balances::make_free_balance_be(&2, 1_000);
assert_ok!(Crowdloan::contribute(Origin::signed(2), ParaId::from(1002), 920, None)); assert_ok!(Crowdloan::contribute(Origin::signed(2), ParaId::from(para_2), 920, None));
// Auction ends at block 110 // Auction ends at block 110
run_to_block(109); run_to_block(109);
assert_eq!( assert_eq!(
last_event(), last_event(),
crowdloan::RawEvent::HandleBidResult(ParaId::from(1002), Ok(())).into(), crowdloan::RawEvent::HandleBidResult(ParaId::from(para_2), Ok(())).into(),
); );
run_to_block(110); run_to_block(110);
assert_eq!( assert_eq!(
@@ -373,62 +375,62 @@ fn basic_end_to_end_works() {
// Paras should have won slots // Paras should have won slots
assert_eq!( assert_eq!(
slots::Leases::<Test>::get(ParaId::from(1001)), slots::Leases::<Test>::get(ParaId::from(para_1)),
// -- 1 --- 2 --- 3 --------- 4 ------------ 5 -------- // -- 1 --- 2 --- 3 --------- 4 ------------ 5 --------
vec![None, None, None, Some((10, 910)), Some((10, 910))], vec![None, None, None, Some((10, 910)), Some((10, 910))],
); );
assert_eq!( assert_eq!(
slots::Leases::<Test>::get(ParaId::from(1002)), slots::Leases::<Test>::get(ParaId::from(para_2)),
// -- 1 --- 2 --- 3 --- 4 --- 5 ---------------- 6 --------------------------- 7 ---------------- // -- 1 --- 2 --- 3 --- 4 --- 5 ---------------- 6 --------------------------- 7 ----------------
vec![None, None, None, None, None, Some((crowdloan_account, 920)), Some((crowdloan_account, 920))], vec![None, None, None, None, None, Some((crowdloan_account, 920)), Some((crowdloan_account, 920))],
); );
// Should not be able to contribute to a winning crowdloan // Should not be able to contribute to a winning crowdloan
Balances::make_free_balance_be(&3, 1_000); Balances::make_free_balance_be(&3, 1_000);
assert_noop!(Crowdloan::contribute(Origin::signed(3), ParaId::from(1002), 10, None), CrowdloanError::<Test>::BidOrLeaseActive); assert_noop!(Crowdloan::contribute(Origin::signed(3), ParaId::from(2001), 10, None), CrowdloanError::<Test>::BidOrLeaseActive);
// New leases will start on block 400 // New leases will start on block 400
let lease_start_block = 400; let lease_start_block = 400;
run_to_block(lease_start_block); run_to_block(lease_start_block);
// First slot, Para 1 should be transitioning to Parachain // First slot, Para 1 should be transitioning to Parachain
assert_eq!(Paras::lifecycle(ParaId::from(1001)), Some(ParaLifecycle::UpgradingParathread)); assert_eq!(Paras::lifecycle(ParaId::from(para_1)), Some(ParaLifecycle::UpgradingParathread));
assert_eq!(Paras::lifecycle(ParaId::from(1002)), Some(ParaLifecycle::Parathread)); assert_eq!(Paras::lifecycle(ParaId::from(para_2)), Some(ParaLifecycle::Parathread));
// Two sessions later, it has upgraded // Two sessions later, it has upgraded
run_to_block(lease_start_block + 20); run_to_block(lease_start_block + 20);
assert_eq!(Paras::lifecycle(ParaId::from(1001)), Some(ParaLifecycle::Parachain)); assert_eq!(Paras::lifecycle(ParaId::from(para_1)), Some(ParaLifecycle::Parachain));
assert_eq!(Paras::lifecycle(ParaId::from(1002)), Some(ParaLifecycle::Parathread)); assert_eq!(Paras::lifecycle(ParaId::from(para_2)), Some(ParaLifecycle::Parathread));
// Second slot nothing happens :) // Second slot nothing happens :)
run_to_block(lease_start_block + 100); run_to_block(lease_start_block + 100);
assert_eq!(Paras::lifecycle(ParaId::from(1001)), Some(ParaLifecycle::Parachain)); assert_eq!(Paras::lifecycle(ParaId::from(para_1)), Some(ParaLifecycle::Parachain));
assert_eq!(Paras::lifecycle(ParaId::from(1002)), Some(ParaLifecycle::Parathread)); assert_eq!(Paras::lifecycle(ParaId::from(para_2)), Some(ParaLifecycle::Parathread));
// Third slot, Para 2 should be upgrading, and Para 1 is downgrading // Third slot, Para 2 should be upgrading, and Para 1 is downgrading
run_to_block(lease_start_block + 200); run_to_block(lease_start_block + 200);
assert_eq!(Paras::lifecycle(ParaId::from(1001)), Some(ParaLifecycle::DowngradingParachain)); assert_eq!(Paras::lifecycle(ParaId::from(para_1)), Some(ParaLifecycle::DowngradingParachain));
assert_eq!(Paras::lifecycle(ParaId::from(1002)), Some(ParaLifecycle::UpgradingParathread)); assert_eq!(Paras::lifecycle(ParaId::from(para_2)), Some(ParaLifecycle::UpgradingParathread));
// Two sessions later, they have transitioned // Two sessions later, they have transitioned
run_to_block(lease_start_block + 220); run_to_block(lease_start_block + 220);
assert_eq!(Paras::lifecycle(ParaId::from(1001)), Some(ParaLifecycle::Parathread)); assert_eq!(Paras::lifecycle(ParaId::from(para_1)), Some(ParaLifecycle::Parathread));
assert_eq!(Paras::lifecycle(ParaId::from(1002)), Some(ParaLifecycle::Parachain)); assert_eq!(Paras::lifecycle(ParaId::from(para_2)), Some(ParaLifecycle::Parachain));
// Fourth slot nothing happens :) // Fourth slot nothing happens :)
run_to_block(lease_start_block + 300); run_to_block(lease_start_block + 300);
assert_eq!(Paras::lifecycle(ParaId::from(1001)), Some(ParaLifecycle::Parathread)); assert_eq!(Paras::lifecycle(ParaId::from(para_1)), Some(ParaLifecycle::Parathread));
assert_eq!(Paras::lifecycle(ParaId::from(1002)), Some(ParaLifecycle::Parachain)); assert_eq!(Paras::lifecycle(ParaId::from(para_2)), Some(ParaLifecycle::Parachain));
// Fifth slot, Para 2 is downgrading // Fifth slot, Para 2 is downgrading
run_to_block(lease_start_block + 400); run_to_block(lease_start_block + 400);
assert_eq!(Paras::lifecycle(ParaId::from(1001)), Some(ParaLifecycle::Parathread)); assert_eq!(Paras::lifecycle(ParaId::from(para_1)), Some(ParaLifecycle::Parathread));
assert_eq!(Paras::lifecycle(ParaId::from(1002)), Some(ParaLifecycle::DowngradingParachain)); assert_eq!(Paras::lifecycle(ParaId::from(para_2)), Some(ParaLifecycle::DowngradingParachain));
// Two sessions later, Para 2 is downgraded // Two sessions later, Para 2 is downgraded
run_to_block(lease_start_block + 420); run_to_block(lease_start_block + 420);
assert_eq!(Paras::lifecycle(ParaId::from(1001)), Some(ParaLifecycle::Parathread)); assert_eq!(Paras::lifecycle(ParaId::from(para_1)), Some(ParaLifecycle::Parathread));
assert_eq!(Paras::lifecycle(ParaId::from(1002)), Some(ParaLifecycle::Parathread)); assert_eq!(Paras::lifecycle(ParaId::from(para_2)), Some(ParaLifecycle::Parathread));
}); });
} }
@@ -436,6 +438,7 @@ fn basic_end_to_end_works() {
fn basic_errors_fail() { fn basic_errors_fail() {
new_test_ext().execute_with(|| { new_test_ext().execute_with(|| {
assert!(System::block_number().is_one()); assert!(System::block_number().is_one());
let para_id = LOWEST_PUBLIC_ID;
// Can't double register // Can't double register
Balances::make_free_balance_be(&1, 1_000); Balances::make_free_balance_be(&1, 1_000);
Balances::make_free_balance_be(&2, 1_000); Balances::make_free_balance_be(&2, 1_000);
@@ -444,16 +447,16 @@ fn basic_errors_fail() {
let validation_code = Registrar::worst_validation_code(); let validation_code = Registrar::worst_validation_code();
assert_ok!(Registrar::register( assert_ok!(Registrar::register(
Origin::signed(1), Origin::signed(1),
ParaId::from(1001), para_id,
genesis_head.clone(), genesis_head.clone(),
validation_code.clone(), validation_code.clone(),
)); ));
assert_noop!(Registrar::register( assert_noop!(Registrar::register(
Origin::signed(2), Origin::signed(2),
ParaId::from(1001), para_id,
genesis_head, genesis_head,
validation_code, validation_code,
), paras_registrar::Error::<Test>::AlreadyRegistered); ), paras_registrar::Error::<Test>::InvalidParaId);
// Start an auction // Start an auction
let duration = 99u32; let duration = 99u32;
@@ -463,7 +466,7 @@ fn basic_errors_fail() {
// Cannot create a crowdloan if you do not own the para // Cannot create a crowdloan if you do not own the para
assert_noop!(Crowdloan::create( assert_noop!(Crowdloan::create(
Origin::signed(2), Origin::signed(2),
ParaId::from(1001), para_id,
1_000, // Cap 1_000, // Cap
lease_period_index_start + 2, // First Slot lease_period_index_start + 2, // First Slot
lease_period_index_start + 3, // Last Slot lease_period_index_start + 3, // Last Slot
@@ -479,6 +482,7 @@ fn competing_slots() {
new_test_ext().execute_with(|| { new_test_ext().execute_with(|| {
assert!(System::block_number().is_one()); assert!(System::block_number().is_one());
let max_bids = 10u32; let max_bids = 10u32;
let para_id = LOWEST_PUBLIC_ID;
// Create n paras and owners // Create n paras and owners
for n in 1 ..= max_bids { for n in 1 ..= max_bids {
@@ -487,7 +491,7 @@ fn competing_slots() {
let validation_code = Registrar::worst_validation_code(); let validation_code = Registrar::worst_validation_code();
assert_ok!(Registrar::register( assert_ok!(Registrar::register(
Origin::signed(n), Origin::signed(n),
ParaId::from(1000 + n), para_id + n - 1,
genesis_head, genesis_head,
validation_code, validation_code,
)); ));
@@ -524,7 +528,7 @@ fn competing_slots() {
// Users will bid directly for parachain // Users will bid directly for parachain
assert_ok!(Auctions::bid( assert_ok!(Auctions::bid(
Origin::signed(n * 10), Origin::signed(n * 10),
ParaId::from(1000 + n), para_id + n - 1,
1, // Auction Index 1, // Auction Index
lease_period_index_start + start, // First Slot lease_period_index_start + start, // First Slot
lease_period_index_start + end, // Last slot lease_period_index_start + end, // Last slot
@@ -539,18 +543,18 @@ fn competing_slots() {
// 900 + 4500 + 2x 8100 = 21,600 // 900 + 4500 + 2x 8100 = 21,600
// 900 + 4500 + 7200 + 9000 = 21,600 // 900 + 4500 + 7200 + 9000 = 21,600
assert_eq!( assert_eq!(
slots::Leases::<Test>::get(ParaId::from(1001)), slots::Leases::<Test>::get(para_id),
// -- 1 --- 2 --- 3 ---------- 4 ------ // -- 1 --- 2 --- 3 ---------- 4 ------
vec![None, None, None, Some((10, 900))], vec![None, None, None, Some((10, 900))],
); );
assert_eq!( assert_eq!(
slots::Leases::<Test>::get(ParaId::from(1005)), slots::Leases::<Test>::get(para_id + 4),
// -- 1 --- 2 --- 3 --- 4 ---------- 5 ------- // -- 1 --- 2 --- 3 --- 4 ---------- 5 -------
vec![None, None, None, None, Some((50, 4500))], vec![None, None, None, None, Some((50, 4500))],
); );
// TODO: Is this right? // TODO: Is this right?
assert_eq!( assert_eq!(
slots::Leases::<Test>::get(ParaId::from(1009)), slots::Leases::<Test>::get(para_id + 8),
// -- 1 --- 2 --- 3 --- 4 --- 5 ---------- 6 --------------- 7 ------- // -- 1 --- 2 --- 3 --- 4 --- 5 ---------- 6 --------------- 7 -------
vec![None, None, None, None, None, Some((90, 8100)), Some((90, 8100))], vec![None, None, None, None, None, Some((90, 8100)), Some((90, 8100))],
); );
@@ -567,6 +571,7 @@ fn competing_bids() {
let lease_period_index_start = 4u32; let lease_period_index_start = 4u32;
assert_ok!(Auctions::new_auction(Origin::root(), duration, lease_period_index_start)); assert_ok!(Auctions::new_auction(Origin::root(), duration, lease_period_index_start));
let start_para = LOWEST_PUBLIC_ID - 1;
// Create 3 paras and owners // Create 3 paras and owners
for n in 1 ..= 3 { for n in 1 ..= 3 {
Balances::make_free_balance_be(&n, 1_000); Balances::make_free_balance_be(&n, 1_000);
@@ -574,7 +579,7 @@ fn competing_bids() {
let validation_code = Registrar::worst_validation_code(); let validation_code = Registrar::worst_validation_code();
assert_ok!(Registrar::register( assert_ok!(Registrar::register(
Origin::signed(n), Origin::signed(n),
ParaId::from(1000 + n), ParaId::from(start_para + n),
genesis_head, genesis_head,
validation_code, validation_code,
)); ));
@@ -582,7 +587,7 @@ fn competing_bids() {
// Create a crowdloan for each para // Create a crowdloan for each para
assert_ok!(Crowdloan::create( assert_ok!(Crowdloan::create(
Origin::signed(n), Origin::signed(n),
ParaId::from(1000 + n), ParaId::from(start_para + n),
100_000, // Cap 100_000, // Cap
lease_period_index_start + 2, // First Slot lease_period_index_start + 2, // First Slot
lease_period_index_start + 3, // Last Slot lease_period_index_start + 3, // Last Slot
@@ -597,7 +602,7 @@ fn competing_bids() {
Balances::make_free_balance_be(&(n * 10), n * 1_000); Balances::make_free_balance_be(&(n * 10), n * 1_000);
let para = n % 3 + 1001; let para = start_para + n % 3 + 1;
if n % 2 == 0 { if n % 2 == 0 {
// User 10 will bid directly for parachain 1 // User 10 will bid directly for parachain 1
@@ -624,14 +629,14 @@ fn competing_bids() {
run_to_block(110); run_to_block(110);
// Appropriate Paras should have won slots // Appropriate Paras should have won slots
let crowdloan_2 = Crowdloan::fund_account_id(ParaId::from(1002)); let crowdloan_2 = Crowdloan::fund_account_id(ParaId::from(2001));
assert_eq!( assert_eq!(
slots::Leases::<Test>::get(ParaId::from(1001)), slots::Leases::<Test>::get(ParaId::from(2000)),
// -- 1 --- 2 --- 3 --- 4 --- 5 ------------- 6 ------------------------ 7 ------------- // -- 1 --- 2 --- 3 --- 4 --- 5 ------------- 6 ------------------------ 7 -------------
vec![None, None, None, None, None, Some((crowdloan_2, 1812)), Some((crowdloan_2, 1812))], vec![None, None, None, None, None, Some((crowdloan_2, 1812)), Some((crowdloan_2, 1812))],
); );
assert_eq!( assert_eq!(
slots::Leases::<Test>::get(ParaId::from(1003)), slots::Leases::<Test>::get(ParaId::from(2002)),
// -- 1 --- 2 --- 3 ---------- 4 --------------- 5 ------- // -- 1 --- 2 --- 3 ---------- 4 --------------- 5 -------
vec![None, None, None, Some((80, 7200)), Some((80, 7200))], vec![None, None, None, Some((80, 7200)), Some((80, 7200))],
); );
@@ -649,20 +654,20 @@ fn basic_swap_works() {
// First register 2 parathreads with different data // First register 2 parathreads with different data
assert_ok!(Registrar::register( assert_ok!(Registrar::register(
Origin::signed(1), Origin::signed(1),
ParaId::from(1001), ParaId::from(2000),
test_genesis_head(10), test_genesis_head(10),
test_validation_code(10), test_validation_code(10),
)); ));
assert_ok!(Registrar::register( assert_ok!(Registrar::register(
Origin::signed(2), Origin::signed(2),
ParaId::from(1002), ParaId::from(2001),
test_genesis_head(20), test_genesis_head(20),
test_validation_code(20), test_validation_code(20),
)); ));
// Paras should be onboarding // Paras should be onboarding
assert_eq!(Paras::lifecycle(ParaId::from(1001)), Some(ParaLifecycle::Onboarding)); assert_eq!(Paras::lifecycle(ParaId::from(2000)), Some(ParaLifecycle::Onboarding));
assert_eq!(Paras::lifecycle(ParaId::from(1002)), Some(ParaLifecycle::Onboarding)); assert_eq!(Paras::lifecycle(ParaId::from(2001)), Some(ParaLifecycle::Onboarding));
// Start a new auction in the future // Start a new auction in the future
let duration = 99u32; let duration = 99u32;
@@ -671,26 +676,26 @@ fn basic_swap_works() {
// 2 sessions later they are parathreads // 2 sessions later they are parathreads
run_to_session(2); run_to_session(2);
assert_eq!(Paras::lifecycle(ParaId::from(1001)), Some(ParaLifecycle::Parathread)); assert_eq!(Paras::lifecycle(ParaId::from(2000)), Some(ParaLifecycle::Parathread));
assert_eq!(Paras::lifecycle(ParaId::from(1002)), Some(ParaLifecycle::Parathread)); assert_eq!(Paras::lifecycle(ParaId::from(2001)), Some(ParaLifecycle::Parathread));
// Open a crowdloan for Para 1 for slots 0-3 // Open a crowdloan for Para 1 for slots 0-3
assert_ok!(Crowdloan::create( assert_ok!(Crowdloan::create(
Origin::signed(1), Origin::signed(1),
ParaId::from(1001), ParaId::from(2000),
1_000_000, // Cap 1_000_000, // Cap
lease_period_index_start + 0, // First Slot lease_period_index_start + 0, // First Slot
lease_period_index_start + 3, // Last Slot lease_period_index_start + 3, // Last Slot
200, // Block End 200, // Block End
None, None,
)); ));
let crowdloan_account = Crowdloan::fund_account_id(ParaId::from(1001)); let crowdloan_account = Crowdloan::fund_account_id(ParaId::from(2000));
// Bunch of contributions // Bunch of contributions
let mut total = 0; let mut total = 0;
for i in 10 .. 20 { for i in 10 .. 20 {
Balances::make_free_balance_be(&i, 1_000); Balances::make_free_balance_be(&i, 1_000);
assert_ok!(Crowdloan::contribute(Origin::signed(i), ParaId::from(1001), 900 - i, None)); assert_ok!(Crowdloan::contribute(Origin::signed(i), ParaId::from(2000), 900 - i, None));
total += 900 - i; total += 900 - i;
} }
assert!(total > 0); assert!(total > 0);
@@ -705,49 +710,49 @@ fn basic_swap_works() {
assert_eq!(Balances::reserved_balance(&2), 500 + 20 * 2 * 1); assert_eq!(Balances::reserved_balance(&2), 500 + 20 * 2 * 1);
assert_eq!(Balances::reserved_balance(&crowdloan_account), total); assert_eq!(Balances::reserved_balance(&crowdloan_account), total);
// Crowdloan is appropriately set // Crowdloan is appropriately set
assert!(Crowdloan::funds(ParaId::from(1001)).is_some()); assert!(Crowdloan::funds(ParaId::from(2000)).is_some());
assert!(Crowdloan::funds(ParaId::from(1002)).is_none()); assert!(Crowdloan::funds(ParaId::from(2001)).is_none());
// New leases will start on block 400 // New leases will start on block 400
let lease_start_block = 400; let lease_start_block = 400;
run_to_block(lease_start_block); run_to_block(lease_start_block);
// Slots are won by Para 1 // Slots are won by Para 1
assert!(!Slots::lease(ParaId::from(1001)).is_empty()); assert!(!Slots::lease(ParaId::from(2000)).is_empty());
assert!(Slots::lease(ParaId::from(1002)).is_empty()); assert!(Slots::lease(ParaId::from(2001)).is_empty());
// 2 sessions later it is a parachain // 2 sessions later it is a parachain
run_to_block(lease_start_block + 20); run_to_block(lease_start_block + 20);
assert_eq!(Paras::lifecycle(ParaId::from(1001)), Some(ParaLifecycle::Parachain)); assert_eq!(Paras::lifecycle(ParaId::from(2000)), Some(ParaLifecycle::Parachain));
assert_eq!(Paras::lifecycle(ParaId::from(1002)), Some(ParaLifecycle::Parathread)); assert_eq!(Paras::lifecycle(ParaId::from(2001)), Some(ParaLifecycle::Parathread));
// Initiate a swap // Initiate a swap
assert_ok!(Registrar::swap(para_origin(1001).into(), ParaId::from(1001), ParaId::from(1002))); assert_ok!(Registrar::swap(para_origin(2000).into(), ParaId::from(2000), ParaId::from(2001)));
assert_ok!(Registrar::swap(para_origin(1002).into(), ParaId::from(1002), ParaId::from(1001))); assert_ok!(Registrar::swap(para_origin(2001).into(), ParaId::from(2001), ParaId::from(2000)));
assert_eq!(Paras::lifecycle(ParaId::from(1001)), Some(ParaLifecycle::DowngradingParachain)); assert_eq!(Paras::lifecycle(ParaId::from(2000)), Some(ParaLifecycle::DowngradingParachain));
assert_eq!(Paras::lifecycle(ParaId::from(1002)), Some(ParaLifecycle::UpgradingParathread)); assert_eq!(Paras::lifecycle(ParaId::from(2001)), Some(ParaLifecycle::UpgradingParathread));
// 2 session later they have swapped // 2 session later they have swapped
run_to_block(lease_start_block + 40); run_to_block(lease_start_block + 40);
assert_eq!(Paras::lifecycle(ParaId::from(1001)), Some(ParaLifecycle::Parathread)); assert_eq!(Paras::lifecycle(ParaId::from(2000)), Some(ParaLifecycle::Parathread));
assert_eq!(Paras::lifecycle(ParaId::from(1002)), Some(ParaLifecycle::Parachain)); assert_eq!(Paras::lifecycle(ParaId::from(2001)), Some(ParaLifecycle::Parachain));
// Deregister parathread // Deregister parathread
assert_ok!(Registrar::deregister(para_origin(1001).into(), ParaId::from(1001))); assert_ok!(Registrar::deregister(para_origin(2000).into(), ParaId::from(2000)));
// Correct deposit is unreserved // Correct deposit is unreserved
assert_eq!(Balances::reserved_balance(&1), 100); // crowdloan deposit left over assert_eq!(Balances::reserved_balance(&1), 100); // crowdloan deposit left over
assert_eq!(Balances::reserved_balance(&2), 500 + 20 * 2 * 1); assert_eq!(Balances::reserved_balance(&2), 500 + 20 * 2 * 1);
// Crowdloan ownership is swapped // Crowdloan ownership is swapped
assert!(Crowdloan::funds(ParaId::from(1001)).is_none()); assert!(Crowdloan::funds(ParaId::from(2000)).is_none());
assert!(Crowdloan::funds(ParaId::from(1002)).is_some()); assert!(Crowdloan::funds(ParaId::from(2001)).is_some());
// Slot is swapped // Slot is swapped
assert!(Slots::lease(ParaId::from(1001)).is_empty()); assert!(Slots::lease(ParaId::from(2000)).is_empty());
assert!(!Slots::lease(ParaId::from(1002)).is_empty()); assert!(!Slots::lease(ParaId::from(2001)).is_empty());
// Cant dissolve // Cant dissolve
assert_noop!(Crowdloan::dissolve(Origin::signed(1), ParaId::from(1001)), CrowdloanError::<Test>::InvalidParaId); assert_noop!(Crowdloan::dissolve(Origin::signed(1), ParaId::from(2000)), CrowdloanError::<Test>::InvalidParaId);
assert_noop!(Crowdloan::dissolve(Origin::signed(2), ParaId::from(1002)), CrowdloanError::<Test>::NotReadyToDissolve); assert_noop!(Crowdloan::dissolve(Origin::signed(2), ParaId::from(2001)), CrowdloanError::<Test>::NotReadyToDissolve);
// Go way in the future when the para is offboarded // Go way in the future when the para is offboarded
run_to_block(lease_start_block + 1000); run_to_block(lease_start_block + 1000);
@@ -755,17 +760,17 @@ fn basic_swap_works() {
// Withdraw of contributions works // Withdraw of contributions works
assert_eq!(Balances::free_balance(&crowdloan_account), total); assert_eq!(Balances::free_balance(&crowdloan_account), total);
for i in 10 .. 20 { for i in 10 .. 20 {
assert_ok!(Crowdloan::withdraw(Origin::signed(i), i, ParaId::from(1002))); assert_ok!(Crowdloan::withdraw(Origin::signed(i), i, ParaId::from(2001)));
} }
assert_eq!(Balances::free_balance(&crowdloan_account), 0); assert_eq!(Balances::free_balance(&crowdloan_account), 0);
// Dissolve returns the balance of the person who put a deposit for crowdloan // Dissolve returns the balance of the person who put a deposit for crowdloan
assert_ok!(Crowdloan::dissolve(Origin::signed(1), ParaId::from(1002))); assert_ok!(Crowdloan::dissolve(Origin::signed(1), ParaId::from(2001)));
assert_eq!(Balances::reserved_balance(&1), 0); assert_eq!(Balances::reserved_balance(&1), 0);
assert_eq!(Balances::reserved_balance(&2), 500 + 20 * 2 * 1); assert_eq!(Balances::reserved_balance(&2), 500 + 20 * 2 * 1);
// Final deregister sets everything back to the start // Final deregister sets everything back to the start
assert_ok!(Registrar::deregister(para_origin(1002).into(), ParaId::from(1002))); assert_ok!(Registrar::deregister(para_origin(2001).into(), ParaId::from(2001)));
assert_eq!(Balances::reserved_balance(&2), 0); assert_eq!(Balances::reserved_balance(&2), 0);
}) })
} }
@@ -780,20 +785,20 @@ fn crowdloan_ending_period_bid() {
// First register 2 parathreads // First register 2 parathreads
assert_ok!(Registrar::register( assert_ok!(Registrar::register(
Origin::signed(1), Origin::signed(1),
ParaId::from(1001), ParaId::from(2000),
test_genesis_head(10), test_genesis_head(10),
test_validation_code(10), test_validation_code(10),
)); ));
assert_ok!(Registrar::register( assert_ok!(Registrar::register(
Origin::signed(2), Origin::signed(2),
ParaId::from(1002), ParaId::from(2001),
test_genesis_head(20), test_genesis_head(20),
test_validation_code(20), test_validation_code(20),
)); ));
// Paras should be onboarding // Paras should be onboarding
assert_eq!(Paras::lifecycle(ParaId::from(1001)), Some(ParaLifecycle::Onboarding)); assert_eq!(Paras::lifecycle(ParaId::from(2000)), Some(ParaLifecycle::Onboarding));
assert_eq!(Paras::lifecycle(ParaId::from(1002)), Some(ParaLifecycle::Onboarding)); assert_eq!(Paras::lifecycle(ParaId::from(2001)), Some(ParaLifecycle::Onboarding));
// Start a new auction in the future // Start a new auction in the future
let duration = 99u32; let duration = 99u32;
@@ -802,26 +807,26 @@ fn crowdloan_ending_period_bid() {
// 2 sessions later they are parathreads // 2 sessions later they are parathreads
run_to_session(2); run_to_session(2);
assert_eq!(Paras::lifecycle(ParaId::from(1001)), Some(ParaLifecycle::Parathread)); assert_eq!(Paras::lifecycle(ParaId::from(2000)), Some(ParaLifecycle::Parathread));
assert_eq!(Paras::lifecycle(ParaId::from(1002)), Some(ParaLifecycle::Parathread)); assert_eq!(Paras::lifecycle(ParaId::from(2001)), Some(ParaLifecycle::Parathread));
// Open a crowdloan for Para 1 for slots 0-3 // Open a crowdloan for Para 1 for slots 0-3
assert_ok!(Crowdloan::create( assert_ok!(Crowdloan::create(
Origin::signed(1), Origin::signed(1),
ParaId::from(1001), ParaId::from(2000),
1_000_000, // Cap 1_000_000, // Cap
lease_period_index_start + 0, // First Slot lease_period_index_start + 0, // First Slot
lease_period_index_start + 3, // Last Slot lease_period_index_start + 3, // Last Slot
200, // Block End 200, // Block End
None, None,
)); ));
let crowdloan_account = Crowdloan::fund_account_id(ParaId::from(1001)); let crowdloan_account = Crowdloan::fund_account_id(ParaId::from(2000));
// Bunch of contributions // Bunch of contributions
let mut total = 0; let mut total = 0;
for i in 10 .. 20 { for i in 10 .. 20 {
Balances::make_free_balance_be(&i, 1_000); Balances::make_free_balance_be(&i, 1_000);
assert_ok!(Crowdloan::contribute(Origin::signed(i), ParaId::from(1001), 900 - i, None)); assert_ok!(Crowdloan::contribute(Origin::signed(i), ParaId::from(2000), 900 - i, None));
total += 900 - i; total += 900 - i;
} }
assert!(total > 0); assert!(total > 0);
@@ -831,7 +836,7 @@ fn crowdloan_ending_period_bid() {
Balances::make_free_balance_be(&2, 1_000); Balances::make_free_balance_be(&2, 1_000);
assert_ok!(Auctions::bid( assert_ok!(Auctions::bid(
Origin::signed(2), Origin::signed(2),
ParaId::from(1002), ParaId::from(2001),
1, // Auction Index 1, // Auction Index
lease_period_index_start + 0, // First Slot lease_period_index_start + 0, // First Slot
lease_period_index_start + 1, // Last slot lease_period_index_start + 1, // Last slot
@@ -843,21 +848,21 @@ fn crowdloan_ending_period_bid() {
assert_eq!(Auctions::is_ending(100), Some(0)); assert_eq!(Auctions::is_ending(100), Some(0));
let mut winning = [None; SlotRange::SLOT_RANGE_COUNT]; let mut winning = [None; SlotRange::SLOT_RANGE_COUNT];
winning[SlotRange::ZeroOne as u8 as usize] = Some((2, ParaId::from(1002), 900)); winning[SlotRange::ZeroOne as u8 as usize] = Some((2, ParaId::from(2001), 900));
winning[SlotRange::ZeroThree as u8 as usize] = Some((crowdloan_account, ParaId::from(1001), total)); winning[SlotRange::ZeroThree as u8 as usize] = Some((crowdloan_account, ParaId::from(2000), total));
assert_eq!(Auctions::winning(0), Some(winning)); assert_eq!(Auctions::winning(0), Some(winning));
run_to_block(101); run_to_block(101);
Balances::make_free_balance_be(&1234, 1_000); Balances::make_free_balance_be(&1234, 1_000);
assert_ok!(Crowdloan::contribute(Origin::signed(1234), ParaId::from(1001), 900, None)); assert_ok!(Crowdloan::contribute(Origin::signed(1234), ParaId::from(2000), 900, None));
// Data propagates correctly // Data propagates correctly
run_to_block(102); run_to_block(102);
let mut winning = [None; SlotRange::SLOT_RANGE_COUNT]; let mut winning = [None; SlotRange::SLOT_RANGE_COUNT];
winning[SlotRange::ZeroOne as u8 as usize] = Some((2, ParaId::from(1002), 900)); winning[SlotRange::ZeroOne as u8 as usize] = Some((2, ParaId::from(2001), 900));
winning[SlotRange::ZeroThree as u8 as usize] = Some((crowdloan_account, ParaId::from(1001), total + 900)); winning[SlotRange::ZeroThree as u8 as usize] = Some((crowdloan_account, ParaId::from(2000), total + 900));
assert_eq!(Auctions::winning(2), Some(winning)); assert_eq!(Auctions::winning(2), Some(winning));
}) })
} }
@@ -876,7 +881,7 @@ fn auction_bid_requires_registered_para() {
Balances::make_free_balance_be(&1, 1_000); Balances::make_free_balance_be(&1, 1_000);
assert_noop!(Auctions::bid( assert_noop!(Auctions::bid(
Origin::signed(1), Origin::signed(1),
ParaId::from(1001), ParaId::from(2000),
1, // Auction Index 1, // Auction Index
lease_period_index_start + 0, // First Slot lease_period_index_start + 0, // First Slot
lease_period_index_start + 1, // Last slot lease_period_index_start + 1, // Last slot
@@ -886,7 +891,7 @@ fn auction_bid_requires_registered_para() {
// Now we register the para // Now we register the para
assert_ok!(Registrar::register( assert_ok!(Registrar::register(
Origin::signed(1), Origin::signed(1),
ParaId::from(1001), ParaId::from(2000),
test_genesis_head(10), test_genesis_head(10),
test_validation_code(10), test_validation_code(10),
)); ));
@@ -894,7 +899,7 @@ fn auction_bid_requires_registered_para() {
// Still can't bid until it is fully onboarded // Still can't bid until it is fully onboarded
assert_noop!(Auctions::bid( assert_noop!(Auctions::bid(
Origin::signed(1), Origin::signed(1),
ParaId::from(1001), ParaId::from(2000),
1, // Auction Index 1, // Auction Index
lease_period_index_start + 0, // First Slot lease_period_index_start + 0, // First Slot
lease_period_index_start + 1, // Last slot lease_period_index_start + 1, // Last slot
@@ -908,7 +913,7 @@ fn auction_bid_requires_registered_para() {
Balances::make_free_balance_be(&1, 1_000); Balances::make_free_balance_be(&1, 1_000);
assert_ok!(Auctions::bid( assert_ok!(Auctions::bid(
Origin::signed(1), Origin::signed(1),
ParaId::from(1001), ParaId::from(2000),
1, // Auction Index 1, // Auction Index
lease_period_index_start + 0, // First Slot lease_period_index_start + 0, // First Slot
lease_period_index_start + 1, // Last slot lease_period_index_start + 1, // Last slot
@@ -932,13 +937,13 @@ fn gap_bids_work() {
// Now register 2 paras // Now register 2 paras
assert_ok!(Registrar::register( assert_ok!(Registrar::register(
Origin::signed(1), Origin::signed(1),
ParaId::from(1001), ParaId::from(2000),
test_genesis_head(10), test_genesis_head(10),
test_validation_code(10), test_validation_code(10),
)); ));
assert_ok!(Registrar::register( assert_ok!(Registrar::register(
Origin::signed(2), Origin::signed(2),
ParaId::from(1002), ParaId::from(2001),
test_genesis_head(10), test_genesis_head(10),
test_validation_code(10), test_validation_code(10),
)); ));
@@ -952,7 +957,7 @@ fn gap_bids_work() {
// Slot 1 for 100 from 10 // Slot 1 for 100 from 10
assert_ok!(Auctions::bid( assert_ok!(Auctions::bid(
Origin::signed(10), Origin::signed(10),
ParaId::from(1001), ParaId::from(2000),
1, // Auction Index 1, // Auction Index
lease_period_index_start + 0, // First Slot lease_period_index_start + 0, // First Slot
lease_period_index_start + 0, // Last slot lease_period_index_start + 0, // Last slot
@@ -961,7 +966,7 @@ fn gap_bids_work() {
// Slot 4 for 400 from 10 // Slot 4 for 400 from 10
assert_ok!(Auctions::bid( assert_ok!(Auctions::bid(
Origin::signed(10), Origin::signed(10),
ParaId::from(1001), ParaId::from(2000),
1, // Auction Index 1, // Auction Index
lease_period_index_start + 3, // First Slot lease_period_index_start + 3, // First Slot
lease_period_index_start + 3, // Last slot lease_period_index_start + 3, // Last slot
@@ -971,7 +976,7 @@ fn gap_bids_work() {
// A bid for another para is counted separately. // A bid for another para is counted separately.
assert_ok!(Auctions::bid( assert_ok!(Auctions::bid(
Origin::signed(10), Origin::signed(10),
ParaId::from(1002), ParaId::from(2001),
1, // Auction Index 1, // Auction Index
lease_period_index_start + 1, // First Slot lease_period_index_start + 1, // First Slot
lease_period_index_start + 1, // Last slot lease_period_index_start + 1, // Last slot
@@ -982,7 +987,7 @@ fn gap_bids_work() {
// Slot 2 for 800 from 20, overtaking 10's bid // Slot 2 for 800 from 20, overtaking 10's bid
assert_ok!(Auctions::bid( assert_ok!(Auctions::bid(
Origin::signed(20), Origin::signed(20),
ParaId::from(1001), ParaId::from(2000),
1, // Auction Index 1, // Auction Index
lease_period_index_start + 1, // First Slot lease_period_index_start + 1, // First Slot
lease_period_index_start + 1, // Last slot lease_period_index_start + 1, // Last slot
@@ -991,7 +996,7 @@ fn gap_bids_work() {
// Slot 3 for 200 from 20 // Slot 3 for 200 from 20
assert_ok!(Auctions::bid( assert_ok!(Auctions::bid(
Origin::signed(20), Origin::signed(20),
ParaId::from(1001), ParaId::from(2000),
1, // Auction Index 1, // Auction Index
lease_period_index_start + 2, // First Slot lease_period_index_start + 2, // First Slot
lease_period_index_start + 2, // Last slot lease_period_index_start + 2, // Last slot
@@ -1003,7 +1008,7 @@ fn gap_bids_work() {
// Should have won the lease periods // Should have won the lease periods
assert_eq!( assert_eq!(
slots::Leases::<Test>::get(ParaId::from(1001)), slots::Leases::<Test>::get(ParaId::from(2000)),
// -- 1 --- 2 --- 3 ---------- 4 -------------- 5 -------------- 6 -------------- 7 ------- // -- 1 --- 2 --- 3 ---------- 4 -------------- 5 -------------- 6 -------------- 7 -------
vec![None, None, None, Some((10, 100)), Some((20, 800)), Some((20, 200)), Some((10, 400))], vec![None, None, None, Some((10, 100)), Some((20, 800)), Some((20, 200)), Some((10, 400))],
); );
@@ -1016,7 +1021,7 @@ fn gap_bids_work() {
run_to_block(400); run_to_block(400);
assert_eq!( assert_eq!(
slots::Leases::<Test>::get(ParaId::from(1001)), slots::Leases::<Test>::get(ParaId::from(2000)),
// --------- 4 -------------- 5 -------------- 6 -------------- 7 ------- // --------- 4 -------------- 5 -------------- 6 -------------- 7 -------
vec![Some((10, 100)), Some((20, 800)), Some((20, 200)), Some((10, 400))], vec![Some((10, 100)), Some((20, 800)), Some((20, 200)), Some((10, 400))],
); );
@@ -1027,7 +1032,7 @@ fn gap_bids_work() {
// Lease period 4 is done, but nothing is unreserved since user 1 has a debt on lease 7 // Lease period 4 is done, but nothing is unreserved since user 1 has a debt on lease 7
run_to_block(500); run_to_block(500);
assert_eq!( assert_eq!(
slots::Leases::<Test>::get(ParaId::from(1001)), slots::Leases::<Test>::get(ParaId::from(2000)),
// --------- 5 -------------- 6 -------------- 7 ------- // --------- 5 -------------- 6 -------------- 7 -------
vec![Some((20, 800)), Some((20, 200)), Some((10, 400))], vec![Some((20, 800)), Some((20, 200)), Some((10, 400))],
); );
@@ -1038,7 +1043,7 @@ fn gap_bids_work() {
// Lease period 5 is done, and 20 will unreserve down to 200. // Lease period 5 is done, and 20 will unreserve down to 200.
run_to_block(600); run_to_block(600);
assert_eq!( assert_eq!(
slots::Leases::<Test>::get(ParaId::from(1001)), slots::Leases::<Test>::get(ParaId::from(2000)),
// --------- 6 -------------- 7 ------- // --------- 6 -------------- 7 -------
vec![Some((20, 200)), Some((10, 400))], vec![Some((20, 200)), Some((10, 400))],
); );
@@ -1048,7 +1053,7 @@ fn gap_bids_work() {
// Lease period 6 is done, and 20 will unreserve everything. // Lease period 6 is done, and 20 will unreserve everything.
run_to_block(700); run_to_block(700);
assert_eq!( assert_eq!(
slots::Leases::<Test>::get(ParaId::from(1001)), slots::Leases::<Test>::get(ParaId::from(2000)),
// --------- 7 ------- // --------- 7 -------
vec![Some((10, 400))], vec![Some((10, 400))],
); );
@@ -1057,7 +1062,7 @@ fn gap_bids_work() {
// All leases are done. Everything is unreserved. // All leases are done. Everything is unreserved.
run_to_block(800); run_to_block(800);
assert_eq!(slots::Leases::<Test>::get(ParaId::from(1001)), vec![]); assert_eq!(slots::Leases::<Test>::get(ParaId::from(2000)), vec![]);
assert_eq!(Balances::reserved_balance(&10), 0); assert_eq!(Balances::reserved_balance(&10), 0);
assert_eq!(Balances::reserved_balance(&20), 0); assert_eq!(Balances::reserved_balance(&20), 0);
}); });
polkadot/runtime/common/src/paras_registrar.rs
+114 -110
View File
@@ -26,7 +26,7 @@ use frame_support::{
}; };
use frame_system::{self, ensure_root, ensure_signed}; use frame_system::{self, ensure_root, ensure_signed};
use primitives::v1::{ use primitives::v1::{
Id as ParaId, ValidationCode, HeadData, LOWEST_USER_ID, Id as ParaId, ValidationCode, HeadData, LOWEST_PUBLIC_ID,
}; };
use runtime_parachains::{ use runtime_parachains::{
paras::{ paras::{
@@ -113,6 +113,9 @@ decl_storage! {
/// The given account ID is responsible for registering the code and initial head data, but may only do /// The given account ID is responsible for registering the code and initial head data, but may only do
/// so if it isn't yet registered. (After that, it's up to governance to do so.) /// so if it isn't yet registered. (After that, it's up to governance to do so.)
pub Paras: map hasher(twox_64_concat) ParaId => Option<ParaInfo<T::AccountId, BalanceOf<T>>>; pub Paras: map hasher(twox_64_concat) ParaId => Option<ParaInfo<T::AccountId, BalanceOf<T>>>;
/// The next free `ParaId`.
pub NextFreeParaId: ParaId;
} }
} }
@@ -168,10 +171,15 @@ decl_module! {
/// Register a Para Id on the relay chain. /// Register a Para Id on the relay chain.
/// ///
/// This function will queue the new Para Id to be a parathread. /// This function will queue the new Para `id` to be a parathread.
/// Using the Slots pallet, a parathread can then be upgraded to get a /// Using the Slots pallet, a parathread can then be upgraded to get a
/// parachain slot. /// parachain slot.
/// ///
/// The `id` *MUST* equal the value of `NextFreeParaId`.
///
/// DEPRECATED: This function should generally not be used and is provided for backwards compatibility
/// only. Use `register_next` instead.
///
/// This function must be called by a signed origin. /// This function must be called by a signed origin.
/// ///
/// The origin must pay a deposit for the registration information, /// The origin must pay a deposit for the registration information,
@@ -185,8 +193,12 @@ decl_module! {
validation_code: ValidationCode, validation_code: ValidationCode,
) -> DispatchResult { ) -> DispatchResult {
let who = ensure_signed(origin)?; let who = ensure_signed(origin)?;
ensure!(id >= LOWEST_USER_ID, Error::<T>::InvalidParaId); let valid_id = NextFreeParaId::get().max(LOWEST_PUBLIC_ID);
Self::do_register(who, None, id, genesis_head, validation_code) ensure!(id == valid_id, Error::<T>::InvalidParaId);
Self::do_register(who, None, id, genesis_head, validation_code)?;
NextFreeParaId::set(id + 1);
Ok(())
} }
/// Force the registration of a Para Id on the relay chain. /// Force the registration of a Para Id on the relay chain.
@@ -271,6 +283,30 @@ decl_module! {
ensure_root(origin)?; ensure_root(origin)?;
Self::remove_lock(para); Self::remove_lock(para);
} }
/// Register a Para Id on the relay chain.
///
/// This function will queue the new Para Id to be a parathread.
/// Using the Slots pallet, a parathread can then be upgraded to get a
/// parachain slot.
///
/// This function must be called by a signed origin.
///
/// The origin must pay a deposit for the registration information,
/// including the genesis information and validation code. ParaId
/// must be greater than or equal to 1000.
#[weight = T::WeightInfo::register()]
pub fn register_next(
origin,
genesis_head: HeadData,
validation_code: ValidationCode,
) -> DispatchResult {
let who = ensure_signed(origin)?;
let id = NextFreeParaId::get().max(LOWEST_PUBLIC_ID);
Self::do_register(who, None, id, genesis_head, validation_code)?;
NextFreeParaId::set(id + 1);
Ok(())
}
} }
} }
@@ -649,40 +685,41 @@ mod tests {
#[test] #[test]
fn end_to_end_scenario_works() { fn end_to_end_scenario_works() {
new_test_ext().execute_with(|| { new_test_ext().execute_with(|| {
let para_id = LOWEST_PUBLIC_ID;
run_to_block(1); run_to_block(1);
// 1032 is not yet registered // first para is not yet registered
assert!(!Parachains::is_parathread(1032.into())); assert!(!Parachains::is_parathread(para_id));
// We register the Para ID // We register the Para ID
assert_ok!(Registrar::register( assert_ok!(Registrar::register(
Origin::signed(1), Origin::signed(1),
1032.into(), para_id,
test_genesis_head(32), test_genesis_head(32),
test_validation_code(32), test_validation_code(32),
)); ));
run_to_session(2); run_to_session(2);
// It is now a parathread. // It is now a parathread.
assert!(Parachains::is_parathread(1032.into())); assert!(Parachains::is_parathread(para_id));
assert!(!Parachains::is_parachain(1032.into())); assert!(!Parachains::is_parachain(para_id));
// Some other external process will elevate parathread to parachain // Some other external process will elevate parathread to parachain
assert_ok!(Registrar::make_parachain(1032.into())); assert_ok!(Registrar::make_parachain(para_id));
run_to_session(4); run_to_session(4);
// It is now a parachain. // It is now a parachain.
assert!(!Parachains::is_parathread(1032.into())); assert!(!Parachains::is_parathread(para_id));
assert!(Parachains::is_parachain(1032.into())); assert!(Parachains::is_parachain(para_id));
// Turn it back into a parathread // Turn it back into a parathread
assert_ok!(Registrar::make_parathread(1032.into())); assert_ok!(Registrar::make_parathread(para_id));
run_to_session(6); run_to_session(6);
assert!(Parachains::is_parathread(1032.into())); assert!(Parachains::is_parathread(para_id));
assert!(!Parachains::is_parachain(1032.into())); assert!(!Parachains::is_parachain(para_id));
// Deregister it // Deregister it
assert_ok!(Registrar::deregister( assert_ok!(Registrar::deregister(
Origin::root(), Origin::root(),
1032.into(), para_id,
)); ));
run_to_session(8); run_to_session(8);
// It is nothing // It is nothing
assert!(!Parachains::is_parathread(1032.into())); assert!(!Parachains::is_parathread(para_id));
assert!(!Parachains::is_parachain(1032.into())); assert!(!Parachains::is_parachain(para_id));
}); });
} }
@@ -690,15 +727,16 @@ mod tests {
fn register_works() { fn register_works() {
new_test_ext().execute_with(|| { new_test_ext().execute_with(|| {
run_to_block(1); run_to_block(1);
assert!(!Parachains::is_parathread(1032.into())); let para_id = LOWEST_PUBLIC_ID;
assert!(!Parachains::is_parathread(para_id));
assert_ok!(Registrar::register( assert_ok!(Registrar::register(
Origin::signed(1), Origin::signed(1),
1032.into(), para_id,
test_genesis_head(32), test_genesis_head(32),
test_validation_code(32), test_validation_code(32),
)); ));
run_to_session(2); run_to_session(2);
assert!(Parachains::is_parathread(1032.into())); assert!(Parachains::is_parathread(para_id));
assert_eq!( assert_eq!(
Balances::reserved_balance(&1), Balances::reserved_balance(&1),
<Test as Config>::ParaDeposit::get() + 64 * <Test as Config>::DataDepositPerByte::get() <Test as Config>::ParaDeposit::get() + 64 * <Test as Config>::DataDepositPerByte::get()
@@ -717,30 +755,31 @@ mod tests {
test_validation_code(<Test as super::Config>::MaxCodeSize::get() as usize), test_validation_code(<Test as super::Config>::MaxCodeSize::get() as usize),
), Error::<Test>::InvalidParaId); ), Error::<Test>::InvalidParaId);
// Successfully register 1032 // Successfully register para
let para_id = LOWEST_PUBLIC_ID;
assert_ok!(Registrar::register( assert_ok!(Registrar::register(
Origin::signed(1), Origin::signed(1),
1032.into(), para_id,
test_genesis_head(<Test as super::Config>::MaxHeadSize::get() as usize), test_genesis_head(<Test as super::Config>::MaxHeadSize::get() as usize),
test_validation_code(<Test as super::Config>::MaxCodeSize::get() as usize), test_validation_code(<Test as super::Config>::MaxCodeSize::get() as usize),
)); ));
run_to_session(2); run_to_session(2);
assert_ok!(Registrar::deregister(Origin::root(), 1032.into())); assert_ok!(Registrar::deregister(Origin::root(), para_id));
// Can't do it again until offboarded from the paras backend // Can't do it again
assert_noop!(Registrar::register( assert_noop!(Registrar::register(
Origin::signed(1), Origin::signed(1),
1032.into(), para_id,
test_genesis_head(<Test as super::Config>::MaxHeadSize::get() as usize), test_genesis_head(<Test as super::Config>::MaxHeadSize::get() as usize),
test_validation_code(<Test as super::Config>::MaxCodeSize::get() as usize), test_validation_code(<Test as super::Config>::MaxCodeSize::get() as usize),
), Error::<Test>::AlreadyRegistered); ), Error::<Test>::InvalidParaId);
// Head Size Check // Head Size Check
assert_noop!(Registrar::register( assert_noop!(Registrar::register(
Origin::signed(2), Origin::signed(2),
1023.into(), para_id + 1,
test_genesis_head((<Test as super::Config>::MaxHeadSize::get() + 1) as usize), test_genesis_head((<Test as super::Config>::MaxHeadSize::get() + 1) as usize),
test_validation_code(<Test as super::Config>::MaxCodeSize::get() as usize), test_validation_code(<Test as super::Config>::MaxCodeSize::get() as usize),
), Error::<Test>::HeadDataTooLarge); ), Error::<Test>::HeadDataTooLarge);
@@ -748,7 +787,7 @@ mod tests {
// Code Size Check // Code Size Check
assert_noop!(Registrar::register( assert_noop!(Registrar::register(
Origin::signed(2), Origin::signed(2),
1023.into(), para_id + 1,
test_genesis_head(<Test as super::Config>::MaxHeadSize::get() as usize), test_genesis_head(<Test as super::Config>::MaxHeadSize::get() as usize),
test_validation_code((<Test as super::Config>::MaxCodeSize::get() + 1) as usize), test_validation_code((<Test as super::Config>::MaxCodeSize::get() + 1) as usize),
), Error::<Test>::CodeTooLarge); ), Error::<Test>::CodeTooLarge);
@@ -756,7 +795,7 @@ mod tests {
// Needs enough funds for deposit // Needs enough funds for deposit
assert_noop!(Registrar::register( assert_noop!(Registrar::register(
Origin::signed(1337), Origin::signed(1337),
1023.into(), para_id + 1,
test_genesis_head(<Test as super::Config>::MaxHeadSize::get() as usize), test_genesis_head(<Test as super::Config>::MaxHeadSize::get() as usize),
test_validation_code(<Test as super::Config>::MaxCodeSize::get() as usize), test_validation_code(<Test as super::Config>::MaxCodeSize::get() as usize),
), BalancesError::<Test, _>::InsufficientBalance); ), BalancesError::<Test, _>::InsufficientBalance);
@@ -767,10 +806,11 @@ mod tests {
fn deregister_works() { fn deregister_works() {
new_test_ext().execute_with(|| { new_test_ext().execute_with(|| {
run_to_block(1); run_to_block(1);
assert!(!Parachains::is_parathread(1032.into())); let para_id = LOWEST_PUBLIC_ID;
assert!(!Parachains::is_parathread(para_id));
assert_ok!(Registrar::register( assert_ok!(Registrar::register(
Origin::signed(1), Origin::signed(1),
1032.into(), para_id,
test_genesis_head(32), test_genesis_head(32),
test_validation_code(32), test_validation_code(32),
)); ));
@@ -779,13 +819,13 @@ mod tests {
<Test as Config>::ParaDeposit::get() + 64 * <Test as Config>::DataDepositPerByte::get() <Test as Config>::ParaDeposit::get() + 64 * <Test as Config>::DataDepositPerByte::get()
); );
run_to_session(2); run_to_session(2);
assert!(Parachains::is_parathread(1032.into())); assert!(Parachains::is_parathread(para_id));
assert_ok!(Registrar::deregister( assert_ok!(Registrar::deregister(
Origin::root(), Origin::root(),
1032.into(), para_id,
)); ));
run_to_session(4); run_to_session(4);
assert!(paras::Module::<Test>::lifecycle(1032.into()).is_none()); assert!(paras::Module::<Test>::lifecycle(para_id).is_none());
assert_eq!(Balances::reserved_balance(&1), 0); assert_eq!(Balances::reserved_balance(&1), 0);
}); });
} }
@@ -794,26 +834,27 @@ mod tests {
fn deregister_handles_basic_errors() { fn deregister_handles_basic_errors() {
new_test_ext().execute_with(|| { new_test_ext().execute_with(|| {
run_to_block(1); run_to_block(1);
assert!(!Parachains::is_parathread(1032.into())); let para_id = LOWEST_PUBLIC_ID;
assert!(!Parachains::is_parathread(para_id));
assert_ok!(Registrar::register( assert_ok!(Registrar::register(
Origin::signed(1), Origin::signed(1),
1032.into(), para_id,
test_genesis_head(32), test_genesis_head(32),
test_validation_code(32), test_validation_code(32),
)); ));
run_to_session(2); run_to_session(2);
assert!(Parachains::is_parathread(1032.into())); assert!(Parachains::is_parathread(para_id));
// Owner check // Owner check
assert_noop!(Registrar::deregister( assert_noop!(Registrar::deregister(
Origin::signed(2), Origin::signed(2),
1032.into(), para_id,
), BadOrigin); ), BadOrigin);
assert_ok!(Registrar::make_parachain(1032.into())); assert_ok!(Registrar::make_parachain(para_id));
run_to_session(4); run_to_session(4);
// Cant directly deregister parachain // Cant directly deregister parachain
assert_noop!(Registrar::deregister( assert_noop!(Registrar::deregister(
Origin::root(), Origin::root(),
1032.into(), para_id,
), Error::<Test>::NotParathread); ), Error::<Test>::NotParathread);
}); });
} }
@@ -821,97 +862,59 @@ mod tests {
#[test] #[test]
fn swap_works() { fn swap_works() {
new_test_ext().execute_with(|| { new_test_ext().execute_with(|| {
// Successfully register 1023 and 1032 // Successfully register first two parachains
let para_1 = LOWEST_PUBLIC_ID;
let para_2 = LOWEST_PUBLIC_ID + 1;
assert_ok!(Registrar::register( assert_ok!(Registrar::register(
Origin::signed(1), Origin::signed(1),
1023.into(), para_1,
test_genesis_head(<Test as super::Config>::MaxHeadSize::get() as usize), test_genesis_head(<Test as super::Config>::MaxHeadSize::get() as usize),
test_validation_code(<Test as super::Config>::MaxCodeSize::get() as usize), test_validation_code(<Test as super::Config>::MaxCodeSize::get() as usize),
)); ));
assert_ok!(Registrar::register( assert_ok!(Registrar::register(
Origin::signed(2), Origin::signed(2),
1032.into(), para_2,
test_genesis_head(<Test as super::Config>::MaxHeadSize::get() as usize), test_genesis_head(<Test as super::Config>::MaxHeadSize::get() as usize),
test_validation_code(<Test as super::Config>::MaxCodeSize::get() as usize), test_validation_code(<Test as super::Config>::MaxCodeSize::get() as usize),
)); ));
run_to_session(2); run_to_session(2);
// Upgrade 1023 into a parachain // Upgrade 1023 into a parachain
assert_ok!(Registrar::make_parachain(1023.into())); assert_ok!(Registrar::make_parachain(para_1));
run_to_session(4); run_to_session(4);
// Roles are as we expect // Roles are as we expect
assert!(Parachains::is_parachain(1023.into())); assert!(Parachains::is_parachain(para_1));
assert!(!Parachains::is_parathread(1023.into())); assert!(!Parachains::is_parathread(para_1));
assert!(!Parachains::is_parachain(1032.into())); assert!(!Parachains::is_parachain(para_2));
assert!(Parachains::is_parathread(1032.into())); assert!(Parachains::is_parathread(para_2));
// Both paras initiate a swap // Both paras initiate a swap
assert_ok!(Registrar::swap( assert_ok!(Registrar::swap(
para_origin(1023.into()), para_origin(para_1),
1023.into(), para_1,
1032.into(), para_2,
)); ));
assert_ok!(Registrar::swap( assert_ok!(Registrar::swap(
para_origin(1032.into()), para_origin(para_2),
1032.into(), para_2,
1023.into(), para_1,
)); ));
run_to_session(6); run_to_session(6);
// Deregister a parathread that was originally a parachain // Deregister a parathread that was originally a parachain
assert_eq!(Parachains::lifecycle(1023.into()), Some(ParaLifecycle::Parathread)); assert_eq!(Parachains::lifecycle(para_1), Some(ParaLifecycle::Parathread));
assert_ok!(Registrar::deregister(runtime_parachains::Origin::Parachain(1023.into()).into(), 1023.into())); assert_ok!(Registrar::deregister(runtime_parachains::Origin::Parachain(para_1).into(), para_1));
run_to_block(21); run_to_block(21);
// Roles are swapped // Roles are swapped
assert!(!Parachains::is_parachain(1023.into())); assert!(!Parachains::is_parachain(para_1));
assert!(Parachains::is_parathread(1023.into())); assert!(Parachains::is_parathread(para_1));
assert!(Parachains::is_parachain(1032.into())); assert!(Parachains::is_parachain(para_2));
assert!(!Parachains::is_parathread(1032.into())); assert!(!Parachains::is_parathread(para_2));
});
}
#[test]
fn cannot_register_until_para_is_cleaned_up() {
new_test_ext().execute_with(|| {
run_to_block(1);
assert_ok!(Registrar::register(
Origin::signed(1),
1001.into(),
vec![1; 3].into(),
vec![1, 2, 3].into()
));
// 2 session changes to fully onboard.
run_to_session(2);
assert_eq!(Parachains::lifecycle(1001.into()), Some(ParaLifecycle::Parathread));
assert_ok!(Registrar::deregister(Origin::root(), 1001.into()));
// Cannot register while it is offboarding.
run_to_session(3);
assert_noop!(Registrar::register(
Origin::signed(1),
1001.into(),
vec![1; 3].into(),
vec![1, 2, 3].into()
), Error::<Test>::AlreadyRegistered);
// By session 4, it is offboarded, and we can register again.
run_to_session(4);
assert_ok!(Registrar::register(
Origin::signed(1),
1001.into(),
vec![1; 3].into(),
vec![1, 2, 3].into()
));
}); });
} }
@@ -919,26 +922,27 @@ mod tests {
fn para_lock_works() { fn para_lock_works() {
new_test_ext().execute_with(|| { new_test_ext().execute_with(|| {
run_to_block(1); run_to_block(1);
let para_id = LOWEST_PUBLIC_ID;
assert_ok!(Registrar::register( assert_ok!(Registrar::register(
Origin::signed(1), Origin::signed(1),
1001.into(), para_id,
vec![1; 3].into(), vec![1; 3].into(),
vec![1, 2, 3].into(), vec![1, 2, 3].into(),
)); ));
// Owner can call swap // Owner can call swap
assert_ok!(Registrar::swap(Origin::signed(1), 1001.into(), 1002.into())); assert_ok!(Registrar::swap(Origin::signed(1), para_id, para_id + 1));
// 2 session changes to fully onboard. // 2 session changes to fully onboard.
run_to_session(2); run_to_session(2);
assert_eq!(Parachains::lifecycle(1001.into()), Some(ParaLifecycle::Parathread)); assert_eq!(Parachains::lifecycle(para_id), Some(ParaLifecycle::Parathread));
// Once they begin onboarding, we lock them in. // Once they begin onboarding, we lock them in.
assert_ok!(Registrar::make_parachain(1001.into())); assert_ok!(Registrar::make_parachain(para_id));
// Owner cannot call swap anymore // Owner cannot call swap anymore
assert_noop!(Registrar::swap(Origin::signed(1), 1001.into(), 1003.into()), BadOrigin); assert_noop!(Registrar::swap(Origin::signed(1), para_id, para_id + 2), BadOrigin);
}); });
} }
} }
@@ -988,7 +992,7 @@ mod benchmarking {
where_clause { where ParaOrigin: Into<<T as frame_system::Config>::Origin> } where_clause { where ParaOrigin: Into<<T as frame_system::Config>::Origin> }
register { register {
let para = ParaId::from(1337); let para = LOWEST_PUBLIC_ID;
let genesis_head = Registrar::<T>::worst_head_data(); let genesis_head = Registrar::<T>::worst_head_data();
let validation_code = Registrar::<T>::worst_validation_code(); let validation_code = Registrar::<T>::worst_validation_code();
let caller: T::AccountId = whitelisted_caller(); let caller: T::AccountId = whitelisted_caller();
@@ -1016,7 +1020,7 @@ mod benchmarking {
} }
deregister { deregister {
let para = register_para::<T>(1337); let para = register_para::<T>(LOWEST_PUBLIC_ID.into());
next_scheduled_session::<T>(); next_scheduled_session::<T>();
let caller: T::AccountId = whitelisted_caller(); let caller: T::AccountId = whitelisted_caller();
}: _(RawOrigin::Signed(caller), para) }: _(RawOrigin::Signed(caller), para)
@@ -1025,8 +1029,8 @@ mod benchmarking {
} }
swap { swap {
let parathread = register_para::<T>(1337); let parathread = register_para::<T>(LOWEST_PUBLIC_ID.into());
let parachain = register_para::<T>(1338); let parachain = register_para::<T>((LOWEST_PUBLIC_ID + 1).into());
let parachain_origin = para_origin(parachain.into()); let parachain_origin = para_origin(parachain.into());
polkadot/runtime/rococo/src/lib.rs
-1
View File
@@ -585,7 +585,6 @@ type LocalOriginConverter = (
parameter_types! { parameter_types! {
pub const BaseXcmWeight: Weight = 100_000; pub const BaseXcmWeight: Weight = 100_000;
pub const RocFee: (MultiLocation, u128) = (RocLocation::get(), 1 * CENTS);
} }
/// The XCM router. When we want to send an XCM message, we use this type. It amalgamates all of our /// The XCM router. When we want to send an XCM message, we use this type. It amalgamates all of our