pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-04-27 12:48:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename Origin (#6020)

Browse Source 
* Rename Origin

* fmt

* fixes

* more fixes

* fix

* more fixing

* small fixes

* last touches

* update lockfile for {"substrate"}

Co-authored-by: Shawn Tabrizi <shawntabrizi@gmail.com>
Co-authored-by: parity-processbot <>
This commit is contained in:
Sergej Sakac
2022-09-21 00:53:12 +02:00
committed by GitHub
parent 8d8bd99582
commit 937c4e76ae
46 changed files with 1176 additions and 910 deletions
Download Patch File Download Diff File Expand all files Collapse all files
polkadot/Cargo.lock
Generated
+172 -172
View File
File diff suppressed because it is too large Load Diff
polkadot/runtime/common/src/assigned_slots.rs
+55 -32
View File
@@ -88,7 +88,7 @@ pub mod pallet {
type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
/// Origin for assigning slots.
type AssignSlotOrigin: EnsureOrigin<<Self as frame_system::Config>::Origin>;
type AssignSlotOrigin: EnsureOrigin<<Self as frame_system::Config>::RuntimeOrigin>;
/// The type representing the leasing system.
type Leaser: Leaser<
@@ -592,7 +592,7 @@ mod tests {
type BaseCallFilter = frame_support::traits::Everything;
type BlockWeights = ();
type BlockLength = ();
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type RuntimeCall = RuntimeCall;
type Index = u64;
type BlockNumber = BlockNumber;
@@ -738,7 +738,10 @@ mod tests {
run_to_block(1);
assert_noop!(
AssignedSlots::assign_perm_parachain_slot(Origin::root(), ParaId::from(1_u32),),
AssignedSlots::assign_perm_parachain_slot(
RuntimeOrigin::root(),
ParaId::from(1_u32),
),
Error::<Test>::ParaDoesntExist
);
});
@@ -750,7 +753,10 @@ mod tests {
run_to_block(1);
assert_noop!(
AssignedSlots::assign_perm_parachain_slot(Origin::signed(1), ParaId::from(1_u32),),
AssignedSlots::assign_perm_parachain_slot(
RuntimeOrigin::signed(1),
ParaId::from(1_u32),
),
BadOrigin
);
});
@@ -770,7 +776,10 @@ mod tests {
assert_ok!(TestRegistrar::<Test>::make_parachain(ParaId::from(1_u32)));
assert_noop!(
AssignedSlots::assign_perm_parachain_slot(Origin::root(), ParaId::from(1_u32),),
AssignedSlots::assign_perm_parachain_slot(
RuntimeOrigin::root(),
ParaId::from(1_u32),
),
Error::<Test>::NotParathread
);
});
@@ -792,18 +801,24 @@ mod tests {
assert_ok!(Slots::lease_out(ParaId::from(1_u32), &1, 1, 1, 1));
// Try to assign a perm slot in current period fails
assert_noop!(
AssignedSlots::assign_perm_parachain_slot(Origin::root(), ParaId::from(1_u32),),
AssignedSlots::assign_perm_parachain_slot(
RuntimeOrigin::root(),
ParaId::from(1_u32),
),
Error::<Test>::OngoingLeaseExists
);
// Cleanup
assert_ok!(Slots::clear_all_leases(Origin::root(), 1.into()));
assert_ok!(Slots::clear_all_leases(RuntimeOrigin::root(), 1.into()));
// Register lease for next lease period
assert_ok!(Slots::lease_out(ParaId::from(1_u32), &1, 1, 2, 1));
// Should be detected and also fail
assert_noop!(
AssignedSlots::assign_perm_parachain_slot(Origin::root(), ParaId::from(1_u32),),
AssignedSlots::assign_perm_parachain_slot(
RuntimeOrigin::root(),
ParaId::from(1_u32),
),
Error::<Test>::OngoingLeaseExists
);
});
@@ -836,17 +851,20 @@ mod tests {
));
assert_ok!(AssignedSlots::assign_perm_parachain_slot(
Origin::root(),
RuntimeOrigin::root(),
ParaId::from(1_u32),
));
assert_ok!(AssignedSlots::assign_perm_parachain_slot(
Origin::root(),
RuntimeOrigin::root(),
ParaId::from(2_u32),
));
assert_eq!(AssignedSlots::permanent_slot_count(), 2);
assert_noop!(
AssignedSlots::assign_perm_parachain_slot(Origin::root(), ParaId::from(3_u32),),
AssignedSlots::assign_perm_parachain_slot(
RuntimeOrigin::root(),
ParaId::from(3_u32),
),
Error::<Test>::MaxPermanentSlotsExceeded
);
});
@@ -868,7 +886,7 @@ mod tests {
assert_eq!(AssignedSlots::permanent_slots(ParaId::from(1_u32)), None);
assert_ok!(AssignedSlots::assign_perm_parachain_slot(
Origin::root(),
RuntimeOrigin::root(),
ParaId::from(1_u32),
));
@@ -901,7 +919,7 @@ mod tests {
assert_noop!(
AssignedSlots::assign_temp_parachain_slot(
Origin::root(),
RuntimeOrigin::root(),
ParaId::from(1_u32),
SlotLeasePeriodStart::Current
),
@@ -917,7 +935,7 @@ mod tests {
assert_noop!(
AssignedSlots::assign_temp_parachain_slot(
Origin::signed(1),
RuntimeOrigin::signed(1),
ParaId::from(1_u32),
SlotLeasePeriodStart::Current
),
@@ -941,7 +959,7 @@ mod tests {
assert_noop!(
AssignedSlots::assign_temp_parachain_slot(
Origin::root(),
RuntimeOrigin::root(),
ParaId::from(1_u32),
SlotLeasePeriodStart::Current
),
@@ -967,7 +985,7 @@ mod tests {
// Try to assign a perm slot in current period fails
assert_noop!(
AssignedSlots::assign_temp_parachain_slot(
Origin::root(),
RuntimeOrigin::root(),
ParaId::from(1_u32),
SlotLeasePeriodStart::Current
),
@@ -975,14 +993,14 @@ mod tests {
);
// Cleanup
assert_ok!(Slots::clear_all_leases(Origin::root(), 1.into()));
assert_ok!(Slots::clear_all_leases(RuntimeOrigin::root(), 1.into()));
// Register lease for next lease period
assert_ok!(Slots::lease_out(ParaId::from(1_u32), &1, 1, 2, 1));
// Should be detected and also fail
assert_noop!(
AssignedSlots::assign_temp_parachain_slot(
Origin::root(),
RuntimeOrigin::root(),
ParaId::from(1_u32),
SlotLeasePeriodStart::Current
),
@@ -1006,7 +1024,7 @@ mod tests {
));
assert_ok!(AssignedSlots::assign_temp_parachain_slot(
Origin::root(),
RuntimeOrigin::root(),
ParaId::from(n as u32),
SlotLeasePeriodStart::Current
));
@@ -1023,7 +1041,7 @@ mod tests {
));
assert_noop!(
AssignedSlots::assign_temp_parachain_slot(
Origin::root(),
RuntimeOrigin::root(),
ParaId::from(7_u32),
SlotLeasePeriodStart::Current
),
@@ -1047,7 +1065,7 @@ mod tests {
assert_eq!(AssignedSlots::temporary_slots(ParaId::from(1_u32)), None);
assert_ok!(AssignedSlots::assign_temp_parachain_slot(
Origin::root(),
RuntimeOrigin::root(),
ParaId::from(1_u32),
SlotLeasePeriodStart::Current
));
@@ -1122,7 +1140,7 @@ mod tests {
));
assert_ok!(AssignedSlots::assign_temp_parachain_slot(
Origin::root(),
RuntimeOrigin::root(),
ParaId::from(n as u32),
if (n % 2).is_zero() {
SlotLeasePeriodStart::Current
@@ -1214,7 +1232,7 @@ mod tests {
run_to_block(1);
assert_noop!(
AssignedSlots::unassign_parachain_slot(Origin::root(), ParaId::from(1_u32),),
AssignedSlots::unassign_parachain_slot(RuntimeOrigin::root(), ParaId::from(1_u32),),
Error::<Test>::SlotNotAssigned
);
});
@@ -1226,7 +1244,10 @@ mod tests {
run_to_block(1);
assert_noop!(
AssignedSlots::assign_perm_parachain_slot(Origin::signed(1), ParaId::from(1_u32),),
AssignedSlots::assign_perm_parachain_slot(
RuntimeOrigin::signed(1),
ParaId::from(1_u32),
),
BadOrigin
);
});
@@ -1245,15 +1266,16 @@ mod tests {
));
assert_ok!(AssignedSlots::assign_perm_parachain_slot(
Origin::root(),
RuntimeOrigin::root(),
ParaId::from(1_u32),
));
assert_eq!(TestRegistrar::<Test>::is_parachain(ParaId::from(1_u32)), true);
assert_ok!(
AssignedSlots::unassign_parachain_slot(Origin::root(), ParaId::from(1_u32),)
);
assert_ok!(AssignedSlots::unassign_parachain_slot(
RuntimeOrigin::root(),
ParaId::from(1_u32),
));
assert_eq!(AssignedSlots::permanent_slot_count(), 0);
assert_eq!(AssignedSlots::has_permanent_slot(ParaId::from(1_u32)), false);
@@ -1276,16 +1298,17 @@ mod tests {
));
assert_ok!(AssignedSlots::assign_temp_parachain_slot(
Origin::root(),
RuntimeOrigin::root(),
ParaId::from(1_u32),
SlotLeasePeriodStart::Current
));
assert_eq!(TestRegistrar::<Test>::is_parachain(ParaId::from(1_u32)), true);
assert_ok!(
AssignedSlots::unassign_parachain_slot(Origin::root(), ParaId::from(1_u32),)
);
assert_ok!(AssignedSlots::unassign_parachain_slot(
RuntimeOrigin::root(),
ParaId::from(1_u32),
));
assert_eq!(AssignedSlots::temporary_slot_count(), 0);
assert_eq!(AssignedSlots::active_temporary_slot_count(), 0);
polkadot/runtime/common/src/auctions.rs
+69 -69
View File
@@ -117,7 +117,7 @@ pub mod pallet {
type Randomness: Randomness<Self::Hash, Self::BlockNumber>;
/// The origin which may initiate auctions.
type InitiateOrigin: EnsureOrigin<Self::Origin>;
type InitiateOrigin: EnsureOrigin<Self::RuntimeOrigin>;
/// Weight Information for the Extrinsics in the Pallet
type WeightInfo: WeightInfo;
@@ -709,7 +709,7 @@ mod tests {
type BlockWeights = ();
type BlockLength = ();
type DbWeight = ();
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type RuntimeCall = RuntimeCall;
type Index = u64;
type BlockNumber = BlockNumber;
@@ -955,8 +955,8 @@ mod tests {
new_test_ext().execute_with(|| {
run_to_block(1);
assert_noop!(Auctions::new_auction(Origin::signed(1), 5, 1), BadOrigin);
assert_ok!(Auctions::new_auction(Origin::signed(6), 5, 1));
assert_noop!(Auctions::new_auction(RuntimeOrigin::signed(1), 5, 1), BadOrigin);
assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 5, 1));
assert_eq!(AuctionCounter::<Test>::get(), 1);
assert_eq!(
@@ -970,8 +970,8 @@ mod tests {
fn bidding_works() {
new_test_ext().execute_with(|| {
run_to_block(1);
assert_ok!(Auctions::new_auction(Origin::signed(6), 5, 1));
assert_ok!(Auctions::bid(Origin::signed(1), 0.into(), 1, 1, 4, 5));
assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 5, 1));
assert_ok!(Auctions::bid(RuntimeOrigin::signed(1), 0.into(), 1, 1, 4, 5));
assert_eq!(Balances::reserved_balance(1), 5);
assert_eq!(Balances::free_balance(1), 5);
@@ -986,12 +986,12 @@ mod tests {
fn under_bidding_works() {
new_test_ext().execute_with(|| {
run_to_block(1);
assert_ok!(Auctions::new_auction(Origin::signed(6), 5, 1));
assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 5, 1));
assert_ok!(Auctions::bid(Origin::signed(1), 0.into(), 1, 1, 4, 5));
assert_ok!(Auctions::bid(RuntimeOrigin::signed(1), 0.into(), 1, 1, 4, 5));
assert_storage_noop!({
assert_ok!(Auctions::bid(Origin::signed(2), 0.into(), 1, 1, 4, 1));
assert_ok!(Auctions::bid(RuntimeOrigin::signed(2), 0.into(), 1, 1, 4, 1));
});
});
}
@@ -1000,9 +1000,9 @@ mod tests {
fn over_bidding_works() {
new_test_ext().execute_with(|| {
run_to_block(1);
assert_ok!(Auctions::new_auction(Origin::signed(6), 5, 1));
assert_ok!(Auctions::bid(Origin::signed(1), 0.into(), 1, 1, 4, 5));
assert_ok!(Auctions::bid(Origin::signed(2), 0.into(), 1, 1, 4, 6));
assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 5, 1));
assert_ok!(Auctions::bid(RuntimeOrigin::signed(1), 0.into(), 1, 1, 4, 5));
assert_ok!(Auctions::bid(RuntimeOrigin::signed(2), 0.into(), 1, 1, 4, 6));
assert_eq!(Balances::reserved_balance(1), 0);
assert_eq!(Balances::free_balance(1), 10);
@@ -1020,7 +1020,7 @@ mod tests {
new_test_ext().execute_with(|| {
run_to_block(1);
assert_ok!(Auctions::new_auction(Origin::signed(6), 5, 1));
assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 5, 1));
assert_eq!(AuctionCounter::<Test>::get(), 1);
assert_eq!(
@@ -1082,8 +1082,8 @@ mod tests {
fn can_win_auction() {
new_test_ext().execute_with(|| {
run_to_block(1);
assert_ok!(Auctions::new_auction(Origin::signed(6), 5, 1));
assert_ok!(Auctions::bid(Origin::signed(1), 0.into(), 1, 1, 4, 1));
assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 5, 1));
assert_ok!(Auctions::bid(RuntimeOrigin::signed(1), 0.into(), 1, 1, 4, 1));
assert_eq!(Balances::reserved_balance(1), 1);
assert_eq!(Balances::free_balance(1), 9);
run_to_block(9);
@@ -1105,8 +1105,8 @@ mod tests {
fn can_win_auction_with_late_randomness() {
new_test_ext().execute_with(|| {
run_to_block(1);
assert_ok!(Auctions::new_auction(Origin::signed(6), 5, 1));
assert_ok!(Auctions::bid(Origin::signed(1), 0.into(), 1, 1, 4, 1));
assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 5, 1));
assert_ok!(Auctions::bid(RuntimeOrigin::signed(1), 0.into(), 1, 1, 4, 1));
assert_eq!(Balances::reserved_balance(1), 1);
assert_eq!(Balances::free_balance(1), 9);
assert_eq!(
@@ -1159,8 +1159,8 @@ mod tests {
fn can_win_incomplete_auction() {
new_test_ext().execute_with(|| {
run_to_block(1);
assert_ok!(Auctions::new_auction(Origin::signed(6), 5, 1));
assert_ok!(Auctions::bid(Origin::signed(1), 0.into(), 1, 4, 4, 5));
assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 5, 1));
assert_ok!(Auctions::bid(RuntimeOrigin::signed(1), 0.into(), 1, 4, 4, 5));
run_to_block(9);
assert_eq!(leases(), vec![((0.into(), 4), LeaseData { leaser: 1, amount: 5 }),]);
@@ -1172,11 +1172,11 @@ mod tests {
fn should_choose_best_combination() {
new_test_ext().execute_with(|| {
run_to_block(1);
assert_ok!(Auctions::new_auction(Origin::signed(6), 5, 1));
assert_ok!(Auctions::bid(Origin::signed(1), 0.into(), 1, 1, 1, 1));
assert_ok!(Auctions::bid(Origin::signed(2), 0.into(), 1, 2, 3, 4));
assert_ok!(Auctions::bid(Origin::signed(3), 0.into(), 1, 4, 4, 2));
assert_ok!(Auctions::bid(Origin::signed(1), 1.into(), 1, 1, 4, 2));
assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 5, 1));
assert_ok!(Auctions::bid(RuntimeOrigin::signed(1), 0.into(), 1, 1, 1, 1));
assert_ok!(Auctions::bid(RuntimeOrigin::signed(2), 0.into(), 1, 2, 3, 4));
assert_ok!(Auctions::bid(RuntimeOrigin::signed(3), 0.into(), 1, 4, 4, 2));
assert_ok!(Auctions::bid(RuntimeOrigin::signed(1), 1.into(), 1, 1, 4, 2));
run_to_block(9);
assert_eq!(
@@ -1199,15 +1199,15 @@ mod tests {
fn gap_bid_works() {
new_test_ext().execute_with(|| {
run_to_block(1);
assert_ok!(Auctions::new_auction(Origin::signed(6), 5, 1));
assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 5, 1));
// User 1 will make a bid for period 1 and 4 for the same Para 0
assert_ok!(Auctions::bid(Origin::signed(1), 0.into(), 1, 1, 1, 1));
assert_ok!(Auctions::bid(Origin::signed(1), 0.into(), 1, 4, 4, 4));
assert_ok!(Auctions::bid(RuntimeOrigin::signed(1), 0.into(), 1, 1, 1, 1));
assert_ok!(Auctions::bid(RuntimeOrigin::signed(1), 0.into(), 1, 4, 4, 4));
// User 2 and 3 will make a bid for para 1 on period 2 and 3 respectively
assert_ok!(Auctions::bid(Origin::signed(2), 1.into(), 1, 2, 2, 2));
assert_ok!(Auctions::bid(Origin::signed(3), 1.into(), 1, 3, 3, 3));
assert_ok!(Auctions::bid(RuntimeOrigin::signed(2), 1.into(), 1, 2, 2, 2));
assert_ok!(Auctions::bid(RuntimeOrigin::signed(3), 1.into(), 1, 3, 3, 3));
// Total reserved should be the max of the two
assert_eq!(Balances::reserved_balance(1), 4);
@@ -1238,16 +1238,16 @@ mod tests {
fn deposit_credit_should_work() {
new_test_ext().execute_with(|| {
run_to_block(1);
assert_ok!(Auctions::new_auction(Origin::signed(6), 5, 1));
assert_ok!(Auctions::bid(Origin::signed(1), 0.into(), 1, 1, 1, 5));
assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 5, 1));
assert_ok!(Auctions::bid(RuntimeOrigin::signed(1), 0.into(), 1, 1, 1, 5));
assert_eq!(Balances::reserved_balance(1), 5);
run_to_block(10);
assert_eq!(leases(), vec![((0.into(), 1), LeaseData { leaser: 1, amount: 5 }),]);
assert_eq!(TestLeaser::deposit_held(0.into(), &1), 5);
assert_ok!(Auctions::new_auction(Origin::signed(6), 5, 2));
assert_ok!(Auctions::bid(Origin::signed(1), 0.into(), 2, 2, 2, 6));
assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 5, 2));
assert_ok!(Auctions::bid(RuntimeOrigin::signed(1), 0.into(), 2, 2, 2, 6));
// Only 1 reserved since we have a deposit credit of 5.
assert_eq!(Balances::reserved_balance(1), 1);
run_to_block(20);
@@ -1267,16 +1267,16 @@ mod tests {
fn deposit_credit_on_alt_para_should_not_count() {
new_test_ext().execute_with(|| {
run_to_block(1);
assert_ok!(Auctions::new_auction(Origin::signed(6), 5, 1));
assert_ok!(Auctions::bid(Origin::signed(1), 0.into(), 1, 1, 1, 5));
assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 5, 1));
assert_ok!(Auctions::bid(RuntimeOrigin::signed(1), 0.into(), 1, 1, 1, 5));
assert_eq!(Balances::reserved_balance(1), 5);
run_to_block(10);
assert_eq!(leases(), vec![((0.into(), 1), LeaseData { leaser: 1, amount: 5 }),]);
assert_eq!(TestLeaser::deposit_held(0.into(), &1), 5);
assert_ok!(Auctions::new_auction(Origin::signed(6), 5, 2));
assert_ok!(Auctions::bid(Origin::signed(1), 1.into(), 2, 2, 2, 6));
assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 5, 2));
assert_ok!(Auctions::bid(RuntimeOrigin::signed(1), 1.into(), 2, 2, 2, 6));
// 6 reserved since we are bidding on a new para; only works because we don't
assert_eq!(Balances::reserved_balance(1), 6);
run_to_block(20);
@@ -1298,11 +1298,11 @@ mod tests {
new_test_ext().execute_with(|| {
run_to_block(1);
assert_ok!(Auctions::new_auction(Origin::signed(6), 5, 1));
assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 5, 1));
for i in 1..6u64 {
run_to_block(i as _);
assert_ok!(Auctions::bid(Origin::signed(i), 0.into(), 1, 1, 4, i));
assert_ok!(Auctions::bid(RuntimeOrigin::signed(i), 0.into(), 1, 1, 4, i));
for j in 1..6 {
assert_eq!(Balances::reserved_balance(j), if j == i { j } else { 0 });
assert_eq!(Balances::free_balance(j), if j == i { j * 9 } else { j * 10 });
@@ -1327,11 +1327,11 @@ mod tests {
new_test_ext().execute_with(|| {
run_to_block(1);
assert_ok!(Auctions::new_auction(Origin::signed(6), 0, 1));
assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 0, 1));
for i in 1..6u64 {
run_to_block(((i - 1) / 2 + 1) as _);
assert_ok!(Auctions::bid(Origin::signed(i), 0.into(), 1, 1, 4, i));
assert_ok!(Auctions::bid(RuntimeOrigin::signed(i), 0.into(), 1, 1, 4, i));
for j in 1..6 {
assert_eq!(Balances::reserved_balance(j), if j <= i { j } else { 0 });
assert_eq!(Balances::free_balance(j), if j <= i { j * 9 } else { j * 10 });
@@ -1405,19 +1405,19 @@ mod tests {
fn lower_bids_are_correctly_refunded() {
new_test_ext().execute_with(|| {
run_to_block(1);
assert_ok!(Auctions::new_auction(Origin::signed(6), 1, 1));
assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 1, 1));
let para_1 = ParaId::from(1_u32);
let para_2 = ParaId::from(2_u32);
// Make a bid and reserve a balance
assert_ok!(Auctions::bid(Origin::signed(1), para_1, 1, 1, 4, 10));
assert_ok!(Auctions::bid(RuntimeOrigin::signed(1), para_1, 1, 1, 4, 10));
assert_eq!(Balances::reserved_balance(1), 10);
assert_eq!(ReservedAmounts::<Test>::get((1, para_1)), Some(10));
assert_eq!(Balances::reserved_balance(2), 0);
assert_eq!(ReservedAmounts::<Test>::get((2, para_2)), None);
// Bigger bid, reserves new balance and returns funds
assert_ok!(Auctions::bid(Origin::signed(2), para_2, 1, 1, 4, 20));
assert_ok!(Auctions::bid(RuntimeOrigin::signed(2), para_2, 1, 1, 4, 20));
assert_eq!(Balances::reserved_balance(1), 0);
assert_eq!(ReservedAmounts::<Test>::get((1, para_1)), None);
assert_eq!(Balances::reserved_balance(2), 20);
@@ -1429,14 +1429,14 @@ mod tests {
fn initialize_winners_in_ending_period_works() {
new_test_ext().execute_with(|| {
run_to_block(1);
assert_ok!(Auctions::new_auction(Origin::signed(6), 9, 1));
assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 9, 1));
let para_1 = ParaId::from(1_u32);
let para_2 = ParaId::from(2_u32);
let para_3 = ParaId::from(3_u32);
// Make bids
assert_ok!(Auctions::bid(Origin::signed(1), para_1, 1, 1, 4, 10));
assert_ok!(Auctions::bid(Origin::signed(2), para_2, 1, 3, 4, 20));
assert_ok!(Auctions::bid(RuntimeOrigin::signed(1), para_1, 1, 1, 4, 10));
assert_ok!(Auctions::bid(RuntimeOrigin::signed(2), para_2, 1, 3, 4, 20));
assert_eq!(
Auctions::auction_status(System::block_number()),
@@ -1466,7 +1466,7 @@ mod tests {
AuctionStatus::<u32>::EndingPeriod(1, 0)
);
assert_eq!(Auctions::winning(1), Some(winning));
assert_ok!(Auctions::bid(Origin::signed(3), para_3, 1, 3, 4, 30));
assert_ok!(Auctions::bid(RuntimeOrigin::signed(3), para_3, 1, 3, 4, 30));
run_to_block(12);
assert_eq!(
@@ -1482,9 +1482,9 @@ mod tests {
fn handle_bid_requires_registered_para() {
new_test_ext().execute_with(|| {
run_to_block(1);
assert_ok!(Auctions::new_auction(Origin::signed(6), 5, 1));
assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 5, 1));
assert_noop!(
Auctions::bid(Origin::signed(1), 1337.into(), 1, 1, 4, 1),
Auctions::bid(RuntimeOrigin::signed(1), 1337.into(), 1, 1, 4, 1),
Error::<Test>::ParaNotRegistered
);
assert_ok!(TestRegistrar::<Test>::register(
@@ -1493,7 +1493,7 @@ mod tests {
dummy_head_data(),
dummy_validation_code()
));
assert_ok!(Auctions::bid(Origin::signed(1), 1337.into(), 1, 1, 4, 1));
assert_ok!(Auctions::bid(RuntimeOrigin::signed(1), 1337.into(), 1, 1, 4, 1));
});
}
@@ -1501,8 +1501,8 @@ mod tests {
fn handle_bid_checks_existing_lease_periods() {
new_test_ext().execute_with(|| {
run_to_block(1);
assert_ok!(Auctions::new_auction(Origin::signed(6), 5, 1));
assert_ok!(Auctions::bid(Origin::signed(1), 0.into(), 1, 2, 3, 1));
assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 5, 1));
assert_ok!(Auctions::bid(RuntimeOrigin::signed(1), 0.into(), 1, 2, 3, 1));
assert_eq!(Balances::reserved_balance(1), 1);
assert_eq!(Balances::free_balance(1), 9);
run_to_block(9);
@@ -1518,21 +1518,21 @@ mod tests {
// Para 1 just won an auction above and won some lease periods.
// No bids can work which overlap these periods.
assert_ok!(Auctions::new_auction(Origin::signed(6), 5, 1));
assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 5, 1));
assert_noop!(
Auctions::bid(Origin::signed(1), 0.into(), 2, 1, 4, 1),
Auctions::bid(RuntimeOrigin::signed(1), 0.into(), 2, 1, 4, 1),
Error::<Test>::AlreadyLeasedOut,
);
assert_noop!(
Auctions::bid(Origin::signed(1), 0.into(), 2, 1, 2, 1),
Auctions::bid(RuntimeOrigin::signed(1), 0.into(), 2, 1, 2, 1),
Error::<Test>::AlreadyLeasedOut,
);
assert_noop!(
Auctions::bid(Origin::signed(1), 0.into(), 2, 3, 4, 1),
Auctions::bid(RuntimeOrigin::signed(1), 0.into(), 2, 3, 4, 1),
Error::<Test>::AlreadyLeasedOut,
);
// This is okay, not an overlapping bid.
assert_ok!(Auctions::bid(Origin::signed(1), 0.into(), 2, 1, 1, 1));
assert_ok!(Auctions::bid(RuntimeOrigin::signed(1), 0.into(), 2, 1, 1, 1));
});
}
@@ -1544,14 +1544,14 @@ mod tests {
SampleLength::set(10);
run_to_block(1);
assert_ok!(Auctions::new_auction(Origin::signed(6), 9, 11));
assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 9, 11));
let para_1 = ParaId::from(1_u32);
let para_2 = ParaId::from(2_u32);
let para_3 = ParaId::from(3_u32);
// Make bids
assert_ok!(Auctions::bid(Origin::signed(1), para_1, 1, 11, 14, 10));
assert_ok!(Auctions::bid(Origin::signed(2), para_2, 1, 13, 14, 20));
assert_ok!(Auctions::bid(RuntimeOrigin::signed(1), para_1, 1, 11, 14, 10));
assert_ok!(Auctions::bid(RuntimeOrigin::signed(2), para_2, 1, 13, 14, 20));
assert_eq!(
Auctions::auction_status(System::block_number()),
@@ -1576,7 +1576,7 @@ mod tests {
assert_eq!(Auctions::winning(0), Some(winning));
// New bids update the current winning
assert_ok!(Auctions::bid(Origin::signed(3), para_3, 1, 14, 14, 30));
assert_ok!(Auctions::bid(RuntimeOrigin::signed(3), para_3, 1, 14, 14, 30));
winning[SlotRange::ThreeThree as u8 as usize] = Some((3, para_3, 30));
assert_eq!(Auctions::winning(0), Some(winning));
@@ -1588,7 +1588,7 @@ mod tests {
assert_eq!(Auctions::winning(1), Some(winning));
run_to_block(25);
// Overbid mid sample
assert_ok!(Auctions::bid(Origin::signed(3), para_3, 1, 13, 14, 30));
assert_ok!(Auctions::bid(RuntimeOrigin::signed(3), para_3, 1, 13, 14, 30));
winning[SlotRange::TwoThree as u8 as usize] = Some((3, para_3, 30));
assert_eq!(Auctions::winning(1), Some(winning));
@@ -1629,7 +1629,7 @@ mod tests {
);
run_to_block(1);
assert_ok!(Auctions::new_auction(Origin::signed(6), 9, 11));
assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 9, 11));
run_to_block(9);
assert_eq!(
@@ -1704,13 +1704,13 @@ mod tests {
fn can_cancel_auction() {
new_test_ext().execute_with(|| {
run_to_block(1);
assert_ok!(Auctions::new_auction(Origin::signed(6), 5, 1));
assert_ok!(Auctions::bid(Origin::signed(1), 0.into(), 1, 1, 4, 1));
assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 5, 1));
assert_ok!(Auctions::bid(RuntimeOrigin::signed(1), 0.into(), 1, 1, 4, 1));
assert_eq!(Balances::reserved_balance(1), 1);
assert_eq!(Balances::free_balance(1), 9);
assert_noop!(Auctions::cancel_auction(Origin::signed(6)), BadOrigin);
assert_ok!(Auctions::cancel_auction(Origin::root()));
assert_noop!(Auctions::cancel_auction(RuntimeOrigin::signed(6)), BadOrigin);
assert_ok!(Auctions::cancel_auction(RuntimeOrigin::root()));
assert!(AuctionInfo::<Test>::get().is_none());
assert_eq!(Balances::reserved_balance(1), 0);
@@ -1784,7 +1784,7 @@ mod benchmarking {
let duration = T::BlockNumber::max_value();
let lease_period_index = LeasePeriodOf::<T>::max_value();
let origin = T::InitiateOrigin::successful_origin();
}: _<T::Origin>(origin, duration, lease_period_index)
}: _<T::RuntimeOrigin>(origin, duration, lease_period_index)
verify {
assert_last_event::<T>(Event::<T>::AuctionStarted {
auction_index: AuctionCounter::<T>::get(),
polkadot/runtime/common/src/claims.rs
+114 -45
View File
@@ -176,7 +176,7 @@ pub mod pallet {
type VestingSchedule: VestingSchedule<Self::AccountId, Moment = Self::BlockNumber>;
#[pallet::constant]
type Prefix: Get<&'static [u8]>;
type MoveClaimOrigin: EnsureOrigin<Self::Origin>;
type MoveClaimOrigin: EnsureOrigin<Self::RuntimeOrigin>;
type WeightInfo: WeightInfo;
}
@@ -750,7 +750,7 @@ mod tests {
type BlockWeights = ();
type BlockLength = ();
type DbWeight = ();
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type RuntimeCall = RuntimeCall;
type Index = u64;
type BlockNumber = u64;
@@ -885,7 +885,7 @@ mod tests {
new_test_ext().execute_with(|| {
assert_eq!(Balances::free_balance(42), 0);
assert_ok!(Claims::claim(
Origin::none(),
RuntimeOrigin::none(),
42,
sig::<Test>(&alice(), &42u64.encode(), &[][..])
));
@@ -900,16 +900,25 @@ mod tests {
new_test_ext().execute_with(|| {
assert_eq!(Balances::free_balance(42), 0);
assert_noop!(
Claims::move_claim(Origin::signed(1), eth(&alice()), eth(&bob()), None),
Claims::move_claim(RuntimeOrigin::signed(1), eth(&alice()), eth(&bob()), None),
BadOrigin
);
assert_ok!(Claims::move_claim(Origin::signed(6), eth(&alice()), eth(&bob()), None));
assert_ok!(Claims::move_claim(
RuntimeOrigin::signed(6),
eth(&alice()),
eth(&bob()),
None
));
assert_noop!(
Claims::claim(Origin::none(), 42, sig::<Test>(&alice(), &42u64.encode(), &[][..])),
Claims::claim(
RuntimeOrigin::none(),
42,
sig::<Test>(&alice(), &42u64.encode(), &[][..])
),
Error::<Test>::SignerHasNoClaim
);
assert_ok!(Claims::claim(
Origin::none(),
RuntimeOrigin::none(),
42,
sig::<Test>(&bob(), &42u64.encode(), &[][..])
));
@@ -922,10 +931,15 @@ mod tests {
#[test]
fn claim_attest_moving_works() {
new_test_ext().execute_with(|| {
assert_ok!(Claims::move_claim(Origin::signed(6), eth(&dave()), eth(&bob()), None));
assert_ok!(Claims::move_claim(
RuntimeOrigin::signed(6),
eth(&dave()),
eth(&bob()),
None
));
let s = sig::<Test>(&bob(), &42u64.encode(), StatementKind::Regular.to_text());
assert_ok!(Claims::claim_attest(
Origin::none(),
RuntimeOrigin::none(),
42,
s,
StatementKind::Regular.to_text().to_vec()
@@ -937,8 +951,16 @@ mod tests {
#[test]
fn attest_moving_works() {
new_test_ext().execute_with(|| {
assert_ok!(Claims::move_claim(Origin::signed(6), eth(&eve()), eth(&bob()), Some(42)));
assert_ok!(Claims::attest(Origin::signed(42), StatementKind::Saft.to_text().to_vec()));
assert_ok!(Claims::move_claim(
RuntimeOrigin::signed(6),
eth(&eve()),
eth(&bob()),
Some(42)
));
assert_ok!(Claims::attest(
RuntimeOrigin::signed(42),
StatementKind::Saft.to_text().to_vec()
));
assert_eq!(Balances::free_balance(&42), 300);
});
}
@@ -947,20 +969,28 @@ mod tests {
fn claiming_does_not_bypass_signing() {
new_test_ext().execute_with(|| {
assert_ok!(Claims::claim(
Origin::none(),
RuntimeOrigin::none(),
42,
sig::<Test>(&alice(), &42u64.encode(), &[][..])
));
assert_noop!(
Claims::claim(Origin::none(), 42, sig::<Test>(&dave(), &42u64.encode(), &[][..])),
Claims::claim(
RuntimeOrigin::none(),
42,
sig::<Test>(&dave(), &42u64.encode(), &[][..])
),
Error::<Test>::InvalidStatement,
);
assert_noop!(
Claims::claim(Origin::none(), 42, sig::<Test>(&eve(), &42u64.encode(), &[][..])),
Claims::claim(
RuntimeOrigin::none(),
42,
sig::<Test>(&eve(), &42u64.encode(), &[][..])
),
Error::<Test>::InvalidStatement,
);
assert_ok!(Claims::claim(
Origin::none(),
RuntimeOrigin::none(),
42,
sig::<Test>(&frank(), &42u64.encode(), &[][..])
));
@@ -973,7 +1003,7 @@ mod tests {
assert_eq!(Balances::free_balance(42), 0);
let s = sig::<Test>(&dave(), &42u64.encode(), StatementKind::Saft.to_text());
let r = Claims::claim_attest(
Origin::none(),
RuntimeOrigin::none(),
42,
s.clone(),
StatementKind::Saft.to_text().to_vec(),
@@ -981,7 +1011,7 @@ mod tests {
assert_noop!(r, Error::<Test>::InvalidStatement);
let r = Claims::claim_attest(
Origin::none(),
RuntimeOrigin::none(),
42,
s,
StatementKind::Regular.to_text().to_vec(),
@@ -992,7 +1022,7 @@ mod tests {
let s = sig::<Test>(&dave(), &42u64.encode(), StatementKind::Regular.to_text());
assert_ok!(Claims::claim_attest(
Origin::none(),
RuntimeOrigin::none(),
42,
s,
StatementKind::Regular.to_text().to_vec()
@@ -1002,7 +1032,7 @@ mod tests {
let s = sig::<Test>(&dave(), &42u64.encode(), StatementKind::Regular.to_text());
let r = Claims::claim_attest(
Origin::none(),
RuntimeOrigin::none(),
42,
s,
StatementKind::Regular.to_text().to_vec(),
@@ -1016,14 +1046,20 @@ mod tests {
new_test_ext().execute_with(|| {
assert_eq!(Balances::free_balance(42), 0);
assert_noop!(
Claims::attest(Origin::signed(69), StatementKind::Saft.to_text().to_vec()),
Claims::attest(RuntimeOrigin::signed(69), StatementKind::Saft.to_text().to_vec()),
Error::<Test>::SenderHasNoClaim
);
assert_noop!(
Claims::attest(Origin::signed(42), StatementKind::Regular.to_text().to_vec()),
Claims::attest(
RuntimeOrigin::signed(42),
StatementKind::Regular.to_text().to_vec()
),
Error::<Test>::InvalidStatement
);
assert_ok!(Claims::attest(Origin::signed(42), StatementKind::Saft.to_text().to_vec()));
assert_ok!(Claims::attest(
RuntimeOrigin::signed(42),
StatementKind::Saft.to_text().to_vec()
));
assert_eq!(Balances::free_balance(&42), 300);
assert_eq!(Claims::total(), total_claims() - 300);
});
@@ -1035,13 +1071,16 @@ mod tests {
assert_eq!(Balances::free_balance(42), 0);
// Alice's claim is 100
assert_ok!(Claims::claim(
Origin::none(),
RuntimeOrigin::none(),
42,
sig::<Test>(&alice(), &42u64.encode(), &[][..])
));
assert_eq!(Balances::free_balance(&42), 100);
// Eve's claim is 300 through Account 42
assert_ok!(Claims::attest(Origin::signed(42), StatementKind::Saft.to_text().to_vec()));
assert_ok!(Claims::attest(
RuntimeOrigin::signed(42),
StatementKind::Saft.to_text().to_vec()
));
assert_eq!(Balances::free_balance(&42), 100 + 300);
assert_eq!(Claims::total(), total_claims() - 400);
});
@@ -1085,7 +1124,7 @@ mod tests {
new_test_ext().execute_with(|| {
assert_eq!(Balances::free_balance(42), 0);
let s = sig::<Test>(&dave(), &42u64.encode(), &[]);
let r = Claims::claim(Origin::none(), 42, s.clone());
let r = Claims::claim(RuntimeOrigin::none(), 42, s.clone());
assert_noop!(r, Error::<Test>::InvalidStatement);
});
}
@@ -1094,18 +1133,22 @@ mod tests {
fn add_claim_works() {
new_test_ext().execute_with(|| {
assert_noop!(
Claims::mint_claim(Origin::signed(42), eth(&bob()), 200, None, None),
Claims::mint_claim(RuntimeOrigin::signed(42), eth(&bob()), 200, None, None),
sp_runtime::traits::BadOrigin,
);
assert_eq!(Balances::free_balance(42), 0);
assert_noop!(
Claims::claim(Origin::none(), 69, sig::<Test>(&bob(), &69u64.encode(), &[][..])),
Claims::claim(
RuntimeOrigin::none(),
69,
sig::<Test>(&bob(), &69u64.encode(), &[][..])
),
Error::<Test>::SignerHasNoClaim,
);
assert_ok!(Claims::mint_claim(Origin::root(), eth(&bob()), 200, None, None));
assert_ok!(Claims::mint_claim(RuntimeOrigin::root(), eth(&bob()), 200, None, None));
assert_eq!(Claims::total(), total_claims() + 200);
assert_ok!(Claims::claim(
Origin::none(),
RuntimeOrigin::none(),
69,
sig::<Test>(&bob(), &69u64.encode(), &[][..])
));
@@ -1119,23 +1162,33 @@ mod tests {
fn add_claim_with_vesting_works() {
new_test_ext().execute_with(|| {
assert_noop!(
Claims::mint_claim(Origin::signed(42), eth(&bob()), 200, Some((50, 10, 1)), None),
Claims::mint_claim(
RuntimeOrigin::signed(42),
eth(&bob()),
200,
Some((50, 10, 1)),
None
),
sp_runtime::traits::BadOrigin,
);
assert_eq!(Balances::free_balance(42), 0);
assert_noop!(
Claims::claim(Origin::none(), 69, sig::<Test>(&bob(), &69u64.encode(), &[][..])),
Claims::claim(
RuntimeOrigin::none(),
69,
sig::<Test>(&bob(), &69u64.encode(), &[][..])
),
Error::<Test>::SignerHasNoClaim,
);
assert_ok!(Claims::mint_claim(
Origin::root(),
RuntimeOrigin::root(),
eth(&bob()),
200,
Some((50, 10, 1)),
None
));
assert_ok!(Claims::claim(
Origin::none(),
RuntimeOrigin::none(),
69,
sig::<Test>(&bob(), &69u64.encode(), &[][..])
));
@@ -1160,7 +1213,7 @@ mod tests {
new_test_ext().execute_with(|| {
assert_noop!(
Claims::mint_claim(
Origin::signed(42),
RuntimeOrigin::signed(42),
eth(&bob()),
200,
None,
@@ -1172,7 +1225,7 @@ mod tests {
let signature = sig::<Test>(&bob(), &69u64.encode(), StatementKind::Regular.to_text());
assert_noop!(
Claims::claim_attest(
Origin::none(),
RuntimeOrigin::none(),
69,
signature.clone(),
StatementKind::Regular.to_text().to_vec()
@@ -1180,18 +1233,18 @@ mod tests {
Error::<Test>::SignerHasNoClaim
);
assert_ok!(Claims::mint_claim(
Origin::root(),
RuntimeOrigin::root(),
eth(&bob()),
200,
None,
Some(StatementKind::Regular)
));
assert_noop!(
Claims::claim_attest(Origin::none(), 69, signature.clone(), vec![],),
Claims::claim_attest(RuntimeOrigin::none(), 69, signature.clone(), vec![],),
Error::<Test>::SignerHasNoClaim
);
assert_ok!(Claims::claim_attest(
Origin::none(),
RuntimeOrigin::none(),
69,
signature.clone(),
StatementKind::Regular.to_text().to_vec()
@@ -1206,7 +1259,7 @@ mod tests {
assert_eq!(Balances::free_balance(42), 0);
assert_err!(
Claims::claim(
Origin::signed(42),
RuntimeOrigin::signed(42),
42,
sig::<Test>(&alice(), &42u64.encode(), &[][..])
),
@@ -1220,12 +1273,16 @@ mod tests {
new_test_ext().execute_with(|| {
assert_eq!(Balances::free_balance(42), 0);
assert_ok!(Claims::claim(
Origin::none(),
RuntimeOrigin::none(),
42,
sig::<Test>(&alice(), &42u64.encode(), &[][..])
));
assert_noop!(
Claims::claim(Origin::none(), 42, sig::<Test>(&alice(), &42u64.encode(), &[][..])),
Claims::claim(
RuntimeOrigin::none(),
42,
sig::<Test>(&alice(), &42u64.encode(), &[][..])
),
Error::<Test>::SignerHasNoClaim
);
});
@@ -1244,7 +1301,7 @@ mod tests {
CurrencyOf::<Test>::make_free_balance_be(&69, total_claims());
assert_eq!(Balances::free_balance(69), total_claims());
assert_ok!(Claims::mint_claim(
Origin::root(),
RuntimeOrigin::root(),
eth(&bob()),
200,
Some((50, 10, 1)),
@@ -1255,7 +1312,11 @@ mod tests {
// They should not be able to claim
assert_noop!(
Claims::claim(Origin::none(), 69, sig::<Test>(&bob(), &69u64.encode(), &[][..])),
Claims::claim(
RuntimeOrigin::none(),
69,
sig::<Test>(&bob(), &69u64.encode(), &[][..])
),
Error::<Test>::VestedBalanceExists,
);
});
@@ -1266,7 +1327,11 @@ mod tests {
new_test_ext().execute_with(|| {
assert_eq!(Balances::free_balance(42), 0);
assert_noop!(
Claims::claim(Origin::none(), 42, sig::<Test>(&alice(), &69u64.encode(), &[][..])),
Claims::claim(
RuntimeOrigin::none(),
42,
sig::<Test>(&alice(), &69u64.encode(), &[][..])
),
Error::<Test>::SignerHasNoClaim
);
});
@@ -1277,7 +1342,11 @@ mod tests {
new_test_ext().execute_with(|| {
assert_eq!(Balances::free_balance(42), 0);
assert_noop!(
Claims::claim(Origin::none(), 42, sig::<Test>(&bob(), &69u64.encode(), &[][..])),
Claims::claim(
RuntimeOrigin::none(),
42,
sig::<Test>(&bob(), &69u64.encode(), &[][..])
),
Error::<Test>::SignerHasNoClaim
);
});
polkadot/runtime/common/src/crowdloan/mod.rs
+126 -96
View File
@@ -892,7 +892,7 @@ mod tests {
type BlockWeights = ();
type BlockLength = ();
type DbWeight = ();
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type RuntimeCall = RuntimeCall;
type Index = u64;
type BlockNumber = BlockNumber;
@@ -1168,7 +1168,7 @@ mod tests {
new_test_ext().execute_with(|| {
let para = new_para();
// Now try to create a crowdloan campaign
assert_ok!(Crowdloan::create(Origin::signed(1), para, 1000, 1, 4, 9, None));
assert_ok!(Crowdloan::create(RuntimeOrigin::signed(1), para, 1000, 1, 4, 9, None));
// This is what the initial `fund_info` should look like
let fund_info = FundInfo {
depositor: 1,
@@ -1201,7 +1201,7 @@ mod tests {
let para = new_para();
// Now try to create a crowdloan campaign
assert_ok!(Crowdloan::create(
Origin::signed(1),
RuntimeOrigin::signed(1),
para,
1000,
1,
@@ -1241,12 +1241,15 @@ mod tests {
let para = new_para();
let e = Error::<Test>::InvalidParaId;
assert_noop!(Crowdloan::create(Origin::signed(1), 1.into(), 1000, 1, 4, 9, None), e);
assert_noop!(
Crowdloan::create(RuntimeOrigin::signed(1), 1.into(), 1000, 1, 4, 9, None),
e
);
// Cannot create a crowdloan with bad lease periods
let e = Error::<Test>::LastPeriodBeforeFirstPeriod;
assert_noop!(Crowdloan::create(Origin::signed(1), para, 1000, 4, 1, 9, None), e);
assert_noop!(Crowdloan::create(RuntimeOrigin::signed(1), para, 1000, 4, 1, 9, None), e);
let e = Error::<Test>::LastPeriodTooFarInFuture;
assert_noop!(Crowdloan::create(Origin::signed(1), para, 1000, 1, 9, 9, None), e);
assert_noop!(Crowdloan::create(RuntimeOrigin::signed(1), para, 1000, 1, 9, 9, None), e);
// Cannot create a crowdloan without some deposit funds
assert_ok!(TestRegistrar::<Test>::register(
@@ -1257,14 +1260,22 @@ mod tests {
));
let e = BalancesError::<Test, _>::InsufficientBalance;
assert_noop!(
Crowdloan::create(Origin::signed(1337), ParaId::from(1234), 1000, 1, 3, 9, None),
Crowdloan::create(
RuntimeOrigin::signed(1337),
ParaId::from(1234),
1000,
1,
3,
9,
None
),
e
);
// Cannot create a crowdloan with nonsense end date
// This crowdloan would end in lease period 2, but is bidding for some slot that starts in lease period 1.
assert_noop!(
Crowdloan::create(Origin::signed(1), para, 1000, 1, 4, 41, None),
Crowdloan::create(RuntimeOrigin::signed(1), para, 1000, 1, 4, 41, None),
Error::<Test>::EndTooFarInFuture
);
});
@@ -1277,13 +1288,13 @@ mod tests {
let index = NextFundIndex::<Test>::get();
// Set up a crowdloan
assert_ok!(Crowdloan::create(Origin::signed(1), para, 1000, 1, 4, 9, None));
assert_ok!(Crowdloan::create(RuntimeOrigin::signed(1), para, 1000, 1, 4, 9, None));
// No contributions yet
assert_eq!(Crowdloan::contribution_get(u32::from(para), &1).0, 0);
// User 1 contributes to their own crowdloan
assert_ok!(Crowdloan::contribute(Origin::signed(1), para, 49, None));
assert_ok!(Crowdloan::contribute(RuntimeOrigin::signed(1), para, 49, None));
// User 1 has spent some funds to do this, transfer fees **are** taken
assert_eq!(Balances::free_balance(1), 950);
// Contributions are stored in the trie
@@ -1309,7 +1320,7 @@ mod tests {
let pubkey = crypto::create_ed25519_pubkey(b"//verifier".to_vec());
// Set up a crowdloan
assert_ok!(Crowdloan::create(
Origin::signed(1),
RuntimeOrigin::signed(1),
para,
1000,
1,
@@ -1323,7 +1334,7 @@ mod tests {
// Missing signature
assert_noop!(
Crowdloan::contribute(Origin::signed(1), para, 49, None),
Crowdloan::contribute(RuntimeOrigin::signed(1), para, 49, None),
Error::<Test>::InvalidSignature
);
@@ -1335,23 +1346,33 @@ mod tests {
// Invalid signature
assert_noop!(
Crowdloan::contribute(Origin::signed(1), para, 49, Some(invalid_signature)),
Crowdloan::contribute(RuntimeOrigin::signed(1), para, 49, Some(invalid_signature)),
Error::<Test>::InvalidSignature
);
// Valid signature wrong parameter
assert_noop!(
Crowdloan::contribute(Origin::signed(1), para, 50, Some(valid_signature.clone())),
Crowdloan::contribute(
RuntimeOrigin::signed(1),
para,
50,
Some(valid_signature.clone())
),
Error::<Test>::InvalidSignature
);
assert_noop!(
Crowdloan::contribute(Origin::signed(2), para, 49, Some(valid_signature.clone())),
Crowdloan::contribute(
RuntimeOrigin::signed(2),
para,
49,
Some(valid_signature.clone())
),
Error::<Test>::InvalidSignature
);
// Valid signature
assert_ok!(Crowdloan::contribute(
Origin::signed(1),
RuntimeOrigin::signed(1),
para,
49,
Some(valid_signature.clone())
@@ -1359,7 +1380,7 @@ mod tests {
// Reuse valid signature
assert_noop!(
Crowdloan::contribute(Origin::signed(1), para, 49, Some(valid_signature)),
Crowdloan::contribute(RuntimeOrigin::signed(1), para, 49, Some(valid_signature)),
Error::<Test>::InvalidSignature
);
@@ -1367,7 +1388,12 @@ mod tests {
let valid_signature_2 = crypto::create_ed25519_signature(&payload_2.encode(), pubkey);
// New valid signature
assert_ok!(Crowdloan::contribute(Origin::signed(1), para, 10, Some(valid_signature_2)));
assert_ok!(Crowdloan::contribute(
RuntimeOrigin::signed(1),
para,
10,
Some(valid_signature_2)
));
// Contributions appear in free balance of crowdloan
assert_eq!(Balances::free_balance(Crowdloan::fund_account_id(index)), 59);
@@ -1385,22 +1411,22 @@ mod tests {
// Cannot contribute to non-existing fund
assert_noop!(
Crowdloan::contribute(Origin::signed(1), para, 49, None),
Crowdloan::contribute(RuntimeOrigin::signed(1), para, 49, None),
Error::<Test>::InvalidParaId
);
// Cannot contribute below minimum contribution
assert_noop!(
Crowdloan::contribute(Origin::signed(1), para, 9, None),
Crowdloan::contribute(RuntimeOrigin::signed(1), para, 9, None),
Error::<Test>::ContributionTooSmall
);
// Set up a crowdloan
assert_ok!(Crowdloan::create(Origin::signed(1), para, 1000, 1, 4, 9, None));
assert_ok!(Crowdloan::contribute(Origin::signed(1), para, 101, None));
assert_ok!(Crowdloan::create(RuntimeOrigin::signed(1), para, 1000, 1, 4, 9, None));
assert_ok!(Crowdloan::contribute(RuntimeOrigin::signed(1), para, 101, None));
// Cannot contribute past the limit
assert_noop!(
Crowdloan::contribute(Origin::signed(2), para, 900, None),
Crowdloan::contribute(RuntimeOrigin::signed(2), para, 900, None),
Error::<Test>::CapExceeded
);
@@ -1409,31 +1435,31 @@ mod tests {
// Cannot contribute to ended fund
assert_noop!(
Crowdloan::contribute(Origin::signed(1), para, 49, None),
Crowdloan::contribute(RuntimeOrigin::signed(1), para, 49, None),
Error::<Test>::ContributionPeriodOver
);
// If a crowdloan has already won, it should not allow contributions.
let para_2 = new_para();
let index = NextFundIndex::<Test>::get();
assert_ok!(Crowdloan::create(Origin::signed(1), para_2, 1000, 1, 4, 40, None));
assert_ok!(Crowdloan::create(RuntimeOrigin::signed(1), para_2, 1000, 1, 4, 40, None));
// Emulate a win by leasing out and putting a deposit. Slots pallet would normally do this.
let crowdloan_account = Crowdloan::fund_account_id(index);
set_winner(para_2, crowdloan_account, true);
assert_noop!(
Crowdloan::contribute(Origin::signed(1), para_2, 49, None),
Crowdloan::contribute(RuntimeOrigin::signed(1), para_2, 49, None),
Error::<Test>::BidOrLeaseActive
);
// Move past lease period 1, should not be allowed to have further contributions with a crowdloan
// that has starting period 1.
let para_3 = new_para();
assert_ok!(Crowdloan::create(Origin::signed(1), para_3, 1000, 1, 4, 40, None));
assert_ok!(Crowdloan::create(RuntimeOrigin::signed(1), para_3, 1000, 1, 4, 40, None));
run_to_block(40);
let now = System::block_number();
assert_eq!(TestAuctioneer::lease_period_index(now).unwrap().0, 2);
assert_noop!(
Crowdloan::contribute(Origin::signed(1), para_3, 49, None),
Crowdloan::contribute(RuntimeOrigin::signed(1), para_3, 49, None),
Error::<Test>::ContributionPeriodOver
);
});
@@ -1452,7 +1478,7 @@ mod tests {
// Set up a crowdloan
assert_ok!(Crowdloan::create(
Origin::signed(1),
RuntimeOrigin::signed(1),
para,
1000,
first_period,
@@ -1464,20 +1490,20 @@ mod tests {
run_to_block(8);
// Can def contribute when auction is running.
assert!(TestAuctioneer::auction_status(System::block_number()).is_ending().is_some());
assert_ok!(Crowdloan::contribute(Origin::signed(2), para, 250, None));
assert_ok!(Crowdloan::contribute(RuntimeOrigin::signed(2), para, 250, None));
run_to_block(10);
// Can't contribute when auction is in the VRF delay period.
assert!(TestAuctioneer::auction_status(System::block_number()).is_vrf());
assert_noop!(
Crowdloan::contribute(Origin::signed(2), para, 250, None),
Crowdloan::contribute(RuntimeOrigin::signed(2), para, 250, None),
Error::<Test>::VrfDelayInProgress
);
run_to_block(15);
// Its fine to contribute when no auction is running.
assert!(!TestAuctioneer::auction_status(System::block_number()).is_in_progress());
assert_ok!(Crowdloan::contribute(Origin::signed(2), para, 250, None));
assert_ok!(Crowdloan::contribute(RuntimeOrigin::signed(2), para, 250, None));
})
}
@@ -1493,7 +1519,7 @@ mod tests {
// Set up a crowdloan
assert_ok!(Crowdloan::create(
Origin::signed(1),
RuntimeOrigin::signed(1),
para,
1000,
first_period,
@@ -1505,13 +1531,13 @@ mod tests {
// Fund crowdloan
run_to_block(1);
assert_ok!(Crowdloan::contribute(Origin::signed(2), para, 100, None));
assert_ok!(Crowdloan::contribute(RuntimeOrigin::signed(2), para, 100, None));
run_to_block(3);
assert_ok!(Crowdloan::contribute(Origin::signed(3), para, 150, None));
assert_ok!(Crowdloan::contribute(RuntimeOrigin::signed(3), para, 150, None));
run_to_block(5);
assert_ok!(Crowdloan::contribute(Origin::signed(4), para, 200, None));
assert_ok!(Crowdloan::contribute(RuntimeOrigin::signed(4), para, 200, None));
run_to_block(8);
assert_ok!(Crowdloan::contribute(Origin::signed(2), para, 250, None));
assert_ok!(Crowdloan::contribute(RuntimeOrigin::signed(2), para, 250, None));
run_to_block(10);
assert_eq!(
@@ -1535,9 +1561,9 @@ mod tests {
let index = NextFundIndex::<Test>::get();
// Set up a crowdloan
assert_ok!(Crowdloan::create(Origin::signed(1), para, 1000, 1, 1, 9, None));
assert_ok!(Crowdloan::contribute(Origin::signed(2), para, 100, None));
assert_ok!(Crowdloan::contribute(Origin::signed(3), para, 50, None));
assert_ok!(Crowdloan::create(RuntimeOrigin::signed(1), para, 1000, 1, 1, 9, None));
assert_ok!(Crowdloan::contribute(RuntimeOrigin::signed(2), para, 100, None));
assert_ok!(Crowdloan::contribute(RuntimeOrigin::signed(3), para, 50, None));
run_to_block(10);
let account_id = Crowdloan::fund_account_id(index);
@@ -1548,11 +1574,11 @@ mod tests {
assert_eq!(Balances::free_balance(2), 1900);
assert_eq!(Balances::free_balance(3), 2950);
assert_ok!(Crowdloan::withdraw(Origin::signed(2), 2, para));
assert_ok!(Crowdloan::withdraw(RuntimeOrigin::signed(2), 2, para));
assert_eq!(Balances::free_balance(&account_id), 50);
assert_eq!(Balances::free_balance(2), 2000);
assert_ok!(Crowdloan::withdraw(Origin::signed(2), 3, para));
assert_ok!(Crowdloan::withdraw(RuntimeOrigin::signed(2), 3, para));
assert_eq!(Balances::free_balance(&account_id), 0);
assert_eq!(Balances::free_balance(3), 3000);
});
@@ -1565,26 +1591,26 @@ mod tests {
let index = NextFundIndex::<Test>::get();
// Set up a crowdloan
assert_ok!(Crowdloan::create(Origin::signed(1), para, 1000, 1, 1, 9, None));
assert_ok!(Crowdloan::contribute(Origin::signed(2), para, 100, None));
assert_ok!(Crowdloan::create(RuntimeOrigin::signed(1), para, 1000, 1, 1, 9, None));
assert_ok!(Crowdloan::contribute(RuntimeOrigin::signed(2), para, 100, None));
run_to_block(10);
let account_id = Crowdloan::fund_account_id(index);
// user sends the crowdloan funds trying to make an accounting error
assert_ok!(Balances::transfer(Origin::signed(1), account_id, 10));
assert_ok!(Balances::transfer(RuntimeOrigin::signed(1), account_id, 10));
// overfunded now
assert_eq!(Balances::free_balance(&account_id), 110);
assert_eq!(Balances::free_balance(2), 1900);
assert_ok!(Crowdloan::withdraw(Origin::signed(2), 2, para));
assert_ok!(Crowdloan::withdraw(RuntimeOrigin::signed(2), 2, para));
assert_eq!(Balances::free_balance(2), 2000);
// Some funds are left over
assert_eq!(Balances::free_balance(&account_id), 10);
// They wil be left in the account at the end
assert_ok!(Crowdloan::dissolve(Origin::signed(1), para));
assert_ok!(Crowdloan::dissolve(RuntimeOrigin::signed(1), para));
assert_eq!(Balances::free_balance(&account_id), 10);
});
}
@@ -1597,23 +1623,23 @@ mod tests {
let account_id = Crowdloan::fund_account_id(index);
// Set up a crowdloan ending on 9
assert_ok!(Crowdloan::create(Origin::signed(1), para, 1000, 1, 1, 9, None));
assert_ok!(Crowdloan::create(RuntimeOrigin::signed(1), para, 1000, 1, 1, 9, None));
// Make some contributions
assert_ok!(Crowdloan::contribute(Origin::signed(1), para, 100, None));
assert_ok!(Crowdloan::contribute(Origin::signed(2), para, 200, None));
assert_ok!(Crowdloan::contribute(Origin::signed(3), para, 300, None));
assert_ok!(Crowdloan::contribute(RuntimeOrigin::signed(1), para, 100, None));
assert_ok!(Crowdloan::contribute(RuntimeOrigin::signed(2), para, 200, None));
assert_ok!(Crowdloan::contribute(RuntimeOrigin::signed(3), para, 300, None));
assert_eq!(Balances::free_balance(account_id), 600);
// Can't refund before the crowdloan it has ended
assert_noop!(
Crowdloan::refund(Origin::signed(1337), para),
Crowdloan::refund(RuntimeOrigin::signed(1337), para),
Error::<Test>::FundNotEnded,
);
// Move to the end of the crowdloan
run_to_block(10);
assert_ok!(Crowdloan::refund(Origin::signed(1337), para));
assert_ok!(Crowdloan::refund(RuntimeOrigin::signed(1337), para));
// Funds are returned
assert_eq!(Balances::free_balance(account_id), 0);
@@ -1632,12 +1658,12 @@ mod tests {
let account_id = Crowdloan::fund_account_id(index);
// Set up a crowdloan ending on 9
assert_ok!(Crowdloan::create(Origin::signed(1), para, 100000, 1, 1, 9, None));
assert_ok!(Crowdloan::create(RuntimeOrigin::signed(1), para, 100000, 1, 1, 9, None));
// Make more contributions than our limit
for i in 1..=RemoveKeysLimit::get() * 2 {
Balances::make_free_balance_be(&i.into(), (1000 * i).into());
assert_ok!(Crowdloan::contribute(
Origin::signed(i.into()),
RuntimeOrigin::signed(i.into()),
para,
(i * 100).into(),
None
@@ -1648,7 +1674,7 @@ mod tests {
// Move to the end of the crowdloan
run_to_block(10);
assert_ok!(Crowdloan::refund(Origin::signed(1337), para));
assert_ok!(Crowdloan::refund(RuntimeOrigin::signed(1337), para));
assert_eq!(
last_event(),
super::Event::<Test>::PartiallyRefunded { para_id: para }.into()
@@ -1658,7 +1684,7 @@ mod tests {
assert!(!Balances::free_balance(account_id).is_zero());
// Call again
assert_ok!(Crowdloan::refund(Origin::signed(1337), para));
assert_ok!(Crowdloan::refund(RuntimeOrigin::signed(1337), para));
assert_eq!(last_event(), super::Event::<Test>::AllRefunded { para_id: para }.into());
// Funds are returned
@@ -1677,16 +1703,16 @@ mod tests {
let issuance = Balances::total_issuance();
// Set up a crowdloan
assert_ok!(Crowdloan::create(Origin::signed(1), para, 1000, 1, 1, 9, None));
assert_ok!(Crowdloan::contribute(Origin::signed(2), para, 100, None));
assert_ok!(Crowdloan::contribute(Origin::signed(3), para, 50, None));
assert_ok!(Crowdloan::create(RuntimeOrigin::signed(1), para, 1000, 1, 1, 9, None));
assert_ok!(Crowdloan::contribute(RuntimeOrigin::signed(2), para, 100, None));
assert_ok!(Crowdloan::contribute(RuntimeOrigin::signed(3), para, 50, None));
run_to_block(10);
// All funds are refunded
assert_ok!(Crowdloan::refund(Origin::signed(2), para));
assert_ok!(Crowdloan::refund(RuntimeOrigin::signed(2), para));
// Now that `fund.raised` is zero, it can be dissolved.
assert_ok!(Crowdloan::dissolve(Origin::signed(1), para));
assert_ok!(Crowdloan::dissolve(RuntimeOrigin::signed(1), para));
assert_eq!(Balances::free_balance(1), 1000);
assert_eq!(Balances::free_balance(2), 2000);
assert_eq!(Balances::free_balance(3), 3000);
@@ -1701,13 +1727,13 @@ mod tests {
let issuance = Balances::total_issuance();
// Set up a crowdloan
assert_ok!(Crowdloan::create(Origin::signed(1), para, 1000, 1, 1, 9, None));
assert_ok!(Crowdloan::contribute(Origin::signed(2), para, 100, None));
assert_ok!(Crowdloan::contribute(Origin::signed(3), para, 50, None));
assert_ok!(Crowdloan::create(RuntimeOrigin::signed(1), para, 1000, 1, 1, 9, None));
assert_ok!(Crowdloan::contribute(RuntimeOrigin::signed(2), para, 100, None));
assert_ok!(Crowdloan::contribute(RuntimeOrigin::signed(3), para, 50, None));
// Can't dissolve before it ends
assert_noop!(
Crowdloan::dissolve(Origin::signed(1), para),
Crowdloan::dissolve(RuntimeOrigin::signed(1), para),
Error::<Test>::NotReadyToDissolve
);
@@ -1715,22 +1741,22 @@ mod tests {
set_winner(para, 1, true);
// Can't dissolve when it won.
assert_noop!(
Crowdloan::dissolve(Origin::signed(1), para),
Crowdloan::dissolve(RuntimeOrigin::signed(1), para),
Error::<Test>::NotReadyToDissolve
);
set_winner(para, 1, false);
// Can't dissolve while it still has user funds
assert_noop!(
Crowdloan::dissolve(Origin::signed(1), para),
Crowdloan::dissolve(RuntimeOrigin::signed(1), para),
Error::<Test>::NotReadyToDissolve
);
// All funds are refunded
assert_ok!(Crowdloan::refund(Origin::signed(2), para));
assert_ok!(Crowdloan::refund(RuntimeOrigin::signed(2), para));
// Now that `fund.raised` is zero, it can be dissolved.
assert_ok!(Crowdloan::dissolve(Origin::signed(1), para));
assert_ok!(Crowdloan::dissolve(RuntimeOrigin::signed(1), para));
assert_eq!(Balances::free_balance(1), 1000);
assert_eq!(Balances::free_balance(2), 2000);
assert_eq!(Balances::free_balance(3), 3000);
@@ -1746,17 +1772,17 @@ mod tests {
let account_id = Crowdloan::fund_account_id(index);
// Set up a crowdloan
assert_ok!(Crowdloan::create(Origin::signed(1), para, 1000, 1, 1, 9, None));
assert_ok!(Crowdloan::create(RuntimeOrigin::signed(1), para, 1000, 1, 1, 9, None));
// Fund crowdloans.
assert_ok!(Crowdloan::contribute(Origin::signed(2), para, 100, None));
assert_ok!(Crowdloan::contribute(Origin::signed(3), para, 50, None));
assert_ok!(Crowdloan::contribute(RuntimeOrigin::signed(2), para, 100, None));
assert_ok!(Crowdloan::contribute(RuntimeOrigin::signed(3), para, 50, None));
// simulate the reserving of para's funds. this actually happens in the Slots pallet.
assert_ok!(Balances::reserve(&account_id, 150));
run_to_block(19);
assert_noop!(
Crowdloan::withdraw(Origin::signed(2), 2, para),
Crowdloan::withdraw(RuntimeOrigin::signed(2), 2, para),
Error::<Test>::BidOrLeaseActive
);
@@ -1772,11 +1798,11 @@ mod tests {
assert_eq!(Balances::free_balance(2), 1900);
assert_eq!(Balances::free_balance(3), 2950);
assert_ok!(Crowdloan::withdraw(Origin::signed(2), 2, para));
assert_ok!(Crowdloan::withdraw(RuntimeOrigin::signed(2), 2, para));
assert_eq!(Balances::free_balance(&account_id), 50);
assert_eq!(Balances::free_balance(2), 2000);
assert_ok!(Crowdloan::withdraw(Origin::signed(2), 3, para));
assert_ok!(Crowdloan::withdraw(RuntimeOrigin::signed(2), 3, para));
assert_eq!(Balances::free_balance(&account_id), 0);
assert_eq!(Balances::free_balance(3), 3000);
});
@@ -1789,11 +1815,11 @@ mod tests {
let para_2 = new_para();
// Set up crowdloans
assert_ok!(Crowdloan::create(Origin::signed(1), para_1, 1000, 1, 1, 9, None));
assert_ok!(Crowdloan::create(Origin::signed(1), para_2, 1000, 1, 1, 9, None));
assert_ok!(Crowdloan::create(RuntimeOrigin::signed(1), para_1, 1000, 1, 1, 9, None));
assert_ok!(Crowdloan::create(RuntimeOrigin::signed(1), para_2, 1000, 1, 1, 9, None));
// Different contributions
assert_ok!(Crowdloan::contribute(Origin::signed(2), para_1, 100, None));
assert_ok!(Crowdloan::contribute(Origin::signed(3), para_2, 50, None));
assert_ok!(Crowdloan::contribute(RuntimeOrigin::signed(2), para_1, 100, None));
assert_ok!(Crowdloan::contribute(RuntimeOrigin::signed(3), para_2, 50, None));
// Original state
assert_eq!(Funds::<Test>::get(para_1).unwrap().raised, 100);
assert_eq!(Funds::<Test>::get(para_2).unwrap().raised, 50);
@@ -1810,10 +1836,10 @@ mod tests {
new_test_ext().execute_with(|| {
let para_1 = new_para();
assert_ok!(Crowdloan::create(Origin::signed(1), para_1, 1000, 1, 1, 9, None));
assert_ok!(Crowdloan::create(RuntimeOrigin::signed(1), para_1, 1000, 1, 1, 9, None));
// Cannot create a fund again
assert_noop!(
Crowdloan::create(Origin::signed(1), para_1, 1000, 1, 1, 9, None),
Crowdloan::create(RuntimeOrigin::signed(1), para_1, 1000, 1, 1, 9, None),
Error::<Test>::FundNotEnded,
);
});
@@ -1824,11 +1850,11 @@ mod tests {
new_test_ext().execute_with(|| {
let para_1 = new_para();
assert_ok!(Crowdloan::create(Origin::signed(1), para_1, 1000, 1, 1, 9, None));
assert_ok!(Crowdloan::contribute(Origin::signed(2), para_1, 100, None));
assert_ok!(Crowdloan::create(RuntimeOrigin::signed(1), para_1, 1000, 1, 1, 9, None));
assert_ok!(Crowdloan::contribute(RuntimeOrigin::signed(2), para_1, 100, None));
let old_crowdloan = Crowdloan::funds(para_1).unwrap();
assert_ok!(Crowdloan::edit(Origin::root(), para_1, 1234, 2, 3, 4, None));
assert_ok!(Crowdloan::edit(RuntimeOrigin::root(), para_1, 1234, 2, 3, 4, None));
let new_crowdloan = Crowdloan::funds(para_1).unwrap();
// Some things stay the same
@@ -1848,25 +1874,29 @@ mod tests {
new_test_ext().execute_with(|| {
let para_1 = new_para();
assert_ok!(Crowdloan::create(Origin::signed(1), para_1, 1000, 1, 1, 9, None));
assert_ok!(Crowdloan::create(RuntimeOrigin::signed(1), para_1, 1000, 1, 1, 9, None));
// Cant add a memo before you have contributed.
assert_noop!(
Crowdloan::add_memo(Origin::signed(1), para_1, b"hello, world".to_vec()),
Crowdloan::add_memo(RuntimeOrigin::signed(1), para_1, b"hello, world".to_vec()),
Error::<Test>::NoContributions,
);
// Make a contribution. Initially no memo.
assert_ok!(Crowdloan::contribute(Origin::signed(1), para_1, 100, None));
assert_ok!(Crowdloan::contribute(RuntimeOrigin::signed(1), para_1, 100, None));
assert_eq!(Crowdloan::contribution_get(0u32, &1), (100, vec![]));
// Can't place a memo that is too large.
assert_noop!(
Crowdloan::add_memo(Origin::signed(1), para_1, vec![123; 123]),
Crowdloan::add_memo(RuntimeOrigin::signed(1), para_1, vec![123; 123]),
Error::<Test>::MemoTooLarge,
);
// Adding a memo to an existing contribution works
assert_ok!(Crowdloan::add_memo(Origin::signed(1), para_1, b"hello, world".to_vec()));
assert_ok!(Crowdloan::add_memo(
RuntimeOrigin::signed(1),
para_1,
b"hello, world".to_vec()
));
assert_eq!(Crowdloan::contribution_get(0u32, &1), (100, b"hello, world".to_vec()));
// Can contribute again and data persists
assert_ok!(Crowdloan::contribute(Origin::signed(1), para_1, 100, None));
assert_ok!(Crowdloan::contribute(RuntimeOrigin::signed(1), para_1, 100, None));
assert_eq!(Crowdloan::contribution_get(0u32, &1), (200, b"hello, world".to_vec()));
});
}
@@ -1877,18 +1907,18 @@ mod tests {
let para_1 = new_para();
assert_ok!(TestAuctioneer::new_auction(5, 0));
assert_ok!(Crowdloan::create(Origin::signed(1), para_1, 1000, 1, 1, 9, None));
assert_ok!(Crowdloan::create(RuntimeOrigin::signed(1), para_1, 1000, 1, 1, 9, None));
// Should fail when no contributions.
assert_noop!(
Crowdloan::poke(Origin::signed(1), para_1),
Crowdloan::poke(RuntimeOrigin::signed(1), para_1),
Error::<Test>::NoContributions
);
assert_ok!(Crowdloan::contribute(Origin::signed(2), para_1, 100, None));
assert_ok!(Crowdloan::contribute(RuntimeOrigin::signed(2), para_1, 100, None));
run_to_block(6);
assert_ok!(Crowdloan::poke(Origin::signed(1), para_1));
assert_ok!(Crowdloan::poke(RuntimeOrigin::signed(1), para_1));
assert_eq!(Crowdloan::new_raise(), vec![para_1]);
assert_noop!(
Crowdloan::poke(Origin::signed(1), para_1),
Crowdloan::poke(RuntimeOrigin::signed(1), para_1),
Error::<Test>::AlreadyInNewRaise
);
});
polkadot/runtime/common/src/impls.rs
+1 -1
View File
@@ -106,7 +106,7 @@ mod tests {
impl frame_system::Config for Test {
type BaseCallFilter = frame_support::traits::Everything;
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type Index = u64;
type BlockNumber = u64;
type RuntimeCall = RuntimeCall;
polkadot/runtime/common/src/integration_tests.rs
+66 -22
View File
@@ -61,9 +61,9 @@ fn account_id(i: u32) -> AccountId32 {
array.into()
}
fn signed(i: u32) -> Origin {
fn signed(i: u32) -> RuntimeOrigin {
let account_id = account_id(i);
Origin::signed(account_id)
RuntimeOrigin::signed(account_id)
}
frame_support::construct_runtime!(
@@ -112,7 +112,7 @@ impl frame_system::Config for Test {
type BlockWeights = BlockWeights;
type BlockLength = ();
type DbWeight = ();
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type RuntimeCall = RuntimeCall;
type Index = u64;
type BlockNumber = BlockNumber;
@@ -218,7 +218,7 @@ impl paras_registrar::Config for Test {
type ParaDeposit = ParaDeposit;
type DataDepositPerByte = DataDepositPerByte;
type Currency = Balances;
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type WeightInfo = crate::paras_registrar::TestWeightInfo;
}
@@ -389,7 +389,11 @@ fn basic_end_to_end_works() {
// Start a new auction in the future
let duration = 99u32 + offset;
let lease_period_index_start = 4u32;
assert_ok!(Auctions::new_auction(Origin::root(), duration, lease_period_index_start));
assert_ok!(Auctions::new_auction(
RuntimeOrigin::root(),
duration,
lease_period_index_start
));
// 2 sessions later they are parathreads
run_to_session(2);
@@ -557,7 +561,11 @@ fn basic_errors_fail() {
// Start an auction
let duration = 99u32;
let lease_period_index_start = 4u32;
assert_ok!(Auctions::new_auction(Origin::root(), duration, lease_period_index_start));
assert_ok!(Auctions::new_auction(
RuntimeOrigin::root(),
duration,
lease_period_index_start
));
// Cannot create a crowdloan if you do not own the para
assert_noop!(
@@ -600,7 +608,11 @@ fn competing_slots() {
// Start a new auction in the future
let duration = 149u32;
let lease_period_index_start = 4u32;
assert_ok!(Auctions::new_auction(Origin::root(), duration, lease_period_index_start));
assert_ok!(Auctions::new_auction(
RuntimeOrigin::root(),
duration,
lease_period_index_start
));
// Paras should be onboarded
run_to_block(20); // session 2
@@ -697,7 +709,11 @@ fn competing_bids() {
let starting_block = System::block_number();
let duration = 99u32;
let lease_period_index_start = 4u32;
assert_ok!(Auctions::new_auction(Origin::root(), duration, lease_period_index_start));
assert_ok!(Auctions::new_auction(
RuntimeOrigin::root(),
duration,
lease_period_index_start
));
for n in 1..=3 {
// Create a crowdloan for each para
@@ -799,7 +815,11 @@ fn basic_swap_works() {
// Start a new auction in the future
let duration = 99u32;
let lease_period_index_start = 4u32;
assert_ok!(Auctions::new_auction(Origin::root(), duration, lease_period_index_start));
assert_ok!(Auctions::new_auction(
RuntimeOrigin::root(),
duration,
lease_period_index_start
));
// 2 sessions later they are parathreads
run_to_session(2);
@@ -955,7 +975,11 @@ fn parachain_swap_works() {
let unique_id = winner - 1999u32;
let starting_block = System::block_number();
let duration = 99u32;
assert_ok!(Auctions::new_auction(Origin::root(), duration, lease_period_index_start));
assert_ok!(Auctions::new_auction(
RuntimeOrigin::root(),
duration,
lease_period_index_start
));
// 2 sessions later they are parathreads
run_to_block(starting_block + 20);
@@ -1106,7 +1130,11 @@ fn crowdloan_ending_period_bid() {
// Start a new auction in the future
let duration = 99u32;
let lease_period_index_start = 4u32;
assert_ok!(Auctions::new_auction(Origin::root(), duration, lease_period_index_start));
assert_ok!(Auctions::new_auction(
RuntimeOrigin::root(),
duration,
lease_period_index_start
));
// 2 sessions later they are parathreads
run_to_session(2);
@@ -1182,7 +1210,11 @@ fn auction_bid_requires_registered_para() {
// Start a new auction in the future
let duration = 99u32;
let lease_period_index_start = 4u32;
assert_ok!(Auctions::new_auction(Origin::root(), duration, lease_period_index_start));
assert_ok!(Auctions::new_auction(
RuntimeOrigin::root(),
duration,
lease_period_index_start
));
// Can't bid with non-registered paras
Balances::make_free_balance_be(&account_id(1), 1_000_000_000);
@@ -1244,7 +1276,11 @@ fn gap_bids_work() {
// Start a new auction in the future
let duration = 99u32;
let lease_period_index_start = 4u32;
assert_ok!(Auctions::new_auction(Origin::root(), duration, lease_period_index_start));
assert_ok!(Auctions::new_auction(
RuntimeOrigin::root(),
duration,
lease_period_index_start
));
Balances::make_free_balance_be(&account_id(1), 1_000_000_000);
Balances::make_free_balance_be(&account_id(2), 1_000_000_000);
@@ -1432,7 +1468,11 @@ fn cant_bid_on_existing_lease_periods() {
let starting_block = System::block_number();
let duration = 99u32;
let lease_period_index_start = 4u32;
assert_ok!(Auctions::new_auction(Origin::root(), duration, lease_period_index_start));
assert_ok!(Auctions::new_auction(
RuntimeOrigin::root(),
duration,
lease_period_index_start
));
// 2 sessions later they are parathreads
run_to_session(2);
@@ -1480,7 +1520,11 @@ fn cant_bid_on_existing_lease_periods() {
let starting_block = System::block_number();
let duration = 99u32;
let lease_period_index_start = 4u32;
assert_ok!(Auctions::new_auction(Origin::root(), duration, lease_period_index_start));
assert_ok!(Auctions::new_auction(
RuntimeOrigin::root(),
duration,
lease_period_index_start
));
// Poke the crowdloan into `NewRaise`
assert_ok!(Crowdloan::poke(signed(1), ParaId::from(2000)));
@@ -1492,7 +1536,7 @@ fn cant_bid_on_existing_lease_periods() {
// Bids cannot be made which intersect
assert_noop!(
Auctions::bid(
Origin::signed(crowdloan_account.clone()),
RuntimeOrigin::signed(crowdloan_account.clone()),
ParaId::from(2000),
2,
lease_period_index_start + 0,
@@ -1504,7 +1548,7 @@ fn cant_bid_on_existing_lease_periods() {
assert_noop!(
Auctions::bid(
Origin::signed(crowdloan_account.clone()),
RuntimeOrigin::signed(crowdloan_account.clone()),
ParaId::from(2000),
2,
lease_period_index_start + 1,
@@ -1516,7 +1560,7 @@ fn cant_bid_on_existing_lease_periods() {
assert_noop!(
Auctions::bid(
Origin::signed(crowdloan_account.clone()),
RuntimeOrigin::signed(crowdloan_account.clone()),
ParaId::from(2000),
2,
lease_period_index_start - 1,
@@ -1528,7 +1572,7 @@ fn cant_bid_on_existing_lease_periods() {
assert_noop!(
Auctions::bid(
Origin::signed(crowdloan_account.clone()),
RuntimeOrigin::signed(crowdloan_account.clone()),
ParaId::from(2000),
2,
lease_period_index_start + 0,
@@ -1540,7 +1584,7 @@ fn cant_bid_on_existing_lease_periods() {
assert_noop!(
Auctions::bid(
Origin::signed(crowdloan_account.clone()),
RuntimeOrigin::signed(crowdloan_account.clone()),
ParaId::from(2000),
2,
lease_period_index_start + 1,
@@ -1552,7 +1596,7 @@ fn cant_bid_on_existing_lease_periods() {
assert_noop!(
Auctions::bid(
Origin::signed(crowdloan_account.clone()),
RuntimeOrigin::signed(crowdloan_account.clone()),
ParaId::from(2000),
2,
lease_period_index_start - 1,
@@ -1564,7 +1608,7 @@ fn cant_bid_on_existing_lease_periods() {
// Will work when not overlapping
assert_ok!(Auctions::bid(
Origin::signed(crowdloan_account.clone()),
RuntimeOrigin::signed(crowdloan_account.clone()),
ParaId::from(2000),
2,
lease_period_index_start + 2,
polkadot/runtime/common/src/paras_registrar.rs
+61 -57
View File
@@ -102,8 +102,8 @@ pub mod pallet {
/// infallibly convert between this origin and the system origin, but in reality, they're the
/// same type, we just can't express that to the Rust type system without writing a `where`
/// clause everywhere.
type Origin: From<<Self as frame_system::Config>::Origin>
+ Into<result::Result<Origin, <Self as Config>::Origin>>;
type RuntimeOrigin: From<<Self as frame_system::Config>::RuntimeOrigin>
+ Into<result::Result<Origin, <Self as Config>::RuntimeOrigin>>;
/// The system's currency for parathread payment.
type Currency: ReservableCurrency<Self::AccountId>;
@@ -456,7 +456,7 @@ impl<T: Config> Pallet<T> {
/// Ensure the origin is one of Root, the `para` owner, or the `para` itself.
/// If the origin is the `para` owner, the `para` must be unlocked.
fn ensure_root_para_or_owner(
origin: <T as frame_system::Config>::Origin,
origin: <T as frame_system::Config>::RuntimeOrigin,
id: ParaId,
) -> DispatchResult {
ensure_signed(origin.clone())
@@ -469,7 +469,8 @@ impl<T: Config> Pallet<T> {
})
.or_else(|_| -> DispatchResult {
// Else check if para origin...
let caller_id = ensure_parachain(<T as Config>::Origin::from(origin.clone()))?;
let caller_id =
ensure_parachain(<T as Config>::RuntimeOrigin::from(origin.clone()))?;
ensure!(caller_id == id, Error::<T>::NotOwner);
Ok(())
})
@@ -648,7 +649,7 @@ mod tests {
impl frame_system::Config for Test {
type BaseCallFilter = frame_support::traits::Everything;
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type RuntimeCall = RuntimeCall;
type Index = u64;
type BlockNumber = BlockNumber;
@@ -715,8 +716,8 @@ mod tests {
}
impl Config for Test {
type RuntimeOrigin = RuntimeOrigin;
type RuntimeEvent = RuntimeEvent;
type Origin = Origin;
type Currency = Balances;
type OnSwap = MockSwap;
type ParaDeposit = ParaDeposit;
@@ -800,7 +801,7 @@ mod tests {
ValidationCode(validation_code)
}
fn para_origin(id: ParaId) -> Origin {
fn para_origin(id: ParaId) -> RuntimeOrigin {
runtime_parachains::Origin::Parachain(id).into()
}
@@ -828,9 +829,9 @@ mod tests {
// first para is not yet registered
assert!(!Parachains::is_parathread(para_id));
// We register the Para ID
assert_ok!(Registrar::reserve(Origin::signed(1)));
assert_ok!(Registrar::reserve(RuntimeOrigin::signed(1)));
assert_ok!(Registrar::register(
Origin::signed(1),
RuntimeOrigin::signed(1),
para_id,
test_genesis_head(32),
test_validation_code(32),
@@ -851,7 +852,7 @@ mod tests {
assert!(Parachains::is_parathread(para_id));
assert!(!Parachains::is_parachain(para_id));
// Deregister it
assert_ok!(Registrar::deregister(Origin::root(), para_id,));
assert_ok!(Registrar::deregister(RuntimeOrigin::root(), para_id,));
run_to_session(8);
// It is nothing
assert!(!Parachains::is_parathread(para_id));
@@ -865,10 +866,10 @@ mod tests {
run_to_block(1);
let para_id = LOWEST_PUBLIC_ID;
assert!(!Parachains::is_parathread(para_id));
assert_ok!(Registrar::reserve(Origin::signed(1)));
assert_ok!(Registrar::reserve(RuntimeOrigin::signed(1)));
assert_eq!(Balances::reserved_balance(&1), <Test as Config>::ParaDeposit::get());
assert_ok!(Registrar::register(
Origin::signed(1),
RuntimeOrigin::signed(1),
para_id,
test_genesis_head(32),
test_validation_code(32),
@@ -890,7 +891,7 @@ mod tests {
assert_noop!(
Registrar::register(
Origin::signed(1),
RuntimeOrigin::signed(1),
para_id,
test_genesis_head(max_head_size() as usize),
test_validation_code(max_code_size() as usize),
@@ -899,11 +900,11 @@ mod tests {
);
// Successfully register para
assert_ok!(Registrar::reserve(Origin::signed(1)));
assert_ok!(Registrar::reserve(RuntimeOrigin::signed(1)));
assert_noop!(
Registrar::register(
Origin::signed(2),
RuntimeOrigin::signed(2),
para_id,
test_genesis_head(max_head_size() as usize),
test_validation_code(max_code_size() as usize),
@@ -912,7 +913,7 @@ mod tests {
);
assert_ok!(Registrar::register(
Origin::signed(1),
RuntimeOrigin::signed(1),
para_id,
test_genesis_head(max_head_size() as usize),
test_validation_code(max_code_size() as usize),
@@ -920,12 +921,12 @@ mod tests {
run_to_session(2);
assert_ok!(Registrar::deregister(Origin::root(), para_id));
assert_ok!(Registrar::deregister(RuntimeOrigin::root(), para_id));
// Can't do it again
assert_noop!(
Registrar::register(
Origin::signed(1),
RuntimeOrigin::signed(1),
para_id,
test_genesis_head(max_head_size() as usize),
test_validation_code(max_code_size() as usize),
@@ -934,10 +935,10 @@ mod tests {
);
// Head Size Check
assert_ok!(Registrar::reserve(Origin::signed(2)));
assert_ok!(Registrar::reserve(RuntimeOrigin::signed(2)));
assert_noop!(
Registrar::register(
Origin::signed(2),
RuntimeOrigin::signed(2),
para_id + 1,
test_genesis_head((max_head_size() + 1) as usize),
test_validation_code(max_code_size() as usize),
@@ -948,7 +949,7 @@ mod tests {
// Code Size Check
assert_noop!(
Registrar::register(
Origin::signed(2),
RuntimeOrigin::signed(2),
para_id + 1,
test_genesis_head(max_head_size() as usize),
test_validation_code((max_code_size() + 1) as usize),
@@ -958,7 +959,7 @@ mod tests {
// Needs enough funds for deposit
assert_noop!(
Registrar::reserve(Origin::signed(1337)),
Registrar::reserve(RuntimeOrigin::signed(1337)),
BalancesError::<Test, _>::InsufficientBalance
);
});
@@ -970,16 +971,16 @@ mod tests {
run_to_block(1);
let para_id = LOWEST_PUBLIC_ID;
assert!(!Parachains::is_parathread(para_id));
assert_ok!(Registrar::reserve(Origin::signed(1)));
assert_ok!(Registrar::reserve(RuntimeOrigin::signed(1)));
assert_ok!(Registrar::register(
Origin::signed(1),
RuntimeOrigin::signed(1),
para_id,
test_genesis_head(32),
test_validation_code(32),
));
run_to_session(2);
assert!(Parachains::is_parathread(para_id));
assert_ok!(Registrar::deregister(Origin::root(), para_id,));
assert_ok!(Registrar::deregister(RuntimeOrigin::root(), para_id,));
run_to_session(4);
assert!(paras::Pallet::<Test>::lifecycle(para_id).is_none());
assert_eq!(Balances::reserved_balance(&1), 0);
@@ -992,9 +993,9 @@ mod tests {
run_to_block(1);
let para_id = LOWEST_PUBLIC_ID;
assert!(!Parachains::is_parathread(para_id));
assert_ok!(Registrar::reserve(Origin::signed(1)));
assert_ok!(Registrar::reserve(RuntimeOrigin::signed(1)));
assert_ok!(Registrar::register(
Origin::signed(1),
RuntimeOrigin::signed(1),
para_id,
test_genesis_head(32),
test_validation_code(32),
@@ -1002,12 +1003,12 @@ mod tests {
run_to_session(2);
assert!(Parachains::is_parathread(para_id));
// Owner check
assert_noop!(Registrar::deregister(Origin::signed(2), para_id,), BadOrigin);
assert_noop!(Registrar::deregister(RuntimeOrigin::signed(2), para_id,), BadOrigin);
assert_ok!(Registrar::make_parachain(para_id));
run_to_session(4);
// Cant directly deregister parachain
assert_noop!(
Registrar::deregister(Origin::root(), para_id,),
Registrar::deregister(RuntimeOrigin::root(), para_id,),
Error::<Test>::NotParathread
);
});
@@ -1019,16 +1020,16 @@ mod tests {
// Successfully register first two parachains
let para_1 = LOWEST_PUBLIC_ID;
let para_2 = LOWEST_PUBLIC_ID + 1;
assert_ok!(Registrar::reserve(Origin::signed(1)));
assert_ok!(Registrar::reserve(RuntimeOrigin::signed(1)));
assert_ok!(Registrar::register(
Origin::signed(1),
RuntimeOrigin::signed(1),
para_1,
test_genesis_head(max_head_size() as usize),
test_validation_code(max_code_size() as usize),
));
assert_ok!(Registrar::reserve(Origin::signed(2)));
assert_ok!(Registrar::reserve(RuntimeOrigin::signed(2)));
assert_ok!(Registrar::register(
Origin::signed(2),
RuntimeOrigin::signed(2),
para_2,
test_genesis_head(max_head_size() as usize),
test_validation_code(max_code_size() as usize),
@@ -1075,17 +1076,17 @@ mod tests {
new_test_ext().execute_with(|| {
run_to_block(1);
assert_ok!(Registrar::reserve(Origin::signed(1)));
assert_ok!(Registrar::reserve(RuntimeOrigin::signed(1)));
let para_id = LOWEST_PUBLIC_ID;
assert_ok!(Registrar::register(
Origin::signed(1),
RuntimeOrigin::signed(1),
para_id,
vec![1; 3].into(),
vec![1, 2, 3].into(),
));
// Owner can call swap
assert_ok!(Registrar::swap(Origin::signed(1), para_id, para_id + 1));
assert_ok!(Registrar::swap(RuntimeOrigin::signed(1), para_id, para_id + 1));
// 2 session changes to fully onboard.
run_to_session(2);
@@ -1095,7 +1096,10 @@ mod tests {
assert_ok!(Registrar::make_parachain(para_id));
// Owner cannot call swap anymore
assert_noop!(Registrar::swap(Origin::signed(1), para_id, para_id + 2), BadOrigin);
assert_noop!(
Registrar::swap(RuntimeOrigin::signed(1), para_id, para_id + 2),
BadOrigin
);
});
}
@@ -1111,30 +1115,30 @@ mod tests {
// Cannot even start a swap
assert_noop!(
Registrar::swap(Origin::root(), para_1, para_2),
Registrar::swap(RuntimeOrigin::root(), para_1, para_2),
Error::<Test>::NotRegistered
);
// We register Paras 1 and 2
assert_ok!(Registrar::reserve(Origin::signed(1)));
assert_ok!(Registrar::reserve(Origin::signed(2)));
assert_ok!(Registrar::reserve(RuntimeOrigin::signed(1)));
assert_ok!(Registrar::reserve(RuntimeOrigin::signed(2)));
assert_ok!(Registrar::register(
Origin::signed(1),
RuntimeOrigin::signed(1),
para_1,
test_genesis_head(32),
test_validation_code(32),
));
assert_ok!(Registrar::register(
Origin::signed(2),
RuntimeOrigin::signed(2),
para_2,
test_genesis_head(32),
test_validation_code(32),
));
// Cannot swap
assert_ok!(Registrar::swap(Origin::root(), para_1, para_2));
assert_ok!(Registrar::swap(RuntimeOrigin::root(), para_1, para_2));
assert_noop!(
Registrar::swap(Origin::root(), para_2, para_1),
Registrar::swap(RuntimeOrigin::root(), para_2, para_1),
Error::<Test>::CannotSwap
);
@@ -1145,9 +1149,9 @@ mod tests {
assert!(Parachains::is_parathread(para_2));
// Cannot swap
assert_ok!(Registrar::swap(Origin::root(), para_1, para_2));
assert_ok!(Registrar::swap(RuntimeOrigin::root(), para_1, para_2));
assert_noop!(
Registrar::swap(Origin::root(), para_2, para_1),
Registrar::swap(RuntimeOrigin::root(), para_2, para_1),
Error::<Test>::CannotSwap
);
@@ -1155,18 +1159,18 @@ mod tests {
assert_ok!(Registrar::make_parachain(para_1));
// Cannot swap
assert_ok!(Registrar::swap(Origin::root(), para_1, para_2));
assert_ok!(Registrar::swap(RuntimeOrigin::root(), para_1, para_2));
assert_noop!(
Registrar::swap(Origin::root(), para_2, para_1),
Registrar::swap(RuntimeOrigin::root(), para_2, para_1),
Error::<Test>::CannotSwap
);
run_to_session(3);
// Cannot swap
assert_ok!(Registrar::swap(Origin::root(), para_1, para_2));
assert_ok!(Registrar::swap(RuntimeOrigin::root(), para_1, para_2));
assert_noop!(
Registrar::swap(Origin::root(), para_2, para_1),
Registrar::swap(RuntimeOrigin::root(), para_2, para_1),
Error::<Test>::CannotSwap
);
@@ -1177,15 +1181,15 @@ mod tests {
assert!(Parachains::is_parathread(para_2));
// Swap works here.
assert_ok!(Registrar::swap(Origin::root(), para_1, para_2));
assert_ok!(Registrar::swap(Origin::root(), para_2, para_1));
assert_ok!(Registrar::swap(RuntimeOrigin::root(), para_1, para_2));
assert_ok!(Registrar::swap(RuntimeOrigin::root(), para_2, para_1));
run_to_session(5);
// Cannot swap
assert_ok!(Registrar::swap(Origin::root(), para_1, para_2));
assert_ok!(Registrar::swap(RuntimeOrigin::root(), para_1, para_2));
assert_noop!(
Registrar::swap(Origin::root(), para_2, para_1),
Registrar::swap(RuntimeOrigin::root(), para_2, para_1),
Error::<Test>::CannotSwap
);
@@ -1201,9 +1205,9 @@ mod tests {
run_to_session(7);
// Cannot swap
assert_ok!(Registrar::swap(Origin::root(), para_1, para_2));
assert_ok!(Registrar::swap(RuntimeOrigin::root(), para_1, para_2));
assert_noop!(
Registrar::swap(Origin::root(), para_2, para_1),
Registrar::swap(RuntimeOrigin::root(), para_2, para_1),
Error::<Test>::CannotSwap
);
@@ -1261,7 +1265,7 @@ mod benchmarking {
}
benchmarks! {
where_clause { where ParaOrigin: Into<<T as frame_system::Config>::Origin> }
where_clause { where ParaOrigin: Into<<T as frame_system::Config>::RuntimeOrigin> }
reserve {
let caller: T::AccountId = whitelisted_caller();
polkadot/runtime/common/src/purchase.rs
+72 -56
View File
@@ -111,10 +111,10 @@ pub mod pallet {
>;
/// The origin allowed to set account status.
type ValidityOrigin: EnsureOrigin<Self::Origin>;
type ValidityOrigin: EnsureOrigin<Self::RuntimeOrigin>;
/// The origin allowed to make configurations to the pallet.
type ConfigurationOrigin: EnsureOrigin<Self::Origin>;
type ConfigurationOrigin: EnsureOrigin<Self::RuntimeOrigin>;
/// The maximum statement length for the statement users to sign when creating an account.
#[pallet::constant]
@@ -510,7 +510,7 @@ mod tests {
type BlockWeights = ();
type BlockLength = ();
type DbWeight = ();
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type RuntimeCall = RuntimeCall;
type Index = u64;
type BlockNumber = u64;
@@ -596,10 +596,14 @@ mod tests {
fn setup() {
let statement = b"Hello, World".to_vec();
let unlock_block = 100;
Purchase::set_statement(Origin::signed(configuration_origin()), statement).unwrap();
Purchase::set_unlock_block(Origin::signed(configuration_origin()), unlock_block).unwrap();
Purchase::set_payment_account(Origin::signed(configuration_origin()), payment_account())
Purchase::set_statement(RuntimeOrigin::signed(configuration_origin()), statement).unwrap();
Purchase::set_unlock_block(RuntimeOrigin::signed(configuration_origin()), unlock_block)
.unwrap();
Purchase::set_payment_account(
RuntimeOrigin::signed(configuration_origin()),
payment_account(),
)
.unwrap();
Balances::make_free_balance_be(&payment_account(), 100_000);
}
@@ -665,18 +669,21 @@ mod tests {
let statement = b"Test Set Statement".to_vec();
// Invalid origin
assert_noop!(
Purchase::set_statement(Origin::signed(alice()), statement.clone()),
Purchase::set_statement(RuntimeOrigin::signed(alice()), statement.clone()),
BadOrigin,
);
// Too Long
let long_statement = [0u8; 10_000].to_vec();
assert_noop!(
Purchase::set_statement(Origin::signed(configuration_origin()), long_statement),
Purchase::set_statement(
RuntimeOrigin::signed(configuration_origin()),
long_statement
),
Error::<Test>::InvalidStatement,
);
// Just right...
assert_ok!(Purchase::set_statement(
Origin::signed(configuration_origin()),
RuntimeOrigin::signed(configuration_origin()),
statement.clone()
));
assert_eq!(Statement::<Test>::get(), statement);
@@ -689,7 +696,7 @@ mod tests {
let unlock_block = 69;
// Invalid origin
assert_noop!(
Purchase::set_unlock_block(Origin::signed(alice()), unlock_block),
Purchase::set_unlock_block(RuntimeOrigin::signed(alice()), unlock_block),
BadOrigin,
);
// Block Number in Past
@@ -697,14 +704,14 @@ mod tests {
System::set_block_number(bad_unlock_block);
assert_noop!(
Purchase::set_unlock_block(
Origin::signed(configuration_origin()),
RuntimeOrigin::signed(configuration_origin()),
bad_unlock_block
),
Error::<Test>::InvalidUnlockBlock,
);
// Just right...
assert_ok!(Purchase::set_unlock_block(
Origin::signed(configuration_origin()),
RuntimeOrigin::signed(configuration_origin()),
unlock_block
));
assert_eq!(UnlockBlock::<Test>::get(), unlock_block);
@@ -717,12 +724,15 @@ mod tests {
let payment_account: AccountId = [69u8; 32].into();
// Invalid Origin
assert_noop!(
Purchase::set_payment_account(Origin::signed(alice()), payment_account.clone()),
Purchase::set_payment_account(
RuntimeOrigin::signed(alice()),
payment_account.clone()
),
BadOrigin,
);
// Just right...
assert_ok!(Purchase::set_payment_account(
Origin::signed(configuration_origin()),
RuntimeOrigin::signed(configuration_origin()),
payment_account.clone()
));
assert_eq!(PaymentAccount::<Test>::get(), Some(payment_account));
@@ -753,7 +763,7 @@ mod tests {
new_test_ext().execute_with(|| {
assert!(!Accounts::<Test>::contains_key(alice()));
assert_ok!(Purchase::create_account(
Origin::signed(validity_origin()),
RuntimeOrigin::signed(validity_origin()),
alice(),
alice_signature().to_vec(),
));
@@ -776,7 +786,7 @@ mod tests {
// Wrong Origin
assert_noop!(
Purchase::create_account(
Origin::signed(alice()),
RuntimeOrigin::signed(alice()),
alice(),
alice_signature().to_vec()
),
@@ -786,7 +796,7 @@ mod tests {
// Wrong Account/Signature
assert_noop!(
Purchase::create_account(
Origin::signed(validity_origin()),
RuntimeOrigin::signed(validity_origin()),
alice(),
bob_signature().to_vec()
),
@@ -802,7 +812,7 @@ mod tests {
));
assert_noop!(
Purchase::create_account(
Origin::signed(validity_origin()),
RuntimeOrigin::signed(validity_origin()),
alice(),
alice_signature().to_vec()
),
@@ -811,13 +821,13 @@ mod tests {
// Duplicate Purchasing Account
assert_ok!(Purchase::create_account(
Origin::signed(validity_origin()),
RuntimeOrigin::signed(validity_origin()),
bob(),
bob_signature().to_vec()
));
assert_noop!(
Purchase::create_account(
Origin::signed(validity_origin()),
RuntimeOrigin::signed(validity_origin()),
bob(),
bob_signature().to_vec()
),
@@ -831,19 +841,19 @@ mod tests {
new_test_ext().execute_with(|| {
// Alice account is created.
assert_ok!(Purchase::create_account(
Origin::signed(validity_origin()),
RuntimeOrigin::signed(validity_origin()),
alice(),
alice_signature().to_vec(),
));
// She submits KYC, and we update the status to `Pending`.
assert_ok!(Purchase::update_validity_status(
Origin::signed(validity_origin()),
RuntimeOrigin::signed(validity_origin()),
alice(),
AccountValidity::Pending,
));
// KYC comes back negative, so we mark the account invalid.
assert_ok!(Purchase::update_validity_status(
Origin::signed(validity_origin()),
RuntimeOrigin::signed(validity_origin()),
alice(),
AccountValidity::Invalid,
));
@@ -859,7 +869,7 @@ mod tests {
);
// She fixes it, we mark her account valid.
assert_ok!(Purchase::update_validity_status(
Origin::signed(validity_origin()),
RuntimeOrigin::signed(validity_origin()),
alice(),
AccountValidity::ValidLow,
));
@@ -882,7 +892,7 @@ mod tests {
// Wrong Origin
assert_noop!(
Purchase::update_validity_status(
Origin::signed(alice()),
RuntimeOrigin::signed(alice()),
alice(),
AccountValidity::Pending,
),
@@ -891,7 +901,7 @@ mod tests {
// Inactive Account
assert_noop!(
Purchase::update_validity_status(
Origin::signed(validity_origin()),
RuntimeOrigin::signed(validity_origin()),
alice(),
AccountValidity::Pending,
),
@@ -899,18 +909,18 @@ mod tests {
);
// Already Completed
assert_ok!(Purchase::create_account(
Origin::signed(validity_origin()),
RuntimeOrigin::signed(validity_origin()),
alice(),
alice_signature().to_vec(),
));
assert_ok!(Purchase::update_validity_status(
Origin::signed(validity_origin()),
RuntimeOrigin::signed(validity_origin()),
alice(),
AccountValidity::Completed,
));
assert_noop!(
Purchase::update_validity_status(
Origin::signed(validity_origin()),
RuntimeOrigin::signed(validity_origin()),
alice(),
AccountValidity::Pending,
),
@@ -924,19 +934,19 @@ mod tests {
new_test_ext().execute_with(|| {
// Alice account is created
assert_ok!(Purchase::create_account(
Origin::signed(validity_origin()),
RuntimeOrigin::signed(validity_origin()),
alice(),
alice_signature().to_vec()
));
// And approved for basic contribution
assert_ok!(Purchase::update_validity_status(
Origin::signed(validity_origin()),
RuntimeOrigin::signed(validity_origin()),
alice(),
AccountValidity::ValidLow,
));
// We set a balance on the user based on the payment they made. 50 locked, 50 free.
assert_ok!(Purchase::update_balance(
Origin::signed(validity_origin()),
RuntimeOrigin::signed(validity_origin()),
alice(),
50,
50,
@@ -954,7 +964,7 @@ mod tests {
);
// We can update the balance based on new information.
assert_ok!(Purchase::update_balance(
Origin::signed(validity_origin()),
RuntimeOrigin::signed(validity_origin()),
alice(),
25,
50,
@@ -978,13 +988,19 @@ mod tests {
new_test_ext().execute_with(|| {
// Wrong Origin
assert_noop!(
Purchase::update_balance(Origin::signed(alice()), alice(), 50, 50, Permill::zero(),),
Purchase::update_balance(
RuntimeOrigin::signed(alice()),
alice(),
50,
50,
Permill::zero(),
),
BadOrigin
);
// Inactive Account
assert_noop!(
Purchase::update_balance(
Origin::signed(validity_origin()),
RuntimeOrigin::signed(validity_origin()),
alice(),
50,
50,
@@ -995,7 +1011,7 @@ mod tests {
// Overflow
assert_noop!(
Purchase::update_balance(
Origin::signed(validity_origin()),
RuntimeOrigin::signed(validity_origin()),
alice(),
u64::MAX,
u64::MAX,
@@ -1011,45 +1027,45 @@ mod tests {
new_test_ext().execute_with(|| {
// Alice and Bob accounts are created
assert_ok!(Purchase::create_account(
Origin::signed(validity_origin()),
RuntimeOrigin::signed(validity_origin()),
alice(),
alice_signature().to_vec()
));
assert_ok!(Purchase::create_account(
Origin::signed(validity_origin()),
RuntimeOrigin::signed(validity_origin()),
bob(),
bob_signature().to_vec()
));
// Alice is approved for basic contribution
assert_ok!(Purchase::update_validity_status(
Origin::signed(validity_origin()),
RuntimeOrigin::signed(validity_origin()),
alice(),
AccountValidity::ValidLow,
));
// Bob is approved for high contribution
assert_ok!(Purchase::update_validity_status(
Origin::signed(validity_origin()),
RuntimeOrigin::signed(validity_origin()),
bob(),
AccountValidity::ValidHigh,
));
// We set a balance on the users based on the payment they made. 50 locked, 50 free.
assert_ok!(Purchase::update_balance(
Origin::signed(validity_origin()),
RuntimeOrigin::signed(validity_origin()),
alice(),
50,
50,
Permill::zero(),
));
assert_ok!(Purchase::update_balance(
Origin::signed(validity_origin()),
RuntimeOrigin::signed(validity_origin()),
bob(),
100,
150,
Permill::zero(),
));
// Now we call payout for Alice and Bob.
assert_ok!(Purchase::payout(Origin::signed(payment_account()), alice(),));
assert_ok!(Purchase::payout(Origin::signed(payment_account()), bob(),));
assert_ok!(Purchase::payout(RuntimeOrigin::signed(payment_account()), alice(),));
assert_ok!(Purchase::payout(RuntimeOrigin::signed(payment_account()), bob(),));
// Payment is made.
assert_eq!(<Test as Config>::Currency::free_balance(&payment_account()), 99_650);
assert_eq!(<Test as Config>::Currency::free_balance(&alice()), 100);
@@ -1082,13 +1098,13 @@ mod tests {
// Vesting lock is removed in whole on block 101 (100 blocks after block 1)
System::set_block_number(100);
let vest_call = RuntimeCall::Vesting(pallet_vesting::Call::<Test>::vest {});
assert_ok!(vest_call.clone().dispatch(Origin::signed(alice())));
assert_ok!(vest_call.clone().dispatch(Origin::signed(bob())));
assert_ok!(vest_call.clone().dispatch(RuntimeOrigin::signed(alice())));
assert_ok!(vest_call.clone().dispatch(RuntimeOrigin::signed(bob())));
assert_eq!(<Test as Config>::VestingSchedule::vesting_balance(&alice()), Some(45));
assert_eq!(<Test as Config>::VestingSchedule::vesting_balance(&bob()), Some(140));
System::set_block_number(101);
assert_ok!(vest_call.clone().dispatch(Origin::signed(alice())));
assert_ok!(vest_call.clone().dispatch(Origin::signed(bob())));
assert_ok!(vest_call.clone().dispatch(RuntimeOrigin::signed(alice())));
assert_ok!(vest_call.clone().dispatch(RuntimeOrigin::signed(bob())));
assert_eq!(<Test as Config>::VestingSchedule::vesting_balance(&alice()), None);
assert_eq!(<Test as Config>::VestingSchedule::vesting_balance(&bob()), None);
});
@@ -1098,45 +1114,45 @@ mod tests {
fn payout_handles_basic_errors() {
new_test_ext().execute_with(|| {
// Wrong Origin
assert_noop!(Purchase::payout(Origin::signed(alice()), alice(),), BadOrigin);
assert_noop!(Purchase::payout(RuntimeOrigin::signed(alice()), alice(),), BadOrigin);
// Account with Existing Vesting Schedule
assert_ok!(
<Test as Config>::VestingSchedule::add_vesting_schedule(&bob(), 100, 1, 50,)
);
assert_noop!(
Purchase::payout(Origin::signed(payment_account()), bob(),),
Purchase::payout(RuntimeOrigin::signed(payment_account()), bob(),),
Error::<Test>::VestingScheduleExists
);
// Invalid Account (never created)
assert_noop!(
Purchase::payout(Origin::signed(payment_account()), alice(),),
Purchase::payout(RuntimeOrigin::signed(payment_account()), alice(),),
Error::<Test>::InvalidAccount
);
// Invalid Account (created, but not valid)
assert_ok!(Purchase::create_account(
Origin::signed(validity_origin()),
RuntimeOrigin::signed(validity_origin()),
alice(),
alice_signature().to_vec()
));
assert_noop!(
Purchase::payout(Origin::signed(payment_account()), alice(),),
Purchase::payout(RuntimeOrigin::signed(payment_account()), alice(),),
Error::<Test>::InvalidAccount
);
// Not enough funds in payment account
assert_ok!(Purchase::update_validity_status(
Origin::signed(validity_origin()),
RuntimeOrigin::signed(validity_origin()),
alice(),
AccountValidity::ValidHigh,
));
assert_ok!(Purchase::update_balance(
Origin::signed(validity_origin()),
RuntimeOrigin::signed(validity_origin()),
alice(),
100_000,
100_000,
Permill::zero(),
));
assert_noop!(
Purchase::payout(Origin::signed(payment_account()), alice(),),
Purchase::payout(RuntimeOrigin::signed(payment_account()), alice(),),
BalancesError::<Test, _>::InsufficientBalance
);
});
polkadot/runtime/common/src/slots/mod.rs
+9 -9
View File
@@ -91,7 +91,7 @@ pub mod pallet {
type LeaseOffset: Get<Self::BlockNumber>;
/// The origin which may forcibly create or clear leases. Root can always do this.
type ForceOrigin: EnsureOrigin<<Self as frame_system::Config>::Origin>;
type ForceOrigin: EnsureOrigin<<Self as frame_system::Config>::RuntimeOrigin>;
/// Weight Information for the Extrinsics in the Pallet
type WeightInfo: WeightInfo;
@@ -529,7 +529,7 @@ mod tests {
type BaseCallFilter = frame_support::traits::Everything;
type BlockWeights = ();
type BlockLength = ();
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type RuntimeCall = RuntimeCall;
type Index = u64;
type BlockNumber = BlockNumber;
@@ -847,7 +847,7 @@ mod tests {
assert_eq!(Balances::reserved_balance(j), j * 10);
}
assert_ok!(Slots::clear_all_leases(Origin::root(), 1.into()));
assert_ok!(Slots::clear_all_leases(RuntimeOrigin::root(), 1.into()));
// Balances cleaned up correctly
for i in 1u32..=max_num {
@@ -925,21 +925,21 @@ mod tests {
// Para 1 should fail cause they don't have any leases
assert_noop!(
Slots::trigger_onboard(Origin::signed(1), 1.into()),
Slots::trigger_onboard(RuntimeOrigin::signed(1), 1.into()),
Error::<Test>::ParaNotOnboarding
);
// Para 2 should succeed
assert_ok!(Slots::trigger_onboard(Origin::signed(1), 2.into()));
assert_ok!(Slots::trigger_onboard(RuntimeOrigin::signed(1), 2.into()));
// Para 3 should fail cause their lease is in the future
assert_noop!(
Slots::trigger_onboard(Origin::signed(1), 3.into()),
Slots::trigger_onboard(RuntimeOrigin::signed(1), 3.into()),
Error::<Test>::ParaNotOnboarding
);
// Trying Para 2 again should fail cause they are not currently a parathread
assert!(Slots::trigger_onboard(Origin::signed(1), 2.into()).is_err());
assert!(Slots::trigger_onboard(RuntimeOrigin::signed(1), 2.into()).is_err());
assert_eq!(TestRegistrar::<Test>::operations(), vec![(2.into(), 1, true),]);
});
@@ -1025,7 +1025,7 @@ mod benchmarking {
let period_begin = 69u32.into();
let period_count = 3u32.into();
let origin = T::ForceOrigin::successful_origin();
}: _<T::Origin>(origin, para, leaser.clone(), amount, period_begin, period_count)
}: _<T::RuntimeOrigin>(origin, para, leaser.clone(), amount, period_begin, period_count)
verify {
assert_last_event::<T>(Event::<T>::Leased {
para_id: para,
@@ -1119,7 +1119,7 @@ mod benchmarking {
}
let origin = T::ForceOrigin::successful_origin();
}: _<T::Origin>(origin, para)
}: _<T::RuntimeOrigin>(origin, para)
verify {
for i in 0 .. max_people {
let leaser = account("lease_deposit", i, 0);
polkadot/runtime/kusama/src/governance/old.rs
+2 -2
View File
@@ -92,7 +92,7 @@ parameter_types! {
pub type CouncilCollective = pallet_collective::Instance1;
impl pallet_collective::Config<CouncilCollective> for Runtime {
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type Proposal = RuntimeCall;
type RuntimeEvent = RuntimeEvent;
type MotionDuration = CouncilMotionDuration;
@@ -148,7 +148,7 @@ parameter_types! {
pub type TechnicalCollective = pallet_collective::Instance2;
impl pallet_collective::Config<TechnicalCollective> for Runtime {
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type Proposal = RuntimeCall;
type RuntimeEvent = RuntimeEvent;
type MotionDuration = TechnicalMotionDuration;
polkadot/runtime/kusama/src/lib.rs
+4 -4
View File
@@ -157,7 +157,7 @@ impl frame_system::Config for Runtime {
type BaseCallFilter = frame_support::traits::Everything;
type BlockWeights = BlockWeights;
type BlockLength = BlockLength;
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type RuntimeCall = RuntimeCall;
type Index = Nonce;
type BlockNumber = BlockNumber;
@@ -216,8 +216,8 @@ impl PrivilegeCmp<OriginCaller> for OriginPrivilegeCmp {
}
impl pallet_scheduler::Config for Runtime {
type RuntimeOrigin = RuntimeOrigin;
type RuntimeEvent = RuntimeEvent;
type Origin = Origin;
type PalletsOrigin = OriginCaller;
type RuntimeCall = RuntimeCall;
type MaximumWeight = MaximumSchedulerWeight;
@@ -1152,8 +1152,8 @@ impl parachains_ump::Config for Runtime {
impl parachains_dmp::Config for Runtime {}
impl parachains_hrmp::Config for Runtime {
type RuntimeOrigin = RuntimeOrigin;
type RuntimeEvent = RuntimeEvent;
type Origin = Origin;
type Currency = Balances;
type WeightInfo = weights::runtime_parachains_hrmp::WeightInfo<Runtime>;
}
@@ -1182,8 +1182,8 @@ parameter_types! {
}
impl paras_registrar::Config for Runtime {
type RuntimeOrigin = RuntimeOrigin;
type RuntimeEvent = RuntimeEvent;
type Origin = Origin;
type Currency = Balances;
type OnSwap = (Crowdloan, Slots);
type ParaDeposit = ParaDeposit;
polkadot/runtime/kusama/src/xcm_config.rs
+11 -11
View File
@@ -17,8 +17,8 @@
//! XCM configurations for the Kusama runtime.
use super::{
parachains_origin, AccountId, Balances, CouncilCollective, Origin, ParaId, Runtime,
RuntimeCall, RuntimeEvent, WeightToFee, XcmPallet,
parachains_origin, AccountId, Balances, CouncilCollective, ParaId, Runtime, RuntimeCall,
RuntimeEvent, RuntimeOrigin, WeightToFee, XcmPallet,
};
use frame_support::{match_types, parameter_types, traits::Everything};
use runtime_common::{xcm_sender, ToAuthor};
@@ -75,13 +75,13 @@ pub type LocalAssetTransactor = XcmCurrencyAdapter<
/// The means that we convert an the XCM message origin location into a local dispatch origin.
type LocalOriginConverter = (
// A `Signed` origin of the sovereign account that the original location controls.
SovereignSignedViaLocation<SovereignAccountOf, Origin>,
SovereignSignedViaLocation<SovereignAccountOf, RuntimeOrigin>,
// A child parachain, natively expressed, has the `Parachain` origin.
ChildParachainAsNative<parachains_origin::Origin, Origin>,
ChildParachainAsNative<parachains_origin::Origin, RuntimeOrigin>,
// The AccountId32 location type can be expressed natively as a `Signed` origin.
SignedAccountId32AsNative<KusamaNetwork, Origin>,
SignedAccountId32AsNative<KusamaNetwork, RuntimeOrigin>,
// A system child parachain, expressed as a Superuser, converts to the `Root` origin.
ChildSystemParachainAsSuperuser<ParaId, Origin>,
ChildSystemParachainAsSuperuser<ParaId, RuntimeOrigin>,
);
parameter_types! {
@@ -158,7 +158,7 @@ parameter_types! {
/// Type to convert the council origin to a Plurality `MultiLocation` value.
pub type CouncilToPlurality = BackingToPlurality<
Origin,
RuntimeOrigin,
pallet_collective::Origin<Runtime, CouncilCollective>,
CouncilBodyId,
>;
@@ -170,7 +170,7 @@ pub type LocalOriginToLocation = (
// `Unit` body.
CouncilToPlurality,
// And a usual Signed origin to be used in XCM as a corresponding AccountId32
SignedToAccountId32<Origin, AccountId, KusamaNetwork>,
SignedToAccountId32<RuntimeOrigin, AccountId, KusamaNetwork>,
);
impl pallet_xcm::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
@@ -178,10 +178,10 @@ impl pallet_xcm::Config for Runtime {
// (safe the possibility of someone spamming the parachain if they're willing to pay the KSM to
// send from the Relay-chain), but it's useless until we bring in XCM v3 which will make
// `DescendOrigin` a bit more useful.
type SendXcmOrigin = xcm_builder::EnsureXcmOrigin<Origin, CouncilToPlurality>;
type SendXcmOrigin = xcm_builder::EnsureXcmOrigin<RuntimeOrigin, CouncilToPlurality>;
type XcmRouter = XcmRouter;
// Anyone can execute XCM messages locally.
type ExecuteXcmOrigin = xcm_builder::EnsureXcmOrigin<Origin, LocalOriginToLocation>;
type ExecuteXcmOrigin = xcm_builder::EnsureXcmOrigin<RuntimeOrigin, LocalOriginToLocation>;
type XcmExecuteFilter = Everything;
type XcmExecutor = xcm_executor::XcmExecutor<XcmConfig>;
// Anyone is able to use teleportation regardless of who they are and what they want to teleport.
@@ -191,7 +191,7 @@ impl pallet_xcm::Config for Runtime {
type XcmReserveTransferFilter = Everything;
type Weigher = FixedWeightBounds<BaseXcmWeight, RuntimeCall, MaxInstructions>;
type LocationInverter = LocationInverter<Ancestry>;
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type RuntimeCall = RuntimeCall;
const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 100;
type AdvertisedXcmVersion = pallet_xcm::CurrentXcmVersion;
polkadot/runtime/parachains/src/configuration/tests.rs
+91 -70
View File
@@ -15,7 +15,7 @@
// along with Polkadot. If not, see <http://www.gnu.org/licenses/>.
use super::*;
use crate::mock::{new_test_ext, Configuration, Origin, ParasShared, Test};
use crate::mock::{new_test_ext, Configuration, ParasShared, RuntimeOrigin, Test};
use frame_support::{assert_err, assert_ok};
fn on_new_session(session_index: SessionIndex) -> (HostConfiguration<u32>, HostConfiguration<u32>) {
@@ -48,7 +48,7 @@ fn initializer_on_new_session() {
new_test_ext(Default::default()).execute_with(|| {
let (prev_config, new_config) = on_new_session(1);
assert_eq!(prev_config, new_config);
assert_ok!(Configuration::set_validation_upgrade_delay(Origin::root(), 100));
assert_ok!(Configuration::set_validation_upgrade_delay(RuntimeOrigin::root(), 100));
let (prev_config, new_config) = on_new_session(2);
assert_eq!(prev_config, new_config);
@@ -67,7 +67,7 @@ fn config_changes_after_2_session_boundary() {
config.validation_upgrade_delay = 100;
assert!(old_config != config);
assert_ok!(Configuration::set_validation_upgrade_delay(Origin::root(), 100));
assert_ok!(Configuration::set_validation_upgrade_delay(RuntimeOrigin::root(), 100));
// Verify that the current configuration has not changed and that there is a scheduled
// change for the SESSION_DELAY sessions in advance.
@@ -96,8 +96,8 @@ fn consecutive_changes_within_one_session() {
config.validation_upgrade_cooldown = 100;
assert!(old_config != config);
assert_ok!(Configuration::set_validation_upgrade_delay(Origin::root(), 100));
assert_ok!(Configuration::set_validation_upgrade_cooldown(Origin::root(), 100));
assert_ok!(Configuration::set_validation_upgrade_delay(RuntimeOrigin::root(), 100));
assert_ok!(Configuration::set_validation_upgrade_cooldown(RuntimeOrigin::root(), 100));
assert_eq!(Configuration::config(), old_config);
assert_eq!(<Configuration as Store>::PendingConfigs::get(), vec![(2, config.clone())]);
@@ -125,7 +125,7 @@ fn pending_next_session_but_we_upgrade_once_more() {
..initial_config.clone()
};
assert_ok!(Configuration::set_validation_upgrade_delay(Origin::root(), 100));
assert_ok!(Configuration::set_validation_upgrade_delay(RuntimeOrigin::root(), 100));
assert_eq!(Configuration::config(), initial_config);
assert_eq!(
<Configuration as Store>::PendingConfigs::get(),
@@ -136,7 +136,7 @@ fn pending_next_session_but_we_upgrade_once_more() {
// We are still waiting until the pending configuration is applied and we add another
// update.
assert_ok!(Configuration::set_validation_upgrade_cooldown(Origin::root(), 99));
assert_ok!(Configuration::set_validation_upgrade_cooldown(RuntimeOrigin::root(), 99));
// This should result in yet another configiguration change scheduled.
assert_eq!(Configuration::config(), initial_config);
@@ -173,7 +173,7 @@ fn scheduled_session_config_update_while_next_session_pending() {
..initial_config.clone()
};
assert_ok!(Configuration::set_validation_upgrade_delay(Origin::root(), 100));
assert_ok!(Configuration::set_validation_upgrade_delay(RuntimeOrigin::root(), 100));
assert_eq!(Configuration::config(), initial_config);
assert_eq!(
<Configuration as Store>::PendingConfigs::get(),
@@ -184,8 +184,8 @@ fn scheduled_session_config_update_while_next_session_pending() {
// The second call should fall into the case where we already have a pending config
// update for the scheduled_session, but we want to update it once more.
assert_ok!(Configuration::set_validation_upgrade_cooldown(Origin::root(), 99));
assert_ok!(Configuration::set_code_retention_period(Origin::root(), 98));
assert_ok!(Configuration::set_validation_upgrade_cooldown(RuntimeOrigin::root(), 99));
assert_ok!(Configuration::set_code_retention_period(RuntimeOrigin::root(), 98));
// This should result in yet another configiguration change scheduled.
assert_eq!(Configuration::config(), initial_config);
@@ -213,30 +213,30 @@ fn scheduled_session_config_update_while_next_session_pending() {
fn invariants() {
new_test_ext(Default::default()).execute_with(|| {
assert_err!(
Configuration::set_max_code_size(Origin::root(), MAX_CODE_SIZE + 1),
Configuration::set_max_code_size(RuntimeOrigin::root(), MAX_CODE_SIZE + 1),
Error::<Test>::InvalidNewValue
);
assert_err!(
Configuration::set_max_pov_size(Origin::root(), MAX_POV_SIZE + 1),
Configuration::set_max_pov_size(RuntimeOrigin::root(), MAX_POV_SIZE + 1),
Error::<Test>::InvalidNewValue
);
assert_err!(
Configuration::set_max_head_data_size(Origin::root(), MAX_HEAD_DATA_SIZE + 1),
Configuration::set_max_head_data_size(RuntimeOrigin::root(), MAX_HEAD_DATA_SIZE + 1),
Error::<Test>::InvalidNewValue
);
assert_err!(
Configuration::set_chain_availability_period(Origin::root(), 0),
Configuration::set_chain_availability_period(RuntimeOrigin::root(), 0),
Error::<Test>::InvalidNewValue
);
assert_err!(
Configuration::set_thread_availability_period(Origin::root(), 0),
Configuration::set_thread_availability_period(RuntimeOrigin::root(), 0),
Error::<Test>::InvalidNewValue
);
assert_err!(
Configuration::set_no_show_slots(Origin::root(), 0),
Configuration::set_no_show_slots(RuntimeOrigin::root(), 0),
Error::<Test>::InvalidNewValue
);
@@ -247,20 +247,20 @@ fn invariants() {
..Default::default()
});
assert_err!(
Configuration::set_chain_availability_period(Origin::root(), 12),
Configuration::set_chain_availability_period(RuntimeOrigin::root(), 12),
Error::<Test>::InvalidNewValue
);
assert_err!(
Configuration::set_thread_availability_period(Origin::root(), 12),
Configuration::set_thread_availability_period(RuntimeOrigin::root(), 12),
Error::<Test>::InvalidNewValue
);
assert_err!(
Configuration::set_minimum_validation_upgrade_delay(Origin::root(), 9),
Configuration::set_minimum_validation_upgrade_delay(RuntimeOrigin::root(), 9),
Error::<Test>::InvalidNewValue
);
assert_err!(
Configuration::set_validation_upgrade_delay(Origin::root(), 0),
Configuration::set_validation_upgrade_delay(RuntimeOrigin::root(), 0),
Error::<Test>::InvalidNewValue
);
});
@@ -270,12 +270,12 @@ fn invariants() {
fn consistency_bypass_works() {
new_test_ext(Default::default()).execute_with(|| {
assert_err!(
Configuration::set_max_code_size(Origin::root(), MAX_CODE_SIZE + 1),
Configuration::set_max_code_size(RuntimeOrigin::root(), MAX_CODE_SIZE + 1),
Error::<Test>::InvalidNewValue
);
assert_ok!(Configuration::set_bypass_consistency_check(Origin::root(), true));
assert_ok!(Configuration::set_max_code_size(Origin::root(), MAX_CODE_SIZE + 1));
assert_ok!(Configuration::set_bypass_consistency_check(RuntimeOrigin::root(), true));
assert_ok!(Configuration::set_max_code_size(RuntimeOrigin::root(), MAX_CODE_SIZE + 1));
assert_eq!(
Configuration::config().max_code_size,
@@ -339,165 +339,186 @@ fn setting_pending_config_members() {
};
Configuration::set_validation_upgrade_cooldown(
Origin::root(),
RuntimeOrigin::root(),
new_config.validation_upgrade_cooldown,
)
.unwrap();
Configuration::set_validation_upgrade_delay(
Origin::root(),
RuntimeOrigin::root(),
new_config.validation_upgrade_delay,
)
.unwrap();
Configuration::set_code_retention_period(Origin::root(), new_config.code_retention_period)
Configuration::set_code_retention_period(
RuntimeOrigin::root(),
new_config.code_retention_period,
)
.unwrap();
Configuration::set_max_code_size(RuntimeOrigin::root(), new_config.max_code_size).unwrap();
Configuration::set_max_pov_size(RuntimeOrigin::root(), new_config.max_pov_size).unwrap();
Configuration::set_max_head_data_size(RuntimeOrigin::root(), new_config.max_head_data_size)
.unwrap();
Configuration::set_max_code_size(Origin::root(), new_config.max_code_size).unwrap();
Configuration::set_max_pov_size(Origin::root(), new_config.max_pov_size).unwrap();
Configuration::set_max_head_data_size(Origin::root(), new_config.max_head_data_size)
Configuration::set_parathread_cores(RuntimeOrigin::root(), new_config.parathread_cores)
.unwrap();
Configuration::set_parathread_cores(Origin::root(), new_config.parathread_cores).unwrap();
Configuration::set_parathread_retries(Origin::root(), new_config.parathread_retries)
Configuration::set_parathread_retries(RuntimeOrigin::root(), new_config.parathread_retries)
.unwrap();
Configuration::set_group_rotation_frequency(
Origin::root(),
RuntimeOrigin::root(),
new_config.group_rotation_frequency,
)
.unwrap();
// This comes out of order to satisfy the validity criteria for the chain and thread
// availability periods.
Configuration::set_minimum_validation_upgrade_delay(
Origin::root(),
RuntimeOrigin::root(),
new_config.minimum_validation_upgrade_delay,
)
.unwrap();
Configuration::set_chain_availability_period(
Origin::root(),
RuntimeOrigin::root(),
new_config.chain_availability_period,
)
.unwrap();
Configuration::set_thread_availability_period(
Origin::root(),
RuntimeOrigin::root(),
new_config.thread_availability_period,
)
.unwrap();
Configuration::set_scheduling_lookahead(Origin::root(), new_config.scheduling_lookahead)
.unwrap();
Configuration::set_scheduling_lookahead(
RuntimeOrigin::root(),
new_config.scheduling_lookahead,
)
.unwrap();
Configuration::set_max_validators_per_core(
Origin::root(),
RuntimeOrigin::root(),
new_config.max_validators_per_core,
)
.unwrap();
Configuration::set_max_validators(Origin::root(), new_config.max_validators).unwrap();
Configuration::set_dispute_period(Origin::root(), new_config.dispute_period).unwrap();
Configuration::set_max_validators(RuntimeOrigin::root(), new_config.max_validators)
.unwrap();
Configuration::set_dispute_period(RuntimeOrigin::root(), new_config.dispute_period)
.unwrap();
Configuration::set_dispute_post_conclusion_acceptance_period(
Origin::root(),
RuntimeOrigin::root(),
new_config.dispute_post_conclusion_acceptance_period,
)
.unwrap();
Configuration::set_dispute_max_spam_slots(
Origin::root(),
RuntimeOrigin::root(),
new_config.dispute_max_spam_slots,
)
.unwrap();
Configuration::set_dispute_conclusion_by_time_out_period(
Origin::root(),
RuntimeOrigin::root(),
new_config.dispute_conclusion_by_time_out_period,
)
.unwrap();
Configuration::set_no_show_slots(Origin::root(), new_config.no_show_slots).unwrap();
Configuration::set_n_delay_tranches(Origin::root(), new_config.n_delay_tranches).unwrap();
Configuration::set_no_show_slots(RuntimeOrigin::root(), new_config.no_show_slots).unwrap();
Configuration::set_n_delay_tranches(RuntimeOrigin::root(), new_config.n_delay_tranches)
.unwrap();
Configuration::set_zeroth_delay_tranche_width(
Origin::root(),
RuntimeOrigin::root(),
new_config.zeroth_delay_tranche_width,
)
.unwrap();
Configuration::set_needed_approvals(Origin::root(), new_config.needed_approvals).unwrap();
Configuration::set_needed_approvals(RuntimeOrigin::root(), new_config.needed_approvals)
.unwrap();
Configuration::set_relay_vrf_modulo_samples(
Origin::root(),
RuntimeOrigin::root(),
new_config.relay_vrf_modulo_samples,
)
.unwrap();
Configuration::set_max_upward_queue_count(
Origin::root(),
RuntimeOrigin::root(),
new_config.max_upward_queue_count,
)
.unwrap();
Configuration::set_max_upward_queue_size(Origin::root(), new_config.max_upward_queue_size)
.unwrap();
Configuration::set_max_upward_queue_size(
RuntimeOrigin::root(),
new_config.max_upward_queue_size,
)
.unwrap();
Configuration::set_max_downward_message_size(
Origin::root(),
RuntimeOrigin::root(),
new_config.max_downward_message_size,
)
.unwrap();
Configuration::set_ump_service_total_weight(
Origin::root(),
RuntimeOrigin::root(),
new_config.ump_service_total_weight,
)
.unwrap();
Configuration::set_max_upward_message_size(
Origin::root(),
RuntimeOrigin::root(),
new_config.max_upward_message_size,
)
.unwrap();
Configuration::set_max_upward_message_num_per_candidate(
Origin::root(),
RuntimeOrigin::root(),
new_config.max_upward_message_num_per_candidate,
)
.unwrap();
Configuration::set_hrmp_sender_deposit(Origin::root(), new_config.hrmp_sender_deposit)
.unwrap();
Configuration::set_hrmp_sender_deposit(
RuntimeOrigin::root(),
new_config.hrmp_sender_deposit,
)
.unwrap();
Configuration::set_hrmp_recipient_deposit(
Origin::root(),
RuntimeOrigin::root(),
new_config.hrmp_recipient_deposit,
)
.unwrap();
Configuration::set_hrmp_channel_max_capacity(
Origin::root(),
RuntimeOrigin::root(),
new_config.hrmp_channel_max_capacity,
)
.unwrap();
Configuration::set_hrmp_channel_max_total_size(
Origin::root(),
RuntimeOrigin::root(),
new_config.hrmp_channel_max_total_size,
)
.unwrap();
Configuration::set_hrmp_max_parachain_inbound_channels(
Origin::root(),
RuntimeOrigin::root(),
new_config.hrmp_max_parachain_inbound_channels,
)
.unwrap();
Configuration::set_hrmp_max_parathread_inbound_channels(
Origin::root(),
RuntimeOrigin::root(),
new_config.hrmp_max_parathread_inbound_channels,
)
.unwrap();
Configuration::set_hrmp_channel_max_message_size(
Origin::root(),
RuntimeOrigin::root(),
new_config.hrmp_channel_max_message_size,
)
.unwrap();
Configuration::set_hrmp_max_parachain_outbound_channels(
Origin::root(),
RuntimeOrigin::root(),
new_config.hrmp_max_parachain_outbound_channels,
)
.unwrap();
Configuration::set_hrmp_max_parathread_outbound_channels(
Origin::root(),
RuntimeOrigin::root(),
new_config.hrmp_max_parathread_outbound_channels,
)
.unwrap();
Configuration::set_hrmp_max_message_num_per_candidate(
Origin::root(),
RuntimeOrigin::root(),
new_config.hrmp_max_message_num_per_candidate,
)
.unwrap();
Configuration::set_ump_max_individual_weight(
Origin::root(),
RuntimeOrigin::root(),
new_config.ump_max_individual_weight,
)
.unwrap();
Configuration::set_pvf_checking_enabled(Origin::root(), new_config.pvf_checking_enabled)
Configuration::set_pvf_checking_enabled(
RuntimeOrigin::root(),
new_config.pvf_checking_enabled,
)
.unwrap();
Configuration::set_pvf_voting_ttl(RuntimeOrigin::root(), new_config.pvf_voting_ttl)
.unwrap();
Configuration::set_pvf_voting_ttl(Origin::root(), new_config.pvf_voting_ttl).unwrap();
assert_eq!(
<Configuration as Store>::PendingConfigs::get(),
@@ -509,7 +530,7 @@ fn setting_pending_config_members() {
#[test]
fn non_root_cannot_set_config() {
new_test_ext(Default::default()).execute_with(|| {
assert!(Configuration::set_validation_upgrade_delay(Origin::signed(1), 100).is_err());
assert!(Configuration::set_validation_upgrade_delay(RuntimeOrigin::signed(1), 100).is_err());
});
}
polkadot/runtime/parachains/src/hrmp.rs
+7 -7
View File
@@ -241,9 +241,9 @@ pub mod pallet {
/// The outer event type.
type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
type Origin: From<crate::Origin>
+ From<<Self as frame_system::Config>::Origin>
+ Into<Result<crate::Origin, <Self as Config>::Origin>>;
type RuntimeOrigin: From<crate::Origin>
+ From<<Self as frame_system::Config>::RuntimeOrigin>
+ Into<Result<crate::Origin, <Self as Config>::RuntimeOrigin>>;
/// An interface for reserving deposits for opening channels.
///
@@ -465,7 +465,7 @@ pub mod pallet {
proposed_max_capacity: u32,
proposed_max_message_size: u32,
) -> DispatchResult {
let origin = ensure_parachain(<T as Config>::Origin::from(origin))?;
let origin = ensure_parachain(<T as Config>::RuntimeOrigin::from(origin))?;
Self::init_open_channel(
origin,
recipient,
@@ -486,7 +486,7 @@ pub mod pallet {
/// The channel will be opened only on the next session boundary.
#[pallet::weight(<T as Config>::WeightInfo::hrmp_accept_open_channel())]
pub fn hrmp_accept_open_channel(origin: OriginFor<T>, sender: ParaId) -> DispatchResult {
let origin = ensure_parachain(<T as Config>::Origin::from(origin))?;
let origin = ensure_parachain(<T as Config>::RuntimeOrigin::from(origin))?;
Self::accept_open_channel(origin, sender)?;
Self::deposit_event(Event::OpenChannelAccepted(sender, origin));
Ok(())
@@ -501,7 +501,7 @@ pub mod pallet {
origin: OriginFor<T>,
channel_id: HrmpChannelId,
) -> DispatchResult {
let origin = ensure_parachain(<T as Config>::Origin::from(origin))?;
let origin = ensure_parachain(<T as Config>::RuntimeOrigin::from(origin))?;
Self::close_channel(origin, channel_id.clone())?;
Self::deposit_event(Event::ChannelClosed(origin, channel_id));
Ok(())
@@ -567,7 +567,7 @@ pub mod pallet {
channel_id: HrmpChannelId,
open_requests: u32,
) -> DispatchResult {
let origin = ensure_parachain(<T as Config>::Origin::from(origin))?;
let origin = ensure_parachain(<T as Config>::RuntimeOrigin::from(origin))?;
ensure!(
<Self as Store>::HrmpOpenChannelRequestsList::decode_len().unwrap_or_default()
as u32 <= open_requests,
polkadot/runtime/parachains/src/hrmp/benchmarking.rs
+2 -2
View File
@@ -66,7 +66,7 @@ fn establish_para_connection<T: Config>(
until: ParachainSetupStep,
) -> [(ParaId, crate::Origin); 2]
where
<T as frame_system::Config>::Origin: From<crate::Origin>,
<T as frame_system::Config>::RuntimeOrigin: From<crate::Origin>,
{
let config = Configuration::<T>::config();
let deposit: BalanceOf<T> = config.hrmp_sender_deposit.unique_saturated_into();
@@ -138,7 +138,7 @@ static_assertions::const_assert!(HRMP_MAX_INBOUND_CHANNELS_BOUND < PREFIX_0);
static_assertions::const_assert!(HRMP_MAX_OUTBOUND_CHANNELS_BOUND < PREFIX_0);
frame_benchmarking::benchmarks! {
where_clause { where <T as frame_system::Config>::Origin: From<crate::Origin> }
where_clause { where <T as frame_system::Config>::RuntimeOrigin: From<crate::Origin> }
hrmp_init_open_channel {
let sender_id: ParaId = 1u32.into();
polkadot/runtime/parachains/src/initializer.rs
+1 -1
View File
@@ -120,7 +120,7 @@ pub mod pallet {
/// A randomness beacon.
type Randomness: Randomness<Self::Hash, Self::BlockNumber>;
/// An origin which is allowed to force updates to parachains.
type ForceOrigin: EnsureOrigin<<Self as frame_system::Config>::Origin>;
type ForceOrigin: EnsureOrigin<<Self as frame_system::Config>::RuntimeOrigin>;
/// Weight information for extrinsics in this pallet.
type WeightInfo: WeightInfo;
}
polkadot/runtime/parachains/src/mock.rs
+2 -2
View File
@@ -92,7 +92,7 @@ impl frame_system::Config for Test {
type BlockWeights = BlockWeights;
type BlockLength = ();
type DbWeight = ();
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type RuntimeCall = RuntimeCall;
type Index = u64;
type BlockNumber = BlockNumber;
@@ -234,8 +234,8 @@ impl crate::ump::Config for Test {
}
impl crate::hrmp::Config for Test {
type RuntimeOrigin = RuntimeOrigin;
type RuntimeEvent = RuntimeEvent;
type Origin = Origin;
type Currency = pallet_balances::Pallet<Test>;
type WeightInfo = crate::hrmp::TestWeightInfo;
}
polkadot/runtime/parachains/src/paras/tests.rs
+40 -12
View File
@@ -26,7 +26,8 @@ use test_helpers::{dummy_head_data, dummy_validation_code};
use crate::{
configuration::HostConfiguration,
mock::{
new_test_ext, Configuration, MockGenesisConfig, Origin, Paras, ParasShared, System, Test,
new_test_ext, Configuration, MockGenesisConfig, Paras, ParasShared, RuntimeOrigin, System,
Test,
},
};
@@ -1449,7 +1450,10 @@ fn add_trusted_validation_code_inserts_with_no_users() {
// with the reference count equal to 0.
let validation_code = ValidationCode(vec![1, 2, 3]);
new_test_ext(Default::default()).execute_with(|| {
assert_ok!(Paras::add_trusted_validation_code(Origin::root(), validation_code.clone()));
assert_ok!(Paras::add_trusted_validation_code(
RuntimeOrigin::root(),
validation_code.clone()
));
assert_eq!(<Paras as Store>::CodeByHashRefs::get(&validation_code.hash()), 0,);
});
}
@@ -1460,9 +1464,15 @@ fn add_trusted_validation_code_idempotent() {
// parameters is a no-op.
let validation_code = ValidationCode(vec![1, 2, 3]);
new_test_ext(Default::default()).execute_with(|| {
assert_ok!(Paras::add_trusted_validation_code(Origin::root(), validation_code.clone()));
assert_ok!(Paras::add_trusted_validation_code(
RuntimeOrigin::root(),
validation_code.clone()
));
assert_storage_noop!({
assert_ok!(Paras::add_trusted_validation_code(Origin::root(), validation_code.clone()));
assert_ok!(Paras::add_trusted_validation_code(
RuntimeOrigin::root(),
validation_code.clone()
));
});
});
}
@@ -1473,8 +1483,14 @@ fn poke_unused_validation_code_removes_code_cleanly() {
// in the storage but has no users will remove it cleanly from the storage.
let validation_code = ValidationCode(vec![1, 2, 3]);
new_test_ext(Default::default()).execute_with(|| {
assert_ok!(Paras::add_trusted_validation_code(Origin::root(), validation_code.clone()));
assert_ok!(Paras::poke_unused_validation_code(Origin::root(), validation_code.hash()));
assert_ok!(Paras::add_trusted_validation_code(
RuntimeOrigin::root(),
validation_code.clone()
));
assert_ok!(Paras::poke_unused_validation_code(
RuntimeOrigin::root(),
validation_code.hash()
));
assert_eq!(<Paras as Store>::CodeByHashRefs::get(&validation_code.hash()), 0);
assert!(!<Paras as Store>::CodeByHash::contains_key(&validation_code.hash()));
@@ -1487,7 +1503,10 @@ fn poke_unused_validation_code_doesnt_remove_code_with_users() {
let validation_code = ValidationCode(vec![1, 2, 3]);
new_test_ext(Default::default()).execute_with(|| {
// First we add the code to the storage.
assert_ok!(Paras::add_trusted_validation_code(Origin::root(), validation_code.clone()));
assert_ok!(Paras::add_trusted_validation_code(
RuntimeOrigin::root(),
validation_code.clone()
));
// Then we add a user to the code, say by upgrading.
run_to_block(2, None);
@@ -1496,7 +1515,10 @@ fn poke_unused_validation_code_doesnt_remove_code_with_users() {
// Finally we poke the code, which should not remove it from the storage.
assert_storage_noop!({
assert_ok!(Paras::poke_unused_validation_code(Origin::root(), validation_code.hash()));
assert_ok!(Paras::poke_unused_validation_code(
RuntimeOrigin::root(),
validation_code.hash()
));
});
check_code_is_stored(&validation_code);
});
@@ -1511,7 +1533,7 @@ fn increase_code_ref_doesnt_have_allergy_on_add_trusted_validation_code() {
let code = ValidationCode(vec![1, 2, 3]);
new_test_ext(Default::default()).execute_with(|| {
assert_ok!(Paras::add_trusted_validation_code(Origin::root(), code.clone()));
assert_ok!(Paras::add_trusted_validation_code(RuntimeOrigin::root(), code.clone()));
Paras::increase_code_ref(&code.hash(), &code);
Paras::increase_code_ref(&code.hash(), &code);
assert!(<Paras as Store>::CodeByHash::contains_key(code.hash()));
@@ -1519,7 +1541,7 @@ fn increase_code_ref_doesnt_have_allergy_on_add_trusted_validation_code() {
});
new_test_ext(Default::default()).execute_with(|| {
assert_ok!(Paras::add_trusted_validation_code(Origin::root(), code.clone()));
assert_ok!(Paras::add_trusted_validation_code(RuntimeOrigin::root(), code.clone()));
Paras::decrease_code_ref(&code.hash());
assert!(<Paras as Store>::CodeByHash::contains_key(code.hash()));
assert_eq!(<Paras as Store>::CodeByHashRefs::get(code.hash()), 0);
@@ -1547,7 +1569,10 @@ fn add_trusted_validation_code_insta_approval() {
..Default::default()
};
new_test_ext(genesis_config).execute_with(|| {
assert_ok!(Paras::add_trusted_validation_code(Origin::root(), validation_code.clone()));
assert_ok!(Paras::add_trusted_validation_code(
RuntimeOrigin::root(),
validation_code.clone()
));
// Then some parachain upgrades it's code with the relay-parent 1.
run_to_block(2, None);
@@ -1602,7 +1627,10 @@ fn add_trusted_validation_code_enacts_existing_pvf_vote() {
assert!(<Paras as Store>::PvfActiveVoteMap::contains_key(&validation_code.hash()));
// Then we add a trusted validation code. That should conclude the vote.
assert_ok!(Paras::add_trusted_validation_code(Origin::root(), validation_code.clone()));
assert_ok!(Paras::add_trusted_validation_code(
RuntimeOrigin::root(),
validation_code.clone()
));
assert!(<Paras as Store>::FutureCodeUpgrades::get(&para_id).is_some());
assert!(!<Paras as Store>::PvfActiveVoteMap::contains_key(&validation_code.hash()));
});
polkadot/runtime/parachains/src/session_info/tests.rs
+5 -5
View File
@@ -19,8 +19,8 @@ use crate::{
configuration::HostConfiguration,
initializer::SessionChangeNotification,
mock::{
new_test_ext, Configuration, MockGenesisConfig, Origin, ParasShared, SessionInfo, System,
Test,
new_test_ext, Configuration, MockGenesisConfig, ParasShared, RuntimeOrigin, SessionInfo,
System, Test,
},
util::take_active_subset,
};
@@ -109,7 +109,7 @@ fn session_pruning_is_based_on_dispute_period() {
// changing `dispute_period` works
let dispute_period = 5;
Configuration::set_dispute_period(Origin::root(), dispute_period).unwrap();
Configuration::set_dispute_period(RuntimeOrigin::root(), dispute_period).unwrap();
// Dispute period does not automatically change
let config = Configuration::config();
@@ -124,7 +124,7 @@ fn session_pruning_is_based_on_dispute_period() {
// Increase dispute period even more
let new_dispute_period = 16;
Configuration::set_dispute_period(Origin::root(), new_dispute_period).unwrap();
Configuration::set_dispute_period(RuntimeOrigin::root(), new_dispute_period).unwrap();
run_to_block(210, session_changes);
assert_eq!(EarliestStoredSession::<Test>::get(), 21 - dispute_period);
@@ -154,7 +154,7 @@ fn session_info_is_based_on_config() {
assert_eq!(session.needed_approvals, 3);
// change some param
Configuration::set_needed_approvals(Origin::root(), 42).unwrap();
Configuration::set_needed_approvals(RuntimeOrigin::root(), 42).unwrap();
// 2 sessions later
run_to_block(3, new_session_every_block);
let session = Sessions::<Test>::get(&3).unwrap();
polkadot/runtime/parachains/src/ump.rs
+1 -1
View File
@@ -234,7 +234,7 @@ pub mod pallet {
type FirstMessageFactorPercent: Get<u64>;
/// Origin which is allowed to execute overweight messages.
type ExecuteOverweightOrigin: EnsureOrigin<Self::Origin>;
type ExecuteOverweightOrigin: EnsureOrigin<Self::RuntimeOrigin>;
/// Weight information for extrinsics in this pallet.
type WeightInfo: WeightInfo;
polkadot/runtime/parachains/src/ump/tests.rs
+6 -6
View File
@@ -16,8 +16,8 @@
use super::*;
use crate::mock::{
assert_last_event, new_test_ext, take_processed, Configuration, MockGenesisConfig, Origin,
System, Test, Ump,
assert_last_event, new_test_ext, take_processed, Configuration, MockGenesisConfig,
RuntimeOrigin, System, Test, Ump,
};
use frame_support::{assert_noop, assert_ok, weights::Weight};
use std::collections::HashSet;
@@ -296,7 +296,7 @@ fn service_overweight_unknown() {
// the next test.
new_test_ext(GenesisConfigBuilder::default().build()).execute_with(|| {
assert_noop!(
Ump::service_overweight(Origin::root(), 0, Weight::from_ref_time(1000)),
Ump::service_overweight(RuntimeOrigin::root(), 0, Weight::from_ref_time(1000)),
Error::<Test>::UnknownMessageIndex
);
});
@@ -346,18 +346,18 @@ fn overweight_queue_works() {
// Now verify that if we wanted to service this overweight message with less than enough
// weight it will fail.
assert_noop!(
Ump::service_overweight(Origin::root(), 0, Weight::from_ref_time(499)),
Ump::service_overweight(RuntimeOrigin::root(), 0, Weight::from_ref_time(499)),
Error::<Test>::WeightOverLimit
);
// ... and if we try to service it with just enough weight it will succeed as well.
assert_ok!(Ump::service_overweight(Origin::root(), 0, Weight::from_ref_time(500)));
assert_ok!(Ump::service_overweight(RuntimeOrigin::root(), 0, Weight::from_ref_time(500)));
assert_last_event(Event::OverweightServiced(0, Weight::from_ref_time(500)).into());
// ... and if we try to service a message with index that doesn't exist it will error
// out.
assert_noop!(
Ump::service_overweight(Origin::root(), 1, Weight::from_ref_time(1000)),
Ump::service_overweight(RuntimeOrigin::root(), 1, Weight::from_ref_time(1000)),
Error::<Test>::UnknownMessageIndex
);
});
polkadot/runtime/polkadot/src/lib.rs
+6 -6
View File
@@ -147,7 +147,7 @@ impl frame_system::Config for Runtime {
type BaseCallFilter = frame_support::traits::Everything;
type BlockWeights = BlockWeights;
type BlockLength = BlockLength;
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type RuntimeCall = RuntimeCall;
type Index = Nonce;
type BlockNumber = BlockNumber;
@@ -206,8 +206,8 @@ impl PrivilegeCmp<OriginCaller> for OriginPrivilegeCmp {
}
impl pallet_scheduler::Config for Runtime {
type RuntimeOrigin = RuntimeOrigin;
type RuntimeEvent = RuntimeEvent;
type Origin = Origin;
type PalletsOrigin = OriginCaller;
type RuntimeCall = RuntimeCall;
type MaximumWeight = MaximumSchedulerWeight;
@@ -673,7 +673,7 @@ parameter_types! {
pub type CouncilCollective = pallet_collective::Instance1;
impl pallet_collective::Config<CouncilCollective> for Runtime {
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type Proposal = RuntimeCall;
type RuntimeEvent = RuntimeEvent;
type MotionDuration = CouncilMotionDuration;
@@ -729,7 +729,7 @@ parameter_types! {
pub type TechnicalCollective = pallet_collective::Instance2;
impl pallet_collective::Config<TechnicalCollective> for Runtime {
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type Proposal = RuntimeCall;
type RuntimeEvent = RuntimeEvent;
type MotionDuration = TechnicalMotionDuration;
@@ -1239,8 +1239,8 @@ impl parachains_ump::Config for Runtime {
impl parachains_dmp::Config for Runtime {}
impl parachains_hrmp::Config for Runtime {
type RuntimeOrigin = RuntimeOrigin;
type RuntimeEvent = RuntimeEvent;
type Origin = Origin;
type Currency = Balances;
type WeightInfo = weights::runtime_parachains_hrmp::WeightInfo<Self>;
}
@@ -1272,8 +1272,8 @@ parameter_types! {
}
impl paras_registrar::Config for Runtime {
type RuntimeOrigin = RuntimeOrigin;
type RuntimeEvent = RuntimeEvent;
type Origin = Origin;
type Currency = Balances;
type OnSwap = (Crowdloan, Slots);
type ParaDeposit = ParaDeposit;
polkadot/runtime/polkadot/src/xcm_config.rs
+10 -10
View File
@@ -17,8 +17,8 @@
//! XCM configuration for Polkadot.
use super::{
parachains_origin, AccountId, Balances, CouncilCollective, Origin, ParaId, Runtime,
RuntimeCall, RuntimeEvent, WeightToFee, XcmPallet,
parachains_origin, AccountId, Balances, CouncilCollective, ParaId, Runtime, RuntimeCall,
RuntimeEvent, RuntimeOrigin, WeightToFee, XcmPallet,
};
use frame_support::{
match_types, parameter_types,
@@ -80,13 +80,13 @@ pub type LocalAssetTransactor = XcmCurrencyAdapter<
type LocalOriginConverter = (
// If the origin kind is `Sovereign`, then return a `Signed` origin with the account determined
// by the `SovereignAccountOf` converter.
SovereignSignedViaLocation<SovereignAccountOf, Origin>,
SovereignSignedViaLocation<SovereignAccountOf, RuntimeOrigin>,
// If the origin kind is `Native` and the XCM origin is a child parachain, then we can express
// it with the special `parachains_origin::Origin` origin variant.
ChildParachainAsNative<parachains_origin::Origin, Origin>,
ChildParachainAsNative<parachains_origin::Origin, RuntimeOrigin>,
// If the origin kind is `Native` and the XCM origin is the `AccountId32` location, then it can
// be expressed using the `Signed` origin variant.
SignedAccountId32AsNative<PolkadotNetwork, Origin>,
SignedAccountId32AsNative<PolkadotNetwork, RuntimeOrigin>,
);
parameter_types! {
@@ -158,7 +158,7 @@ parameter_types! {
/// Type to convert a council origin to a Plurality `MultiLocation` value.
pub type CouncilToPlurality = BackingToPlurality<
Origin,
RuntimeOrigin,
pallet_collective::Origin<Runtime, CouncilCollective>,
CouncilBodyId,
>;
@@ -170,16 +170,16 @@ pub type LocalOriginToLocation = (
// `Unit` body.
CouncilToPlurality,
// And a usual Signed origin to be used in XCM as a corresponding AccountId32
SignedToAccountId32<Origin, AccountId, PolkadotNetwork>,
SignedToAccountId32<RuntimeOrigin, AccountId, PolkadotNetwork>,
);
impl pallet_xcm::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
// Only allow the council to send messages.
type SendXcmOrigin = xcm_builder::EnsureXcmOrigin<Origin, CouncilToPlurality>;
type SendXcmOrigin = xcm_builder::EnsureXcmOrigin<RuntimeOrigin, CouncilToPlurality>;
type XcmRouter = XcmRouter;
// Anyone can execute XCM messages locally...
type ExecuteXcmOrigin = xcm_builder::EnsureXcmOrigin<Origin, LocalOriginToLocation>;
type ExecuteXcmOrigin = xcm_builder::EnsureXcmOrigin<RuntimeOrigin, LocalOriginToLocation>;
// ...but they must match our filter, which rejects all.
type XcmExecuteFilter = Nothing; // == Deny All
type XcmExecutor = xcm_executor::XcmExecutor<XcmConfig>;
@@ -187,7 +187,7 @@ impl pallet_xcm::Config for Runtime {
type XcmReserveTransferFilter = Everything; // == Allow All
type Weigher = FixedWeightBounds<BaseXcmWeight, RuntimeCall, MaxInstructions>;
type LocationInverter = LocationInverter<Ancestry>;
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type RuntimeCall = RuntimeCall;
const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 100;
type AdvertisedXcmVersion = AdvertisedXcmVersion;
polkadot/runtime/rococo/src/lib.rs
+6 -6
View File
@@ -149,7 +149,7 @@ impl frame_system::Config for Runtime {
type BlockWeights = BlockWeights;
type BlockLength = BlockLength;
type DbWeight = RocksDbWeight;
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type RuntimeCall = RuntimeCall;
type Index = Nonce;
type BlockNumber = BlockNumber;
@@ -207,8 +207,8 @@ impl PrivilegeCmp<OriginCaller> for OriginPrivilegeCmp {
}
impl pallet_scheduler::Config for Runtime {
type RuntimeOrigin = RuntimeOrigin;
type RuntimeEvent = RuntimeEvent;
type Origin = Origin;
type PalletsOrigin = OriginCaller;
type RuntimeCall = RuntimeCall;
type MaximumWeight = MaximumSchedulerWeight;
@@ -459,7 +459,7 @@ parameter_types! {
type CouncilCollective = pallet_collective::Instance1;
impl pallet_collective::Config<CouncilCollective> for Runtime {
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type Proposal = RuntimeCall;
type RuntimeEvent = RuntimeEvent;
type MotionDuration = CouncilMotionDuration;
@@ -515,7 +515,7 @@ parameter_types! {
type TechnicalCollective = pallet_collective::Instance2;
impl pallet_collective::Config<TechnicalCollective> for Runtime {
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type Proposal = RuntimeCall;
type RuntimeEvent = RuntimeEvent;
type MotionDuration = TechnicalMotionDuration;
@@ -1071,8 +1071,8 @@ impl parachains_ump::Config for Runtime {
impl parachains_dmp::Config for Runtime {}
impl parachains_hrmp::Config for Runtime {
type RuntimeOrigin = RuntimeOrigin;
type RuntimeEvent = RuntimeEvent;
type Origin = Origin;
type Currency = Balances;
type WeightInfo = weights::runtime_parachains_hrmp::WeightInfo<Runtime>;
}
@@ -1118,8 +1118,8 @@ parameter_types! {
}
impl paras_registrar::Config for Runtime {
type RuntimeOrigin = RuntimeOrigin;
type RuntimeEvent = RuntimeEvent;
type Origin = Origin;
type Currency = Balances;
type OnSwap = (Crowdloan, Slots);
type ParaDeposit = ParaDeposit;
polkadot/runtime/rococo/src/validator_manager.rs
+1 -1
View File
@@ -40,7 +40,7 @@ pub mod pallet {
type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
/// Privileged origin that can add or remove validators.
type PrivilegedOrigin: EnsureOrigin<<Self as frame_system::Config>::Origin>;
type PrivilegedOrigin: EnsureOrigin<<Self as frame_system::Config>::RuntimeOrigin>;
}
#[pallet::event]
polkadot/runtime/rococo/src/xcm_config.rs
+11 -11
View File
@@ -17,8 +17,8 @@
//! XCM configuration for Rococo.
use super::{
parachains_origin, AccountId, Balances, CouncilCollective, Origin, ParaId, Runtime,
RuntimeCall, RuntimeEvent, WeightToFee, XcmPallet,
parachains_origin, AccountId, Balances, CouncilCollective, ParaId, Runtime, RuntimeCall,
RuntimeEvent, RuntimeOrigin, WeightToFee, XcmPallet,
};
use frame_support::{match_types, parameter_types, traits::Everything};
use runtime_common::{xcm_sender, ToAuthor};
@@ -76,13 +76,13 @@ pub type LocalAssetTransactor = XcmCurrencyAdapter<
/// The means that we convert an the XCM message origin location into a local dispatch origin.
type LocalOriginConverter = (
// A `Signed` origin of the sovereign account that the original location controls.
SovereignSignedViaLocation<SovereignAccountOf, Origin>,
SovereignSignedViaLocation<SovereignAccountOf, RuntimeOrigin>,
// A child parachain, natively expressed, has the `Parachain` origin.
ChildParachainAsNative<parachains_origin::Origin, Origin>,
ChildParachainAsNative<parachains_origin::Origin, RuntimeOrigin>,
// The AccountId32 location type can be expressed natively as a `Signed` origin.
SignedAccountId32AsNative<RococoNetwork, Origin>,
SignedAccountId32AsNative<RococoNetwork, RuntimeOrigin>,
// A system child parachain, expressed as a Superuser, converts to the `Root` origin.
ChildSystemParachainAsSuperuser<ParaId, Origin>,
ChildSystemParachainAsSuperuser<ParaId, RuntimeOrigin>,
);
parameter_types! {
@@ -176,7 +176,7 @@ parameter_types! {
/// Type to convert the council origin to a Plurality `MultiLocation` value.
pub type CouncilToPlurality = BackingToPlurality<
Origin,
RuntimeOrigin,
pallet_collective::Origin<Runtime, CouncilCollective>,
CouncilBodyId,
>;
@@ -188,14 +188,14 @@ pub type LocalOriginToLocation = (
// `Unit` body.
CouncilToPlurality,
// And a usual Signed origin to be used in XCM as a corresponding AccountId32
SignedToAccountId32<Origin, AccountId, RococoNetwork>,
SignedToAccountId32<RuntimeOrigin, AccountId, RococoNetwork>,
);
impl pallet_xcm::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type SendXcmOrigin = xcm_builder::EnsureXcmOrigin<Origin, LocalOriginToLocation>;
type SendXcmOrigin = xcm_builder::EnsureXcmOrigin<RuntimeOrigin, LocalOriginToLocation>;
type XcmRouter = XcmRouter;
// Anyone can execute XCM messages locally.
type ExecuteXcmOrigin = xcm_builder::EnsureXcmOrigin<Origin, LocalOriginToLocation>;
type ExecuteXcmOrigin = xcm_builder::EnsureXcmOrigin<RuntimeOrigin, LocalOriginToLocation>;
type XcmExecuteFilter = Everything;
type XcmExecutor = xcm_executor::XcmExecutor<XcmConfig>;
// Anyone is able to use teleportation regardless of who they are and what they want to teleport.
@@ -205,7 +205,7 @@ impl pallet_xcm::Config for Runtime {
type XcmReserveTransferFilter = Everything;
type Weigher = FixedWeightBounds<BaseXcmWeight, RuntimeCall, MaxInstructions>;
type LocationInverter = LocationInverter<Ancestry>;
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type RuntimeCall = RuntimeCall;
const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 100;
type AdvertisedXcmVersion = pallet_xcm::CurrentXcmVersion;
polkadot/runtime/test-runtime/src/lib.rs
+11 -10
View File
@@ -135,7 +135,7 @@ impl frame_system::Config for Runtime {
type BlockWeights = BlockWeights;
type BlockLength = BlockLength;
type DbWeight = ();
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type RuntimeCall = RuntimeCall;
type Index = Nonce;
type BlockNumber = BlockNumber;
@@ -534,30 +534,31 @@ parameter_types! {
pub const MaxInstructions: u32 = 100;
}
pub type LocalOriginToLocation = xcm_builder::SignedToAccountId32<Origin, AccountId, AnyNetwork>;
pub type LocalOriginToLocation =
xcm_builder::SignedToAccountId32<RuntimeOrigin, AccountId, AnyNetwork>;
impl pallet_xcm::Config for Runtime {
// The config types here are entirely configurable, since the only one that is sorely needed
// is `XcmExecutor`, which will be used in unit tests located in xcm-executor.
type RuntimeEvent = RuntimeEvent;
type ExecuteXcmOrigin = xcm_builder::EnsureXcmOrigin<Origin, LocalOriginToLocation>;
type ExecuteXcmOrigin = xcm_builder::EnsureXcmOrigin<RuntimeOrigin, LocalOriginToLocation>;
type LocationInverter = xcm_config::InvertNothing;
type SendXcmOrigin = xcm_builder::EnsureXcmOrigin<Origin, LocalOriginToLocation>;
type SendXcmOrigin = xcm_builder::EnsureXcmOrigin<RuntimeOrigin, LocalOriginToLocation>;
type Weigher = xcm_builder::FixedWeightBounds<BaseXcmWeight, RuntimeCall, MaxInstructions>;
type XcmRouter = xcm_config::DoNothingRouter;
type XcmExecuteFilter = Everything;
type XcmExecutor = xcm_executor::XcmExecutor<xcm_config::XcmConfig>;
type XcmTeleportFilter = Everything;
type XcmReserveTransferFilter = Everything;
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type RuntimeCall = RuntimeCall;
const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 100;
type AdvertisedXcmVersion = pallet_xcm::CurrentXcmVersion;
}
impl parachains_hrmp::Config for Runtime {
type RuntimeOrigin = RuntimeOrigin;
type RuntimeEvent = RuntimeEvent;
type Origin = Origin;
type Currency = Balances;
type WeightInfo = parachains_hrmp::TestWeightInfo;
}
@@ -570,7 +571,7 @@ impl parachains_origin::Config for Runtime {}
impl pallet_test_notifier::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type RuntimeCall = RuntimeCall;
}
@@ -589,8 +590,8 @@ pub mod pallet_test_notifier {
#[pallet::config]
pub trait Config: frame_system::Config + pallet_xcm::Config {
type RuntimeEvent: IsType<<Self as frame_system::Config>::RuntimeEvent> + From<Event<Self>>;
type Origin: IsType<<Self as frame_system::Config>::Origin>
+ Into<Result<pallet_xcm::Origin, <Self as Config>::Origin>>;
type RuntimeOrigin: IsType<<Self as frame_system::Config>::RuntimeOrigin>
+ Into<Result<pallet_xcm::Origin, <Self as Config>::RuntimeOrigin>>;
type RuntimeCall: IsType<<Self as pallet_xcm::Config>::RuntimeCall> + From<Call<Self>>;
}
@@ -647,7 +648,7 @@ pub mod pallet_test_notifier {
query_id: QueryId,
response: Response,
) -> DispatchResult {
let responder = ensure_response(<T as Config>::Origin::from(origin))?;
let responder = ensure_response(<T as Config>::RuntimeOrigin::from(origin))?;
Self::deposit_event(Event::<T>::ResponseReceived(responder, query_id, response));
Ok(())
}
polkadot/runtime/test-runtime/src/xcm_config.rs
+2 -2
View File
@@ -31,7 +31,7 @@ parameter_types! {
/// of this chain.
pub type LocalOriginToLocation = (
// And a usual Signed origin to be used in XCM as a corresponding AccountId32
SignedToAccountId32<crate::Origin, crate::AccountId, OurNetwork>,
SignedToAccountId32<crate::RuntimeOrigin, crate::AccountId, OurNetwork>,
);
pub struct DoNothingRouter;
@@ -81,7 +81,7 @@ impl xcm_executor::Config for XcmConfig {
type RuntimeCall = super::RuntimeCall;
type XcmSender = DoNothingRouter;
type AssetTransactor = DummyAssetTransactor;
type OriginConverter = pallet_xcm::XcmPassthrough<super::Origin>;
type OriginConverter = pallet_xcm::XcmPassthrough<super::RuntimeOrigin>;
type IsReserve = ();
type IsTeleporter = ();
type LocationInverter = InvertNothing;
polkadot/runtime/westend/src/lib.rs
+4 -4
View File
@@ -141,7 +141,7 @@ impl frame_system::Config for Runtime {
type BaseCallFilter = frame_support::traits::Everything;
type BlockWeights = BlockWeights;
type BlockLength = BlockLength;
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type RuntimeCall = RuntimeCall;
type Index = Nonce;
type BlockNumber = BlockNumber;
@@ -172,8 +172,8 @@ parameter_types! {
}
impl pallet_scheduler::Config for Runtime {
type RuntimeOrigin = RuntimeOrigin;
type RuntimeEvent = RuntimeEvent;
type Origin = Origin;
type PalletsOrigin = OriginCaller;
type RuntimeCall = RuntimeCall;
type MaximumWeight = MaximumSchedulerWeight;
@@ -906,8 +906,8 @@ impl parachains_ump::Config for Runtime {
impl parachains_dmp::Config for Runtime {}
impl parachains_hrmp::Config for Runtime {
type RuntimeOrigin = RuntimeOrigin;
type RuntimeEvent = RuntimeEvent;
type Origin = Origin;
type Currency = Balances;
type WeightInfo = weights::runtime_parachains_hrmp::WeightInfo<Self>;
}
@@ -975,8 +975,8 @@ parameter_types! {
}
impl paras_registrar::Config for Runtime {
type RuntimeOrigin = RuntimeOrigin;
type RuntimeEvent = RuntimeEvent;
type Origin = Origin;
type Currency = Balances;
type OnSwap = (Crowdloan, Slots);
type ParaDeposit = ParaDeposit;
polkadot/runtime/westend/src/xcm_config.rs
+10 -10
View File
@@ -17,8 +17,8 @@
//! XCM configurations for Westend.
use super::{
parachains_origin, weights, AccountId, Balances, Origin, ParaId, Runtime, RuntimeCall,
RuntimeEvent, WeightToFee, XcmPallet,
parachains_origin, weights, AccountId, Balances, ParaId, Runtime, RuntimeCall, RuntimeEvent,
RuntimeOrigin, WeightToFee, XcmPallet,
};
use frame_support::{
parameter_types,
@@ -60,10 +60,10 @@ pub type LocalAssetTransactor = XcmCurrencyAdapter<
>;
type LocalOriginConverter = (
SovereignSignedViaLocation<LocationConverter, Origin>,
ChildParachainAsNative<parachains_origin::Origin, Origin>,
SignedAccountId32AsNative<WestendNetwork, Origin>,
ChildSystemParachainAsSuperuser<ParaId, Origin>,
SovereignSignedViaLocation<LocationConverter, RuntimeOrigin>,
ChildParachainAsNative<parachains_origin::Origin, RuntimeOrigin>,
SignedAccountId32AsNative<WestendNetwork, RuntimeOrigin>,
ChildSystemParachainAsSuperuser<ParaId, RuntimeOrigin>,
);
/// The XCM router. When we want to send an XCM message, we use this type. It amalgamates all of our
@@ -122,15 +122,15 @@ impl xcm_executor::Config for XcmConfig {
/// of this chain.
pub type LocalOriginToLocation = (
// And a usual Signed origin to be used in XCM as a corresponding AccountId32
SignedToAccountId32<Origin, AccountId, WestendNetwork>,
SignedToAccountId32<RuntimeOrigin, AccountId, WestendNetwork>,
);
impl pallet_xcm::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type SendXcmOrigin = xcm_builder::EnsureXcmOrigin<Origin, LocalOriginToLocation>;
type SendXcmOrigin = xcm_builder::EnsureXcmOrigin<RuntimeOrigin, LocalOriginToLocation>;
type XcmRouter = XcmRouter;
// Anyone can execute XCM messages locally...
type ExecuteXcmOrigin = xcm_builder::EnsureXcmOrigin<Origin, LocalOriginToLocation>;
type ExecuteXcmOrigin = xcm_builder::EnsureXcmOrigin<RuntimeOrigin, LocalOriginToLocation>;
// ...but they must match our filter, which rejects everything.
type XcmExecuteFilter = Nothing;
type XcmExecutor = xcm_executor::XcmExecutor<XcmConfig>;
@@ -139,7 +139,7 @@ impl pallet_xcm::Config for Runtime {
type Weigher =
WeightInfoBounds<weights::xcm::WestendXcmWeight<RuntimeCall>, RuntimeCall, MaxInstructions>;
type LocationInverter = LocationInverter<Ancestry>;
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type RuntimeCall = RuntimeCall;
const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 100;
type AdvertisedXcmVersion = pallet_xcm::CurrentXcmVersion;
polkadot/xcm/pallet-xcm-benchmarks/src/fungible/mock.rs
+1 -1
View File
@@ -54,7 +54,7 @@ impl frame_system::Config for Test {
type BlockWeights = ();
type BlockLength = ();
type DbWeight = ();
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type Index = u64;
type BlockNumber = u64;
type Hash = H256;
polkadot/xcm/pallet-xcm-benchmarks/src/generic/mock.rs
+9 -9
View File
@@ -60,7 +60,7 @@ impl frame_system::Config for Test {
type BlockWeights = ();
type BlockLength = ();
type DbWeight = ();
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type Index = u64;
type BlockNumber = u64;
type Hash = H256;
@@ -103,7 +103,7 @@ impl xcm_executor::Config for XcmConfig {
type RuntimeCall = RuntimeCall;
type XcmSender = DevNull;
type AssetTransactor = NoAssetTransactor;
type OriginConverter = AlwaysSignedByDefault<Origin>;
type OriginConverter = AlwaysSignedByDefault<RuntimeOrigin>;
type IsReserve = AllAssetLocationsPass;
type IsTeleporter = ();
type LocationInverter = xcm_builder::LocationInverter<Ancestry>;
@@ -159,18 +159,18 @@ pub fn new_test_ext() -> sp_io::TestExternalities {
t.into()
}
pub struct AlwaysSignedByDefault<Origin>(core::marker::PhantomData<Origin>);
impl<Origin> ConvertOrigin<Origin> for AlwaysSignedByDefault<Origin>
pub struct AlwaysSignedByDefault<RuntimeOrigin>(core::marker::PhantomData<RuntimeOrigin>);
impl<RuntimeOrigin> ConvertOrigin<RuntimeOrigin> for AlwaysSignedByDefault<RuntimeOrigin>
where
Origin: OriginTrait,
<Origin as OriginTrait>::AccountId: Decode,
RuntimeOrigin: OriginTrait,
<RuntimeOrigin as OriginTrait>::AccountId: Decode,
{
fn convert_origin(
_origin: impl Into<MultiLocation>,
_kind: OriginKind,
) -> Result<Origin, MultiLocation> {
Ok(Origin::signed(
<Origin as OriginTrait>::AccountId::decode(&mut TrailingZeroInput::zeroes())
) -> Result<RuntimeOrigin, MultiLocation> {
Ok(RuntimeOrigin::signed(
<RuntimeOrigin as OriginTrait>::AccountId::decode(&mut TrailingZeroInput::zeroes())
.expect("infinite length input; no invalid inputs for type; qed"),
))
}
polkadot/xcm/pallet-xcm-benchmarks/src/generic/mod.rs
+1 -1
View File
@@ -15,7 +15,7 @@ pub mod pallet {
#[pallet::config]
pub trait Config<I: 'static = ()>: frame_system::Config + crate::Config {
type RuntimeCall: Dispatchable<Origin = Self::Origin>
type RuntimeCall: Dispatchable<RuntimeOrigin = Self::RuntimeOrigin>
+ GetDispatchInfo
+ From<frame_system::Call<Self>>
+ Encode;
polkadot/xcm/pallet-xcm/src/lib.rs
+18 -7
View File
@@ -75,7 +75,10 @@ pub mod pallet {
/// Required origin for sending XCM messages. If successful, it resolves to `MultiLocation`
/// which exists as an interior location within this chain's XCM context.
type SendXcmOrigin: EnsureOrigin<<Self as SysConfig>::Origin, Success = MultiLocation>;
type SendXcmOrigin: EnsureOrigin<
<Self as SysConfig>::RuntimeOrigin,
Success = MultiLocation,
>;
/// The type used to actually dispatch an XCM to its destination.
type XcmRouter: SendXcm;
@@ -83,7 +86,10 @@ pub mod pallet {
/// Required origin for executing XCM messages, including the teleport functionality. If successful,
/// then it resolves to `MultiLocation` which exists as an interior location within this chain's XCM
/// context.
type ExecuteXcmOrigin: EnsureOrigin<<Self as SysConfig>::Origin, Success = MultiLocation>;
type ExecuteXcmOrigin: EnsureOrigin<
<Self as SysConfig>::RuntimeOrigin,
Success = MultiLocation,
>;
/// Our XCM filter which messages to be executed using `XcmExecutor` must pass.
type XcmExecuteFilter: Contains<(MultiLocation, Xcm<<Self as SysConfig>::RuntimeCall>)>;
@@ -104,13 +110,16 @@ pub mod pallet {
type LocationInverter: InvertLocation;
/// The outer `Origin` type.
type Origin: From<Origin> + From<<Self as SysConfig>::Origin>;
type RuntimeOrigin: From<Origin> + From<<Self as SysConfig>::RuntimeOrigin>;
/// The outer `Call` type.
type RuntimeCall: Parameter
+ GetDispatchInfo
+ IsType<<Self as frame_system::Config>::RuntimeCall>
+ Dispatchable<Origin = <Self as Config>::Origin, PostInfo = PostDispatchInfo>;
+ Dispatchable<
RuntimeOrigin = <Self as Config>::RuntimeOrigin,
PostInfo = PostDispatchInfo,
>;
const VERSION_DISCOVERY_QUEUE_SIZE: u32;
@@ -1555,12 +1564,14 @@ where
/// A simple passthrough where we reuse the `MultiLocation`-typed XCM origin as the inner value of
/// this crate's `Origin::Xcm` value.
pub struct XcmPassthrough<Origin>(PhantomData<Origin>);
impl<Origin: From<crate::Origin>> ConvertOrigin<Origin> for XcmPassthrough<Origin> {
pub struct XcmPassthrough<RuntimeOrigin>(PhantomData<RuntimeOrigin>);
impl<RuntimeOrigin: From<crate::Origin>> ConvertOrigin<RuntimeOrigin>
for XcmPassthrough<RuntimeOrigin>
{
fn convert_origin(
origin: impl Into<MultiLocation>,
kind: OriginKind,
) -> Result<Origin, MultiLocation> {
) -> Result<RuntimeOrigin, MultiLocation> {
let origin = origin.into();
match kind {
OriginKind::Xcm => Ok(crate::Origin::Xcm(origin).into()),
polkadot/xcm/pallet-xcm/src/mock.rs
+13 -13
View File
@@ -52,8 +52,8 @@ pub mod pallet_test_notifier {
#[pallet::config]
pub trait Config: frame_system::Config + crate::Config {
type RuntimeEvent: IsType<<Self as frame_system::Config>::RuntimeEvent> + From<Event<Self>>;
type Origin: IsType<<Self as frame_system::Config>::Origin>
+ Into<Result<crate::Origin, <Self as Config>::Origin>>;
type RuntimeOrigin: IsType<<Self as frame_system::Config>::RuntimeOrigin>
+ Into<Result<crate::Origin, <Self as Config>::RuntimeOrigin>>;
type RuntimeCall: IsType<<Self as crate::Config>::RuntimeCall> + From<Call<Self>>;
}
@@ -110,7 +110,7 @@ pub mod pallet_test_notifier {
query_id: QueryId,
response: Response,
) -> DispatchResult {
let responder = ensure_response(<T as Config>::Origin::from(origin))?;
let responder = ensure_response(<T as Config>::RuntimeOrigin::from(origin))?;
Self::deposit_event(Event::<T>::ResponseReceived(responder, query_id, response));
Ok(())
}
@@ -171,7 +171,7 @@ parameter_types! {
}
impl frame_system::Config for Test {
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type RuntimeCall = RuntimeCall;
type Index = u64;
type BlockNumber = u64;
@@ -229,10 +229,10 @@ pub type LocalAssetTransactor =
XcmCurrencyAdapter<Balances, IsConcrete<RelayLocation>, SovereignAccountOf, AccountId, ()>;
type LocalOriginConverter = (
SovereignSignedViaLocation<SovereignAccountOf, Origin>,
ChildParachainAsNative<origin::Origin, Origin>,
SignedAccountId32AsNative<AnyNetwork, Origin>,
ChildSystemParachainAsSuperuser<ParaId, Origin>,
SovereignSignedViaLocation<SovereignAccountOf, RuntimeOrigin>,
ChildParachainAsNative<origin::Origin, RuntimeOrigin>,
SignedAccountId32AsNative<AnyNetwork, RuntimeOrigin>,
ChildSystemParachainAsSuperuser<ParaId, RuntimeOrigin>,
);
parameter_types! {
@@ -267,7 +267,7 @@ impl xcm_executor::Config for XcmConfig {
type SubscriptionService = XcmPallet;
}
pub type LocalOriginToLocation = SignedToAccountId32<Origin, AccountId, AnyNetwork>;
pub type LocalOriginToLocation = SignedToAccountId32<RuntimeOrigin, AccountId, AnyNetwork>;
parameter_types! {
pub static AdvertisedXcmVersion: pallet_xcm::XcmVersion = 2;
@@ -275,16 +275,16 @@ parameter_types! {
impl pallet_xcm::Config for Test {
type RuntimeEvent = RuntimeEvent;
type SendXcmOrigin = xcm_builder::EnsureXcmOrigin<Origin, LocalOriginToLocation>;
type SendXcmOrigin = xcm_builder::EnsureXcmOrigin<RuntimeOrigin, LocalOriginToLocation>;
type XcmRouter = (TestSendXcmErrX8, TestSendXcm);
type ExecuteXcmOrigin = xcm_builder::EnsureXcmOrigin<Origin, LocalOriginToLocation>;
type ExecuteXcmOrigin = xcm_builder::EnsureXcmOrigin<RuntimeOrigin, LocalOriginToLocation>;
type XcmExecuteFilter = Everything;
type XcmExecutor = XcmExecutor<XcmConfig>;
type XcmTeleportFilter = Everything;
type XcmReserveTransferFilter = Everything;
type Weigher = FixedWeightBounds<BaseXcmWeight, RuntimeCall, MaxInstructions>;
type LocationInverter = LocationInverter<Ancestry>;
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type RuntimeCall = RuntimeCall;
const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 100;
type AdvertisedXcmVersion = AdvertisedXcmVersion;
@@ -294,7 +294,7 @@ impl origin::Config for Test {}
impl pallet_test_notifier::Config for Test {
type RuntimeEvent = RuntimeEvent;
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type RuntimeCall = RuntimeCall;
}
polkadot/xcm/pallet-xcm/src/tests.rs
+26 -22
View File
@@ -171,7 +171,11 @@ fn send_works() {
]);
let versioned_dest = Box::new(RelayLocation::get().into());
let versioned_message = Box::new(VersionedXcm::from(message.clone()));
assert_ok!(XcmPallet::send(Origin::signed(ALICE), versioned_dest, versioned_message));
assert_ok!(XcmPallet::send(
RuntimeOrigin::signed(ALICE),
versioned_dest,
versioned_message
));
assert_eq!(
sent_xcm(),
vec![(
@@ -209,7 +213,7 @@ fn send_fails_when_xcm_router_blocks() {
]);
assert_noop!(
XcmPallet::send(
Origin::signed(ALICE),
RuntimeOrigin::signed(ALICE),
Box::new(MultiLocation::ancestor(8).into()),
Box::new(VersionedXcm::from(message.clone())),
),
@@ -233,7 +237,7 @@ fn teleport_assets_works() {
assert_eq!(Balances::total_balance(&ALICE), INITIAL_BALANCE);
let dest: MultiLocation = AccountId32 { network: Any, id: BOB.into() }.into();
assert_ok!(XcmPallet::teleport_assets(
Origin::signed(ALICE),
RuntimeOrigin::signed(ALICE),
Box::new(RelayLocation::get().into()),
Box::new(dest.clone().into()),
Box::new((Here, SEND_AMOUNT).into()),
@@ -276,7 +280,7 @@ fn limmited_teleport_assets_works() {
assert_eq!(Balances::total_balance(&ALICE), INITIAL_BALANCE);
let dest: MultiLocation = AccountId32 { network: Any, id: BOB.into() }.into();
assert_ok!(XcmPallet::limited_teleport_assets(
Origin::signed(ALICE),
RuntimeOrigin::signed(ALICE),
Box::new(RelayLocation::get().into()),
Box::new(dest.clone().into()),
Box::new((Here, SEND_AMOUNT).into()),
@@ -320,7 +324,7 @@ fn unlimmited_teleport_assets_works() {
assert_eq!(Balances::total_balance(&ALICE), INITIAL_BALANCE);
let dest: MultiLocation = AccountId32 { network: Any, id: BOB.into() }.into();
assert_ok!(XcmPallet::limited_teleport_assets(
Origin::signed(ALICE),
RuntimeOrigin::signed(ALICE),
Box::new(RelayLocation::get().into()),
Box::new(dest.clone().into()),
Box::new((Here, SEND_AMOUNT).into()),
@@ -363,7 +367,7 @@ fn reserve_transfer_assets_works() {
Junction::AccountId32 { network: NetworkId::Any, id: ALICE.into() }.into();
assert_eq!(Balances::total_balance(&ALICE), INITIAL_BALANCE);
assert_ok!(XcmPallet::reserve_transfer_assets(
Origin::signed(ALICE),
RuntimeOrigin::signed(ALICE),
Box::new(Parachain(PARA_ID).into().into()),
Box::new(dest.clone().into()),
Box::new((Here, SEND_AMOUNT).into()),
@@ -411,7 +415,7 @@ fn limited_reserve_transfer_assets_works() {
Junction::AccountId32 { network: NetworkId::Any, id: ALICE.into() }.into();
assert_eq!(Balances::total_balance(&ALICE), INITIAL_BALANCE);
assert_ok!(XcmPallet::limited_reserve_transfer_assets(
Origin::signed(ALICE),
RuntimeOrigin::signed(ALICE),
Box::new(Parachain(PARA_ID).into().into()),
Box::new(dest.clone().into()),
Box::new((Here, SEND_AMOUNT).into()),
@@ -460,7 +464,7 @@ fn unlimited_reserve_transfer_assets_works() {
Junction::AccountId32 { network: NetworkId::Any, id: ALICE.into() }.into();
assert_eq!(Balances::total_balance(&ALICE), INITIAL_BALANCE);
assert_ok!(XcmPallet::limited_reserve_transfer_assets(
Origin::signed(ALICE),
RuntimeOrigin::signed(ALICE),
Box::new(Parachain(PARA_ID).into().into()),
Box::new(dest.clone().into()),
Box::new((Here, SEND_AMOUNT).into()),
@@ -507,7 +511,7 @@ fn execute_withdraw_to_deposit_works() {
Junction::AccountId32 { network: NetworkId::Any, id: BOB.into() }.into();
assert_eq!(Balances::total_balance(&ALICE), INITIAL_BALANCE);
assert_ok!(XcmPallet::execute(
Origin::signed(ALICE),
RuntimeOrigin::signed(ALICE),
Box::new(VersionedXcm::from(Xcm(vec![
WithdrawAsset((Here, SEND_AMOUNT).into()),
buy_execution((Here, SEND_AMOUNT)),
@@ -534,7 +538,7 @@ fn trapped_assets_can_be_claimed() {
Junction::AccountId32 { network: NetworkId::Any, id: BOB.into() }.into();
assert_ok!(XcmPallet::execute(
Origin::signed(ALICE),
RuntimeOrigin::signed(ALICE),
Box::new(VersionedXcm::from(Xcm(vec![
WithdrawAsset((Here, SEND_AMOUNT).into()),
buy_execution((Here, SEND_AMOUNT)),
@@ -569,7 +573,7 @@ fn trapped_assets_can_be_claimed() {
let weight = 3 * BaseXcmWeight::get();
assert_ok!(XcmPallet::execute(
Origin::signed(ALICE),
RuntimeOrigin::signed(ALICE),
Box::new(VersionedXcm::from(Xcm(vec![
ClaimAsset { assets: (Here, SEND_AMOUNT).into(), ticket: Here.into() },
buy_execution((Here, SEND_AMOUNT)),
@@ -584,7 +588,7 @@ fn trapped_assets_can_be_claimed() {
let weight = 3 * BaseXcmWeight::get();
assert_ok!(XcmPallet::execute(
Origin::signed(ALICE),
RuntimeOrigin::signed(ALICE),
Box::new(VersionedXcm::from(Xcm(vec![
ClaimAsset { assets: (Here, SEND_AMOUNT).into(), ticket: Here.into() },
buy_execution((Here, SEND_AMOUNT)),
@@ -615,7 +619,7 @@ fn basic_subscription_works() {
new_test_ext_with_balances(vec![]).execute_with(|| {
let remote = Parachain(1000).into();
assert_ok!(XcmPallet::force_subscribe_version_notify(
Origin::root(),
RuntimeOrigin::root(),
Box::new(remote.clone().into()),
));
@@ -658,13 +662,13 @@ fn subscriptions_increment_id() {
new_test_ext_with_balances(vec![]).execute_with(|| {
let remote = Parachain(1000).into();
assert_ok!(XcmPallet::force_subscribe_version_notify(
Origin::root(),
RuntimeOrigin::root(),
Box::new(remote.clone().into()),
));
let remote2 = Parachain(1001).into();
assert_ok!(XcmPallet::force_subscribe_version_notify(
Origin::root(),
RuntimeOrigin::root(),
Box::new(remote2.clone().into()),
));
@@ -689,12 +693,12 @@ fn double_subscription_fails() {
new_test_ext_with_balances(vec![]).execute_with(|| {
let remote = Parachain(1000).into();
assert_ok!(XcmPallet::force_subscribe_version_notify(
Origin::root(),
RuntimeOrigin::root(),
Box::new(remote.clone().into()),
));
assert_noop!(
XcmPallet::force_subscribe_version_notify(
Origin::root(),
RuntimeOrigin::root(),
Box::new(remote.clone().into())
),
Error::<Test>::AlreadySubscribed,
@@ -707,16 +711,16 @@ fn unsubscribe_works() {
new_test_ext_with_balances(vec![]).execute_with(|| {
let remote = Parachain(1000).into();
assert_ok!(XcmPallet::force_subscribe_version_notify(
Origin::root(),
RuntimeOrigin::root(),
Box::new(remote.clone().into()),
));
assert_ok!(XcmPallet::force_unsubscribe_version_notify(
Origin::root(),
RuntimeOrigin::root(),
Box::new(remote.clone().into())
));
assert_noop!(
XcmPallet::force_unsubscribe_version_notify(
Origin::root(),
RuntimeOrigin::root(),
Box::new(remote.clone().into())
),
Error::<Test>::NoSubscription,
@@ -851,7 +855,7 @@ fn subscriber_side_subscription_works() {
new_test_ext_with_balances(vec![]).execute_with(|| {
let remote = Parachain(1000).into();
assert_ok!(XcmPallet::force_subscribe_version_notify(
Origin::root(),
RuntimeOrigin::root(),
Box::new(remote.clone().into()),
));
take_sent_xcm();
@@ -893,7 +897,7 @@ fn auto_subscription_works() {
let remote0 = Parachain(1000).into();
let remote1 = Parachain(1001).into();
assert_ok!(XcmPallet::force_default_xcm_version(Origin::root(), Some(1)));
assert_ok!(XcmPallet::force_default_xcm_version(RuntimeOrigin::root(), Some(1)));
// Wrapping a version for a destination we don't know elicits a subscription.
let v1_msg = xcm::v1::Xcm::<()>::QueryResponse {
polkadot/xcm/xcm-builder/src/mock.rs
+2 -2
View File
@@ -60,11 +60,11 @@ pub enum TestCall {
Any(Weight, Option<Weight>),
}
impl Dispatchable for TestCall {
type Origin = TestOrigin;
type RuntimeOrigin = TestOrigin;
type Config = ();
type Info = ();
type PostInfo = PostDispatchInfo;
fn dispatch(self, origin: Self::Origin) -> DispatchResultWithPostInfo {
fn dispatch(self, origin: Self::RuntimeOrigin) -> DispatchResultWithPostInfo {
let mut post_info = PostDispatchInfo::default();
let maybe_actual = match self {
TestCall::OnlyRoot(_, maybe_actual) |
polkadot/xcm/xcm-builder/src/origin_conversion.rs
+83 -68
View File
@@ -24,18 +24,20 @@ use xcm::latest::{BodyId, BodyPart, Junction, Junctions::*, MultiLocation, Netwo
use xcm_executor::traits::{Convert, ConvertOrigin};
/// Sovereign accounts use the system's `Signed` origin with an account ID derived from the `LocationConverter`.
pub struct SovereignSignedViaLocation<LocationConverter, Origin>(
PhantomData<(LocationConverter, Origin)>,
pub struct SovereignSignedViaLocation<LocationConverter, RuntimeOrigin>(
PhantomData<(LocationConverter, RuntimeOrigin)>,
);
impl<LocationConverter: Convert<MultiLocation, Origin::AccountId>, Origin: OriginTrait>
ConvertOrigin<Origin> for SovereignSignedViaLocation<LocationConverter, Origin>
impl<
LocationConverter: Convert<MultiLocation, RuntimeOrigin::AccountId>,
RuntimeOrigin: OriginTrait,
> ConvertOrigin<RuntimeOrigin> for SovereignSignedViaLocation<LocationConverter, RuntimeOrigin>
where
Origin::AccountId: Clone,
RuntimeOrigin::AccountId: Clone,
{
fn convert_origin(
origin: impl Into<MultiLocation>,
kind: OriginKind,
) -> Result<Origin, MultiLocation> {
) -> Result<RuntimeOrigin, MultiLocation> {
let origin = origin.into();
log::trace!(
target: "xcm::origin_conversion",
@@ -44,57 +46,61 @@ where
);
if let OriginKind::SovereignAccount = kind {
let location = LocationConverter::convert(origin)?;
Ok(Origin::signed(location).into())
Ok(RuntimeOrigin::signed(location).into())
} else {
Err(origin)
}
}
}
pub struct ParentAsSuperuser<Origin>(PhantomData<Origin>);
impl<Origin: OriginTrait> ConvertOrigin<Origin> for ParentAsSuperuser<Origin> {
pub struct ParentAsSuperuser<RuntimeOrigin>(PhantomData<RuntimeOrigin>);
impl<RuntimeOrigin: OriginTrait> ConvertOrigin<RuntimeOrigin> for ParentAsSuperuser<RuntimeOrigin> {
fn convert_origin(
origin: impl Into<MultiLocation>,
kind: OriginKind,
) -> Result<Origin, MultiLocation> {
) -> Result<RuntimeOrigin, MultiLocation> {
let origin = origin.into();
log::trace!(target: "xcm::origin_conversion", "ParentAsSuperuser origin: {:?}, kind: {:?}", origin, kind);
if kind == OriginKind::Superuser && origin.contains_parents_only(1) {
Ok(Origin::root())
Ok(RuntimeOrigin::root())
} else {
Err(origin)
}
}
}
pub struct ChildSystemParachainAsSuperuser<ParaId, Origin>(PhantomData<(ParaId, Origin)>);
impl<ParaId: IsSystem + From<u32>, Origin: OriginTrait> ConvertOrigin<Origin>
for ChildSystemParachainAsSuperuser<ParaId, Origin>
pub struct ChildSystemParachainAsSuperuser<ParaId, RuntimeOrigin>(
PhantomData<(ParaId, RuntimeOrigin)>,
);
impl<ParaId: IsSystem + From<u32>, RuntimeOrigin: OriginTrait> ConvertOrigin<RuntimeOrigin>
for ChildSystemParachainAsSuperuser<ParaId, RuntimeOrigin>
{
fn convert_origin(
origin: impl Into<MultiLocation>,
kind: OriginKind,
) -> Result<Origin, MultiLocation> {
) -> Result<RuntimeOrigin, MultiLocation> {
let origin = origin.into();
log::trace!(target: "xcm::origin_conversion", "ChildSystemParachainAsSuperuser origin: {:?}, kind: {:?}", origin, kind);
match (kind, origin) {
(
OriginKind::Superuser,
MultiLocation { parents: 0, interior: X1(Junction::Parachain(id)) },
) if ParaId::from(id).is_system() => Ok(Origin::root()),
) if ParaId::from(id).is_system() => Ok(RuntimeOrigin::root()),
(_, origin) => Err(origin),
}
}
}
pub struct SiblingSystemParachainAsSuperuser<ParaId, Origin>(PhantomData<(ParaId, Origin)>);
impl<ParaId: IsSystem + From<u32>, Origin: OriginTrait> ConvertOrigin<Origin>
for SiblingSystemParachainAsSuperuser<ParaId, Origin>
pub struct SiblingSystemParachainAsSuperuser<ParaId, RuntimeOrigin>(
PhantomData<(ParaId, RuntimeOrigin)>,
);
impl<ParaId: IsSystem + From<u32>, RuntimeOrigin: OriginTrait> ConvertOrigin<RuntimeOrigin>
for SiblingSystemParachainAsSuperuser<ParaId, RuntimeOrigin>
{
fn convert_origin(
origin: impl Into<MultiLocation>,
kind: OriginKind,
) -> Result<Origin, MultiLocation> {
) -> Result<RuntimeOrigin, MultiLocation> {
let origin = origin.into();
log::trace!(
target: "xcm::origin_conversion",
@@ -105,42 +111,44 @@ impl<ParaId: IsSystem + From<u32>, Origin: OriginTrait> ConvertOrigin<Origin>
(
OriginKind::Superuser,
MultiLocation { parents: 1, interior: X1(Junction::Parachain(id)) },
) if ParaId::from(id).is_system() => Ok(Origin::root()),
) if ParaId::from(id).is_system() => Ok(RuntimeOrigin::root()),
(_, origin) => Err(origin),
}
}
}
pub struct ChildParachainAsNative<ParachainOrigin, Origin>(PhantomData<(ParachainOrigin, Origin)>);
impl<ParachainOrigin: From<u32>, Origin: From<ParachainOrigin>> ConvertOrigin<Origin>
for ChildParachainAsNative<ParachainOrigin, Origin>
pub struct ChildParachainAsNative<ParachainOrigin, RuntimeOrigin>(
PhantomData<(ParachainOrigin, RuntimeOrigin)>,
);
impl<ParachainOrigin: From<u32>, RuntimeOrigin: From<ParachainOrigin>> ConvertOrigin<RuntimeOrigin>
for ChildParachainAsNative<ParachainOrigin, RuntimeOrigin>
{
fn convert_origin(
origin: impl Into<MultiLocation>,
kind: OriginKind,
) -> Result<Origin, MultiLocation> {
) -> Result<RuntimeOrigin, MultiLocation> {
let origin = origin.into();
log::trace!(target: "xcm::origin_conversion", "ChildParachainAsNative origin: {:?}, kind: {:?}", origin, kind);
match (kind, origin) {
(
OriginKind::Native,
MultiLocation { parents: 0, interior: X1(Junction::Parachain(id)) },
) => Ok(Origin::from(ParachainOrigin::from(id))),
) => Ok(RuntimeOrigin::from(ParachainOrigin::from(id))),
(_, origin) => Err(origin),
}
}
}
pub struct SiblingParachainAsNative<ParachainOrigin, Origin>(
PhantomData<(ParachainOrigin, Origin)>,
pub struct SiblingParachainAsNative<ParachainOrigin, RuntimeOrigin>(
PhantomData<(ParachainOrigin, RuntimeOrigin)>,
);
impl<ParachainOrigin: From<u32>, Origin: From<ParachainOrigin>> ConvertOrigin<Origin>
for SiblingParachainAsNative<ParachainOrigin, Origin>
impl<ParachainOrigin: From<u32>, RuntimeOrigin: From<ParachainOrigin>> ConvertOrigin<RuntimeOrigin>
for SiblingParachainAsNative<ParachainOrigin, RuntimeOrigin>
{
fn convert_origin(
origin: impl Into<MultiLocation>,
kind: OriginKind,
) -> Result<Origin, MultiLocation> {
) -> Result<RuntimeOrigin, MultiLocation> {
let origin = origin.into();
log::trace!(
target: "xcm::origin_conversion",
@@ -151,21 +159,23 @@ impl<ParachainOrigin: From<u32>, Origin: From<ParachainOrigin>> ConvertOrigin<Or
(
OriginKind::Native,
MultiLocation { parents: 1, interior: X1(Junction::Parachain(id)) },
) => Ok(Origin::from(ParachainOrigin::from(id))),
) => Ok(RuntimeOrigin::from(ParachainOrigin::from(id))),
(_, origin) => Err(origin),
}
}
}
// Our Relay-chain has a native origin given by the `Get`ter.
pub struct RelayChainAsNative<RelayOrigin, Origin>(PhantomData<(RelayOrigin, Origin)>);
impl<RelayOrigin: Get<Origin>, Origin> ConvertOrigin<Origin>
for RelayChainAsNative<RelayOrigin, Origin>
pub struct RelayChainAsNative<RelayOrigin, RuntimeOrigin>(
PhantomData<(RelayOrigin, RuntimeOrigin)>,
);
impl<RelayOrigin: Get<RuntimeOrigin>, RuntimeOrigin> ConvertOrigin<RuntimeOrigin>
for RelayChainAsNative<RelayOrigin, RuntimeOrigin>
{
fn convert_origin(
origin: impl Into<MultiLocation>,
kind: OriginKind,
) -> Result<Origin, MultiLocation> {
) -> Result<RuntimeOrigin, MultiLocation> {
let origin = origin.into();
log::trace!(target: "xcm::origin_conversion", "RelayChainAsNative origin: {:?}, kind: {:?}", origin, kind);
if kind == OriginKind::Native && origin.contains_parents_only(1) {
@@ -176,16 +186,16 @@ impl<RelayOrigin: Get<Origin>, Origin> ConvertOrigin<Origin>
}
}
pub struct SignedAccountId32AsNative<Network, Origin>(PhantomData<(Network, Origin)>);
impl<Network: Get<NetworkId>, Origin: OriginTrait> ConvertOrigin<Origin>
for SignedAccountId32AsNative<Network, Origin>
pub struct SignedAccountId32AsNative<Network, RuntimeOrigin>(PhantomData<(Network, RuntimeOrigin)>);
impl<Network: Get<NetworkId>, RuntimeOrigin: OriginTrait> ConvertOrigin<RuntimeOrigin>
for SignedAccountId32AsNative<Network, RuntimeOrigin>
where
Origin::AccountId: From<[u8; 32]>,
RuntimeOrigin::AccountId: From<[u8; 32]>,
{
fn convert_origin(
origin: impl Into<MultiLocation>,
kind: OriginKind,
) -> Result<Origin, MultiLocation> {
) -> Result<RuntimeOrigin, MultiLocation> {
let origin = origin.into();
log::trace!(
target: "xcm::origin_conversion",
@@ -197,22 +207,24 @@ where
OriginKind::Native,
MultiLocation { parents: 0, interior: X1(Junction::AccountId32 { id, network }) },
) if matches!(network, NetworkId::Any) || network == Network::get() =>
Ok(Origin::signed(id.into())),
Ok(RuntimeOrigin::signed(id.into())),
(_, origin) => Err(origin),
}
}
}
pub struct SignedAccountKey20AsNative<Network, Origin>(PhantomData<(Network, Origin)>);
impl<Network: Get<NetworkId>, Origin: OriginTrait> ConvertOrigin<Origin>
for SignedAccountKey20AsNative<Network, Origin>
pub struct SignedAccountKey20AsNative<Network, RuntimeOrigin>(
PhantomData<(Network, RuntimeOrigin)>,
);
impl<Network: Get<NetworkId>, RuntimeOrigin: OriginTrait> ConvertOrigin<RuntimeOrigin>
for SignedAccountKey20AsNative<Network, RuntimeOrigin>
where
Origin::AccountId: From<[u8; 20]>,
RuntimeOrigin::AccountId: From<[u8; 20]>,
{
fn convert_origin(
origin: impl Into<MultiLocation>,
kind: OriginKind,
) -> Result<Origin, MultiLocation> {
) -> Result<RuntimeOrigin, MultiLocation> {
let origin = origin.into();
log::trace!(
target: "xcm::origin_conversion",
@@ -224,28 +236,28 @@ where
OriginKind::Native,
MultiLocation { parents: 0, interior: X1(Junction::AccountKey20 { key, network }) },
) if (matches!(network, NetworkId::Any) || network == Network::get()) =>
Ok(Origin::signed(key.into())),
Ok(RuntimeOrigin::signed(key.into())),
(_, origin) => Err(origin),
}
}
}
/// `EnsureOrigin` barrier to convert from dispatch origin to XCM origin, if one exists.
pub struct EnsureXcmOrigin<Origin, Conversion>(PhantomData<(Origin, Conversion)>);
impl<Origin: OriginTrait + Clone, Conversion: Convert<Origin, MultiLocation>> EnsureOrigin<Origin>
for EnsureXcmOrigin<Origin, Conversion>
pub struct EnsureXcmOrigin<RuntimeOrigin, Conversion>(PhantomData<(RuntimeOrigin, Conversion)>);
impl<RuntimeOrigin: OriginTrait + Clone, Conversion: Convert<RuntimeOrigin, MultiLocation>>
EnsureOrigin<RuntimeOrigin> for EnsureXcmOrigin<RuntimeOrigin, Conversion>
where
Origin::PalletsOrigin: PartialEq,
RuntimeOrigin::PalletsOrigin: PartialEq,
{
type Success = MultiLocation;
fn try_origin(o: Origin) -> Result<Self::Success, Origin> {
fn try_origin(o: RuntimeOrigin) -> Result<Self::Success, RuntimeOrigin> {
let o = match Conversion::convert(o) {
Ok(location) => return Ok(location),
Err(o) => o,
};
// We institute a root fallback so root can always represent the context. This
// guarantees that `successful_origin` will work.
if o.caller() == Origin::root().caller() {
if o.caller() == RuntimeOrigin::root().caller() {
Ok(Here.into())
} else {
Err(o)
@@ -253,8 +265,8 @@ where
}
#[cfg(feature = "runtime-benchmarks")]
fn try_successful_origin() -> Result<Origin, ()> {
Ok(Origin::root())
fn try_successful_origin() -> Result<RuntimeOrigin, ()> {
Ok(RuntimeOrigin::root())
}
}
@@ -262,16 +274,16 @@ where
///
/// Typically used when configuring `pallet-xcm` for allowing normal accounts to dispatch an XCM from an `AccountId32`
/// origin.
pub struct SignedToAccountId32<Origin, AccountId, Network>(
PhantomData<(Origin, AccountId, Network)>,
pub struct SignedToAccountId32<RuntimeOrigin, AccountId, Network>(
PhantomData<(RuntimeOrigin, AccountId, Network)>,
);
impl<Origin: OriginTrait + Clone, AccountId: Into<[u8; 32]>, Network: Get<NetworkId>>
Convert<Origin, MultiLocation> for SignedToAccountId32<Origin, AccountId, Network>
impl<RuntimeOrigin: OriginTrait + Clone, AccountId: Into<[u8; 32]>, Network: Get<NetworkId>>
Convert<RuntimeOrigin, MultiLocation> for SignedToAccountId32<RuntimeOrigin, AccountId, Network>
where
Origin::PalletsOrigin: From<SystemRawOrigin<AccountId>>
+ TryInto<SystemRawOrigin<AccountId>, Error = Origin::PalletsOrigin>,
RuntimeOrigin::PalletsOrigin: From<SystemRawOrigin<AccountId>>
+ TryInto<SystemRawOrigin<AccountId>, Error = RuntimeOrigin::PalletsOrigin>,
{
fn convert(o: Origin) -> Result<MultiLocation, Origin> {
fn convert(o: RuntimeOrigin) -> Result<MultiLocation, RuntimeOrigin> {
o.try_with_caller(|caller| match caller.try_into() {
Ok(SystemRawOrigin::Signed(who)) =>
Ok(Junction::AccountId32 { network: Network::get(), id: who.into() }.into()),
@@ -286,13 +298,16 @@ where
///
/// Typically used when configuring `pallet-xcm` for allowing a collective's Origin to dispatch an XCM from a
/// `Plurality` origin.
pub struct BackingToPlurality<Origin, COrigin, Body>(PhantomData<(Origin, COrigin, Body)>);
impl<Origin: OriginTrait + Clone, COrigin: GetBacking, Body: Get<BodyId>>
Convert<Origin, MultiLocation> for BackingToPlurality<Origin, COrigin, Body>
pub struct BackingToPlurality<RuntimeOrigin, COrigin, Body>(
PhantomData<(RuntimeOrigin, COrigin, Body)>,
);
impl<RuntimeOrigin: OriginTrait + Clone, COrigin: GetBacking, Body: Get<BodyId>>
Convert<RuntimeOrigin, MultiLocation> for BackingToPlurality<RuntimeOrigin, COrigin, Body>
where
Origin::PalletsOrigin: From<COrigin> + TryInto<COrigin, Error = Origin::PalletsOrigin>,
RuntimeOrigin::PalletsOrigin:
From<COrigin> + TryInto<COrigin, Error = RuntimeOrigin::PalletsOrigin>,
{
fn convert(o: Origin) -> Result<MultiLocation, Origin> {
fn convert(o: RuntimeOrigin) -> Result<MultiLocation, RuntimeOrigin> {
o.try_with_caller(|caller| match caller.try_into() {
Ok(co) => match co.get_backing() {
Some(backing) => Ok(Junction::Plurality {
polkadot/xcm/xcm-builder/tests/mock/mod.rs
+9 -9
View File
@@ -61,7 +61,7 @@ parameter_types! {
}
impl frame_system::Config for Runtime {
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type RuntimeCall = RuntimeCall;
type Index = u64;
type BlockNumber = u64;
@@ -133,10 +133,10 @@ pub type LocalCurrencyAdapter = XcmCurrencyAdapter<
pub type LocalAssetTransactor = (LocalCurrencyAdapter,);
type LocalOriginConverter = (
SovereignSignedViaLocation<SovereignAccountOf, Origin>,
ChildParachainAsNative<origin::Origin, Origin>,
SignedAccountId32AsNative<KusamaNetwork, Origin>,
ChildSystemParachainAsSuperuser<ParaId, Origin>,
SovereignSignedViaLocation<SovereignAccountOf, RuntimeOrigin>,
ChildParachainAsNative<origin::Origin, RuntimeOrigin>,
SignedAccountId32AsNative<KusamaNetwork, RuntimeOrigin>,
ChildSystemParachainAsSuperuser<ParaId, RuntimeOrigin>,
);
parameter_types! {
@@ -176,22 +176,22 @@ impl xcm_executor::Config for XcmConfig {
type SubscriptionService = XcmPallet;
}
pub type LocalOriginToLocation = SignedToAccountId32<Origin, AccountId, KusamaNetwork>;
pub type LocalOriginToLocation = SignedToAccountId32<RuntimeOrigin, AccountId, KusamaNetwork>;
impl pallet_xcm::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type LocationInverter = LocationInverter<Ancestry>;
type SendXcmOrigin = xcm_builder::EnsureXcmOrigin<Origin, LocalOriginToLocation>;
type SendXcmOrigin = xcm_builder::EnsureXcmOrigin<RuntimeOrigin, LocalOriginToLocation>;
type XcmRouter = TestSendXcm;
// Anyone can execute XCM messages locally...
type ExecuteXcmOrigin = xcm_builder::EnsureXcmOrigin<Origin, LocalOriginToLocation>;
type ExecuteXcmOrigin = xcm_builder::EnsureXcmOrigin<RuntimeOrigin, LocalOriginToLocation>;
type XcmExecuteFilter = Nothing;
type XcmExecutor = XcmExecutor<XcmConfig>;
type XcmTeleportFilter = Everything;
type XcmReserveTransferFilter = Everything;
type Weigher = FixedWeightBounds<BaseXcmWeight, RuntimeCall, MaxInstructions>;
type RuntimeCall = RuntimeCall;
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 100;
type AdvertisedXcmVersion = pallet_xcm::CurrentXcmVersion;
}
polkadot/xcm/xcm-executor/src/config.rs
+1 -1
View File
@@ -33,7 +33,7 @@ pub trait Config {
type AssetTransactor: TransactAsset;
/// How to get a call origin from a `OriginKind` value.
type OriginConverter: ConvertOrigin<<Self::RuntimeCall as Dispatchable>::Origin>;
type OriginConverter: ConvertOrigin<<Self::RuntimeCall as Dispatchable>::RuntimeOrigin>;
/// Combinations of (Location, Asset) pairs which we trust as reserves.
type IsReserve: FilterAssetLocation;
polkadot/xcm/xcm-simulator/example/src/lib.rs
+1 -1
View File
@@ -206,7 +206,7 @@ mod tests {
Relay::execute_with(|| {
assert_ok!(RelayChainPalletXcm::reserve_transfer_assets(
relay_chain::Origin::signed(ALICE),
relay_chain::RuntimeOrigin::signed(ALICE),
Box::new(X1(Parachain(1)).into().into()),
Box::new(X1(AccountId32 { network: Any, id: ALICE.into() }).into().into()),
Box::new((Here, withdraw_amount).into()),
polkadot/xcm/xcm-simulator/example/src/parachain.rs
+8 -8
View File
@@ -52,7 +52,7 @@ parameter_types! {
}
impl frame_system::Config for Runtime {
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type RuntimeCall = RuntimeCall;
type Index = u64;
type BlockNumber = u64;
@@ -114,9 +114,9 @@ pub type LocationToAccountId = (
);
pub type XcmOriginToCallOrigin = (
SovereignSignedViaLocation<LocationToAccountId, Origin>,
SignedAccountId32AsNative<RelayNetwork, Origin>,
XcmPassthrough<Origin>,
SovereignSignedViaLocation<LocationToAccountId, RuntimeOrigin>,
SignedAccountId32AsNative<RelayNetwork, RuntimeOrigin>,
XcmPassthrough<RuntimeOrigin>,
);
parameter_types! {
@@ -298,20 +298,20 @@ impl mock_msg_queue::Config for Runtime {
type XcmExecutor = XcmExecutor<XcmConfig>;
}
pub type LocalOriginToLocation = SignedToAccountId32<Origin, AccountId, RelayNetwork>;
pub type LocalOriginToLocation = SignedToAccountId32<RuntimeOrigin, AccountId, RelayNetwork>;
impl pallet_xcm::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type SendXcmOrigin = EnsureXcmOrigin<Origin, LocalOriginToLocation>;
type SendXcmOrigin = EnsureXcmOrigin<RuntimeOrigin, LocalOriginToLocation>;
type XcmRouter = XcmRouter;
type ExecuteXcmOrigin = EnsureXcmOrigin<Origin, LocalOriginToLocation>;
type ExecuteXcmOrigin = EnsureXcmOrigin<RuntimeOrigin, LocalOriginToLocation>;
type XcmExecuteFilter = Everything;
type XcmExecutor = XcmExecutor<XcmConfig>;
type XcmTeleportFilter = Nothing;
type XcmReserveTransferFilter = Everything;
type Weigher = FixedWeightBounds<UnitWeightCost, RuntimeCall, MaxInstructions>;
type LocationInverter = LocationInverter<Ancestry>;
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type RuntimeCall = RuntimeCall;
const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 100;
type AdvertisedXcmVersion = pallet_xcm::CurrentXcmVersion;
polkadot/xcm/xcm-simulator/example/src/relay_chain.rs
+9 -9
View File
@@ -42,7 +42,7 @@ parameter_types! {
}
impl frame_system::Config for Runtime {
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type RuntimeCall = RuntimeCall;
type Index = u64;
type BlockNumber = u64;
@@ -107,10 +107,10 @@ pub type LocalAssetTransactor =
XcmCurrencyAdapter<Balances, IsConcrete<KsmLocation>, SovereignAccountOf, AccountId, ()>;
type LocalOriginConverter = (
SovereignSignedViaLocation<SovereignAccountOf, Origin>,
ChildParachainAsNative<origin::Origin, Origin>,
SignedAccountId32AsNative<KusamaNetwork, Origin>,
ChildSystemParachainAsSuperuser<ParaId, Origin>,
SovereignSignedViaLocation<SovereignAccountOf, RuntimeOrigin>,
ChildParachainAsNative<origin::Origin, RuntimeOrigin>,
SignedAccountId32AsNative<KusamaNetwork, RuntimeOrigin>,
ChildSystemParachainAsSuperuser<ParaId, RuntimeOrigin>,
);
parameter_types! {
@@ -140,21 +140,21 @@ impl Config for XcmConfig {
type SubscriptionService = ();
}
pub type LocalOriginToLocation = SignedToAccountId32<Origin, AccountId, KusamaNetwork>;
pub type LocalOriginToLocation = SignedToAccountId32<RuntimeOrigin, AccountId, KusamaNetwork>;
impl pallet_xcm::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type SendXcmOrigin = xcm_builder::EnsureXcmOrigin<Origin, LocalOriginToLocation>;
type SendXcmOrigin = xcm_builder::EnsureXcmOrigin<RuntimeOrigin, LocalOriginToLocation>;
type XcmRouter = XcmRouter;
// Anyone can execute XCM messages locally...
type ExecuteXcmOrigin = xcm_builder::EnsureXcmOrigin<Origin, LocalOriginToLocation>;
type ExecuteXcmOrigin = xcm_builder::EnsureXcmOrigin<RuntimeOrigin, LocalOriginToLocation>;
type XcmExecuteFilter = Nothing;
type XcmExecutor = XcmExecutor<XcmConfig>;
type XcmTeleportFilter = Everything;
type XcmReserveTransferFilter = Everything;
type Weigher = FixedWeightBounds<BaseXcmWeight, RuntimeCall, MaxInstructions>;
type LocationInverter = LocationInverter<Ancestry>;
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type RuntimeCall = RuntimeCall;
const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 100;
type AdvertisedXcmVersion = pallet_xcm::CurrentXcmVersion;
polkadot/xcm/xcm-simulator/fuzzer/src/parachain.rs
+8 -8
View File
@@ -52,7 +52,7 @@ parameter_types! {
}
impl frame_system::Config for Runtime {
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type RuntimeCall = RuntimeCall;
type Index = u64;
type BlockNumber = u64;
@@ -114,9 +114,9 @@ pub type LocationToAccountId = (
);
pub type XcmOriginToCallOrigin = (
SovereignSignedViaLocation<LocationToAccountId, Origin>,
SignedAccountId32AsNative<RelayNetwork, Origin>,
XcmPassthrough<Origin>,
SovereignSignedViaLocation<LocationToAccountId, RuntimeOrigin>,
SignedAccountId32AsNative<RelayNetwork, RuntimeOrigin>,
XcmPassthrough<RuntimeOrigin>,
);
parameter_types! {
@@ -298,20 +298,20 @@ impl mock_msg_queue::Config for Runtime {
type XcmExecutor = XcmExecutor<XcmConfig>;
}
pub type LocalOriginToLocation = SignedToAccountId32<Origin, AccountId, RelayNetwork>;
pub type LocalOriginToLocation = SignedToAccountId32<RuntimeOrigin, AccountId, RelayNetwork>;
impl pallet_xcm::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type SendXcmOrigin = EnsureXcmOrigin<Origin, LocalOriginToLocation>;
type SendXcmOrigin = EnsureXcmOrigin<RuntimeOrigin, LocalOriginToLocation>;
type XcmRouter = XcmRouter;
type ExecuteXcmOrigin = EnsureXcmOrigin<Origin, LocalOriginToLocation>;
type ExecuteXcmOrigin = EnsureXcmOrigin<RuntimeOrigin, LocalOriginToLocation>;
type XcmExecuteFilter = Everything;
type XcmExecutor = XcmExecutor<XcmConfig>;
type XcmTeleportFilter = Nothing;
type XcmReserveTransferFilter = Everything;
type Weigher = FixedWeightBounds<UnitWeightCost, RuntimeCall, MaxInstructions>;
type LocationInverter = LocationInverter<Ancestry>;
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type RuntimeCall = RuntimeCall;
const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 100;
type AdvertisedXcmVersion = pallet_xcm::CurrentXcmVersion;
polkadot/xcm/xcm-simulator/fuzzer/src/relay_chain.rs
+9 -9
View File
@@ -42,7 +42,7 @@ parameter_types! {
}
impl frame_system::Config for Runtime {
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type RuntimeCall = RuntimeCall;
type Index = u64;
type BlockNumber = u64;
@@ -107,10 +107,10 @@ pub type LocalAssetTransactor =
XcmCurrencyAdapter<Balances, IsConcrete<KsmLocation>, SovereignAccountOf, AccountId, ()>;
type LocalOriginConverter = (
SovereignSignedViaLocation<SovereignAccountOf, Origin>,
ChildParachainAsNative<origin::Origin, Origin>,
SignedAccountId32AsNative<KusamaNetwork, Origin>,
ChildSystemParachainAsSuperuser<ParaId, Origin>,
SovereignSignedViaLocation<SovereignAccountOf, RuntimeOrigin>,
ChildParachainAsNative<origin::Origin, RuntimeOrigin>,
SignedAccountId32AsNative<KusamaNetwork, RuntimeOrigin>,
ChildSystemParachainAsSuperuser<ParaId, RuntimeOrigin>,
);
parameter_types! {
@@ -140,21 +140,21 @@ impl Config for XcmConfig {
type SubscriptionService = ();
}
pub type LocalOriginToLocation = SignedToAccountId32<Origin, AccountId, KusamaNetwork>;
pub type LocalOriginToLocation = SignedToAccountId32<RuntimeOrigin, AccountId, KusamaNetwork>;
impl pallet_xcm::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type SendXcmOrigin = xcm_builder::EnsureXcmOrigin<Origin, LocalOriginToLocation>;
type SendXcmOrigin = xcm_builder::EnsureXcmOrigin<RuntimeOrigin, LocalOriginToLocation>;
type XcmRouter = XcmRouter;
// Anyone can execute XCM messages locally...
type ExecuteXcmOrigin = xcm_builder::EnsureXcmOrigin<Origin, LocalOriginToLocation>;
type ExecuteXcmOrigin = xcm_builder::EnsureXcmOrigin<RuntimeOrigin, LocalOriginToLocation>;
type XcmExecuteFilter = Nothing;
type XcmExecutor = XcmExecutor<XcmConfig>;
type XcmTeleportFilter = Everything;
type XcmReserveTransferFilter = Everything;
type Weigher = FixedWeightBounds<BaseXcmWeight, RuntimeCall, MaxInstructions>;
type LocationInverter = LocationInverter<Ancestry>;
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type RuntimeCall = RuntimeCall;
const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 100;
type AdvertisedXcmVersion = pallet_xcm::CurrentXcmVersion;