difftreelog
fix(preimage-execution) introduce weight expectation + adjust benchmarks + new tests
in: master
6 files changed
pallets/maintenance/src/benchmarking.rsdiffbeforeafterboth--- a/pallets/maintenance/src/benchmarking.rs
+++ b/pallets/maintenance/src/benchmarking.rs
@@ -19,7 +19,7 @@
use frame_benchmarking::benchmarks;
use frame_system::{Call as RuntimeCall, RawOrigin};
-use frame_support::{ensure, traits::StorePreimage};
+use frame_support::{ensure, pallet_prelude::Weight, traits::StorePreimage};
use codec::Encode;
use sp_std::vec;
@@ -40,7 +40,7 @@
execute_preimage {
let call_hash = RuntimeCall::<T>::set_storage { items: vec![] }.encode();
let hash = T::Preimages::note(call_hash.into())?;
- }: _(RawOrigin::Root, hash)
+ }: _(RawOrigin::Root, hash, None, Weight::from_parts(100000000000, 100000000000))
verify {
}
}
pallets/maintenance/src/lib.rsdiffbeforeafterboth--- a/pallets/maintenance/src/lib.rs
+++ b/pallets/maintenance/src/lib.rs
@@ -104,30 +104,48 @@
#[pallet::call_index(2)]
#[pallet::weight(<T as Config>::WeightInfo::execute_preimage())]
- pub fn execute_preimage(_origin: OriginFor<T>, _hash: H256) -> DispatchResult {
- #[cfg(feature = "preimage")]
- {
- let origin = _origin;
- let hash = _hash;
+ pub fn execute_preimage(
+ origin: OriginFor<T>,
+ hash: H256,
+ preimage_length: Option<u32>,
+ weight_bound: Weight,
+ ) -> DispatchResultWithPostInfo {
+ use codec::Decode;
- ensure_root(origin)?;
+ ensure_root(origin)?;
- let len = T::Preimages::len(&hash).ok_or(DispatchError::Unavailable)?;
- let bounded = T::Preimages::pick::<<T as Config>::RuntimeCall>(hash, len);
- let (call, _) =
- T::Preimages::realize(&bounded).map_err(|_| DispatchError::Unavailable)?;
+ let data = T::Preimages::fetch(&hash, preimage_length)?;
+ weight_bound.set_proof_size(
+ weight_bound
+ .proof_size()
+ .checked_sub(
+ data.len()
+ .try_into()
+ .map_err(|_| DispatchError::Corruption)?,
+ )
+ .ok_or(DispatchError::Exhausted)?,
+ );
- let result = match call.dispatch(frame_system::RawOrigin::Root.into()) {
- Ok(_) => Ok(()),
- Err(error_and_info) => Err(error_and_info.error),
- };
+ let call = <T as Config>::RuntimeCall::decode(&mut &data[..])
+ .map_err(|_| DispatchError::Corruption)?;
- result
- }
+ ensure!(
+ call.get_dispatch_info().weight.all_lte(weight_bound),
+ DispatchError::Exhausted
+ );
- #[cfg(not(feature = "preimage"))]
- {
- Err(DispatchError::Unavailable)
+ match call.dispatch(frame_system::RawOrigin::Root.into()) {
+ Ok(post_info) => Ok(PostDispatchInfo {
+ actual_weight: post_info.actual_weight,
+ pays_fee: Pays::No,
+ }),
+ Err(error_and_info) => Err(DispatchErrorWithPostInfo {
+ post_info: PostDispatchInfo {
+ actual_weight: error_and_info.post_info.actual_weight,
+ pays_fee: Pays::No,
+ },
+ error: error_and_info.error,
+ }),
}
}
}
runtime/common/config/pallets/preimage.rsdiffbeforeafterboth--- a/runtime/common/config/pallets/preimage.rs
+++ b/runtime/common/config/pallets/preimage.rs
@@ -20,8 +20,7 @@
use up_common::constants::*;
parameter_types! {
- pub PreimageBaseDeposit: Balance = 1000 * UNIQUE; // deposit(2, 64);
- // pub PreimageByteDeposit: Balance = 1 * CENTIUNIQUE; // deposit(0, 1);
+ pub PreimageBaseDeposit: Balance = 1000 * UNIQUE;
}
impl pallet_preimage::Config for Runtime {
runtime/common/runtime_apis.rsdiffbeforeafterboth--- a/runtime/common/runtime_apis.rs
+++ b/runtime/common/runtime_apis.rs
@@ -565,9 +565,6 @@
#[cfg(feature = "collator-selection")]
list_benchmark!(list, extra, pallet_identity, Identity);
- #[cfg(feature = "preimage")]
- list_benchmark!(list, extra, pallet_preimage, Preimage);
-
#[cfg(feature = "foreign-assets")]
list_benchmark!(list, extra, pallet_foreign_assets, ForeignAssets);
@@ -631,9 +628,6 @@
#[cfg(feature = "collator-selection")]
add_benchmark!(params, batches, pallet_identity, Identity);
-
- #[cfg(feature = "preimage")]
- add_benchmark!(params, batches, pallet_preimage, Preimage);
#[cfg(feature = "foreign-assets")]
add_benchmark!(params, batches, pallet_foreign_assets, ForeignAssets);
tests/src/maintenance.seqtest.tsdiffbeforeafterboth1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617import {IKeyringPair} from '@polkadot/types/types';18import {ApiPromise} from '@polkadot/api';19import {expect, itSched, itSub, Pallets, requirePalletsOrSkip, usingPlaygrounds} from './util';20import {itEth} from './eth/util';2122async function maintenanceEnabled(api: ApiPromise): Promise<boolean> {23 return (await api.query.maintenance.enabled()).toJSON() as boolean;24}2526describe('Integration Test: Maintenance Functionality', () => {27 let superuser: IKeyringPair;28 let donor: IKeyringPair;29 let bob: IKeyringPair;3031 before(async function() {32 await usingPlaygrounds(async (helper, privateKey) => {33 requirePalletsOrSkip(this, helper, [Pallets.Maintenance]);34 superuser = await privateKey('//Alice');35 donor = await privateKey({filename: __filename});36 [bob] = await helper.arrange.createAccounts([10000n], donor);3738 });39 });4041 describe('Maintenance Mode', () => {42 before(async function() {43 await usingPlaygrounds(async (helper) => {44 if (await maintenanceEnabled(helper.getApi())) {45 console.warn('\tMaintenance mode was left enabled BEFORE the test suite! Disabling it now.');46 await expect(helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.disable', [])).to.be.fulfilled;47 }48 });49 });5051 itSub('Allows superuser to enable and disable maintenance mode - and disallows anyone else', async ({helper}) => {52 // Make sure non-sudo can't enable maintenance mode53 await expect(helper.executeExtrinsic(superuser, 'api.tx.maintenance.enable', []), 'on commoner enabling MM')54 .to.be.rejectedWith(/BadOrigin/);5556 // Set maintenance mode57 await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.enable', []);58 expect(await maintenanceEnabled(helper.getApi()), 'MM is OFF when it should be ON').to.be.true;5960 // Make sure non-sudo can't disable maintenance mode61 await expect(helper.executeExtrinsic(bob, 'api.tx.maintenance.disable', []), 'on commoner disabling MM')62 .to.be.rejectedWith(/BadOrigin/);6364 // Disable maintenance mode65 await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.disable', []);66 expect(await maintenanceEnabled(helper.getApi()), 'MM is ON when it should be OFF').to.be.false;67 });6869 itSub('MM blocks unique pallet calls', async ({helper}) => {70 // Can create an NFT collection before enabling the MM71 const nftCollection = await helper.nft.mintCollection(bob, {72 tokenPropertyPermissions: [{key: 'test', permission: {73 collectionAdmin: true,74 tokenOwner: true,75 mutable: true,76 }}],77 });7879 // Can mint an NFT before enabling the MM80 const nft = await nftCollection.mintToken(bob);8182 // Can create an FT collection before enabling the MM83 const ftCollection = await helper.ft.mintCollection(superuser);8485 // Can mint an FT before enabling the MM86 await expect(ftCollection.mint(superuser)).to.be.fulfilled;8788 await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.enable', []);89 expect(await maintenanceEnabled(helper.getApi()), 'MM is OFF when it should be ON').to.be.true;9091 // Unable to create a collection when the MM is enabled92 await expect(helper.nft.mintCollection(superuser), 'cudo forbidden stuff')93 .to.be.rejectedWith(/Invalid Transaction: Transaction call is not expected/);9495 // Unable to set token properties when the MM is enabled96 await expect(nft.setProperties(97 bob,98 [{key: 'test', value: 'test-val'}],99 )).to.be.rejectedWith(/Invalid Transaction: Transaction call is not expected/);100101 // Unable to mint an NFT when the MM is enabled102 await expect(nftCollection.mintToken(superuser))103 .to.be.rejectedWith(/Invalid Transaction: Transaction call is not expected/);104105 // Unable to mint an FT when the MM is enabled106 await expect(ftCollection.mint(superuser))107 .to.be.rejectedWith(/Invalid Transaction: Transaction call is not expected/);108109 await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.disable', []);110 expect(await maintenanceEnabled(helper.getApi()), 'MM is ON when it should be OFF').to.be.false;111112 // Can create a collection after disabling the MM113 await expect(helper.nft.mintCollection(bob), 'MM is disabled, the collection should be created').to.be.fulfilled;114115 // Can set token properties after disabling the MM116 await nft.setProperties(bob, [{key: 'test', value: 'test-val'}]);117118 // Can mint an NFT after disabling the MM119 await nftCollection.mintToken(bob);120121 // Can mint an FT after disabling the MM122 await ftCollection.mint(superuser);123 });124125 itSub.ifWithPallets('MM blocks unique pallet calls (Re-Fungible)', [Pallets.ReFungible], async ({helper}) => {126 // Can create an RFT collection before enabling the MM127 const rftCollection = await helper.rft.mintCollection(superuser);128129 // Can mint an RFT before enabling the MM130 await expect(rftCollection.mintToken(superuser)).to.be.fulfilled;131132 await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.enable', []);133 expect(await maintenanceEnabled(helper.getApi()), 'MM is OFF when it should be ON').to.be.true;134135 // Unable to mint an RFT when the MM is enabled136 await expect(rftCollection.mintToken(superuser))137 .to.be.rejectedWith(/Invalid Transaction: Transaction call is not expected/);138139 await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.disable', []);140 expect(await maintenanceEnabled(helper.getApi()), 'MM is ON when it should be OFF').to.be.false;141142 // Can mint an RFT after disabling the MM143 await rftCollection.mintToken(superuser);144 });145146 itSub('MM allows native token transfers and RPC calls', async ({helper}) => {147 // We can use RPC before the MM is enabled148 const totalCount = await helper.collection.getTotalCount();149150 // We can transfer funds before the MM is enabled151 await expect(helper.balance.transferToSubstrate(superuser, bob.address, 2n)).to.be.fulfilled;152153 await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.enable', []);154 expect(await maintenanceEnabled(helper.getApi()), 'MM is OFF when it should be ON').to.be.true;155156 // RPCs work while in maintenance157 expect(await helper.collection.getTotalCount()).to.be.deep.equal(totalCount);158159 // We still able to transfer funds160 await expect(helper.balance.transferToSubstrate(bob, superuser.address, 1n)).to.be.fulfilled;161162 await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.disable', []);163 expect(await maintenanceEnabled(helper.getApi()), 'MM is ON when it should be OFF').to.be.false;164165 // RPCs work after maintenance166 expect(await helper.collection.getTotalCount()).to.be.deep.equal(totalCount);167168 // Transfers work after maintenance169 await expect(helper.balance.transferToSubstrate(bob, superuser.address, 1n)).to.be.fulfilled;170 });171172 itSched.ifWithPallets('MM blocks scheduled calls and the scheduler itself', [Pallets.Scheduler], async (scheduleKind, {helper}) => {173 const collection = await helper.nft.mintCollection(bob);174175 const nftBeforeMM = await collection.mintToken(bob);176 const nftDuringMM = await collection.mintToken(bob);177 const nftAfterMM = await collection.mintToken(bob);178179 const [180 scheduledIdBeforeMM,181 scheduledIdDuringMM,182 scheduledIdBunkerThroughMM,183 scheduledIdAttemptDuringMM,184 scheduledIdAfterMM,185 ] = scheduleKind == 'named'186 ? helper.arrange.makeScheduledIds(5)187 : new Array(5);188189 const blocksToWait = 6;190191 // Scheduling works before the maintenance192 await nftBeforeMM.scheduleAfter(blocksToWait, {scheduledId: scheduledIdBeforeMM})193 .transfer(bob, {Substrate: superuser.address});194195 await helper.wait.newBlocks(blocksToWait + 1);196 expect(await nftBeforeMM.getOwner()).to.be.deep.equal({Substrate: superuser.address});197198 // Schedule a transaction that should occur *during* the maintenance199 await nftDuringMM.scheduleAfter(blocksToWait, {scheduledId: scheduledIdDuringMM})200 .transfer(bob, {Substrate: superuser.address});201202 // Schedule a transaction that should occur *after* the maintenance203 await nftDuringMM.scheduleAfter(blocksToWait * 2, {scheduledId: scheduledIdBunkerThroughMM})204 .transfer(bob, {Substrate: superuser.address});205206 await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.enable', []);207 expect(await maintenanceEnabled(helper.getApi()), 'MM is OFF when it should be ON').to.be.true;208209 await helper.wait.newBlocks(blocksToWait + 1);210 // The owner should NOT change since the scheduled transaction should be rejected211 expect(await nftDuringMM.getOwner()).to.be.deep.equal({Substrate: bob.address});212213 // Any attempts to schedule a tx during the MM should be rejected214 await expect(nftDuringMM.scheduleAfter(blocksToWait, {scheduledId: scheduledIdAttemptDuringMM})215 .transfer(bob, {Substrate: superuser.address}))216 .to.be.rejectedWith(/Invalid Transaction: Transaction call is not expected/);217218 await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.disable', []);219 expect(await maintenanceEnabled(helper.getApi()), 'MM is ON when it should be OFF').to.be.false;220221 // Scheduling works after the maintenance222 await nftAfterMM.scheduleAfter(blocksToWait, {scheduledId: scheduledIdAfterMM})223 .transfer(bob, {Substrate: superuser.address});224225 await helper.wait.newBlocks(blocksToWait + 1);226227 expect(await nftAfterMM.getOwner()).to.be.deep.equal({Substrate: superuser.address});228 // The owner of the token scheduled for transaction *before* maintenance should now change *after* maintenance229 expect(await nftDuringMM.getOwner()).to.be.deep.equal({Substrate: superuser.address});230 });231232 itEth('Disallows Ethereum transactions to execute while in maintenance', async ({helper}) => {233 const owner = await helper.eth.createAccountWithBalance(donor);234 const receiver = helper.eth.createAccount();235236 const {collectionAddress} = await helper.eth.createERC721MetadataCompatibleNFTCollection(owner, 'A', 'B', 'C', '');237238 // Set maintenance mode239 await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.enable', []);240 expect(await maintenanceEnabled(helper.getApi()), 'MM is OFF when it should be ON').to.be.true;241242 const contract = await helper.ethNativeContract.collection(collectionAddress, 'nft', owner);243 const tokenId = await contract.methods.nextTokenId().call();244 expect(tokenId).to.be.equal('1');245246 await expect(contract.methods.mintWithTokenURI(receiver, 'Test URI').send())247 .to.be.rejectedWith(/Returned error: unknown error/);248249 await expect(contract.methods.ownerOf(tokenId).call()).rejectedWith(/token not found/);250251 // Disable maintenance mode252 await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.disable', []);253 expect(await maintenanceEnabled(helper.getApi()), 'MM is ON when it should be OFF').to.be.false;254 });255256 itSub('Allows to enable and disable MM repeatedly', async ({helper}) => {257 // Set maintenance mode258 await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.enable', []);259 await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.enable', []);260 expect(await maintenanceEnabled(helper.getApi()), 'MM is OFF when it should be ON').to.be.true;261262 // Disable maintenance mode263 await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.disable', []);264 await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.disable', []);265 expect(await maintenanceEnabled(helper.getApi()), 'MM is ON when it should be OFF').to.be.false;266 });267268 afterEach(async () => {269 await usingPlaygrounds(async helper => {270 if (helper.fetchMissingPalletNames([Pallets.Maintenance]).length != 0) return;271 if (await maintenanceEnabled(helper.getApi())) {272 console.warn('\tMaintenance mode was left enabled AFTER a test has finished! Be careful. Disabling it now.');273 await helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.disable', []);274 }275 expect(await maintenanceEnabled(helper.getApi()), 'Disastrous! Exited the test suite with maintenance mode on.').to.be.false;276 });277 });278 });279280 describe('Preimage Execution', () => {281 let preimageHash: string;282283 before(async function() {284 await usingPlaygrounds(async (helper) => {285 requirePalletsOrSkip(this, helper, [Pallets.Preimage, Pallets.Maintenance]);286287 // create a preimage to be operated with in the tests288 const randomAccounts = await helper.arrange.createCrowd(10, 0n, superuser);289 const randomIdentities = randomAccounts.map((acc, i) => [290 acc.address, {291 deposit: 0n,292 judgements: [],293 info: {294 display: {295 raw: `Random Account #${i}`,296 },297 },298 },299 ]);300 const preimage = helper.constructApiCall('api.tx.identity.forceInsertIdentities', [randomIdentities]).method.toHex();301 const result = await helper.preimage.notePreimage(bob, preimage);302 const events = result.result.events.filter(x => x.event.method === 'Noted' && x.event.section === 'preimage');303 preimageHash = events[0].event.data[0].toHuman();304 });305 });306307 itSub('Successfully executes call in a preimage', async ({helper}) => {308 const result = await expect(helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.executePreimage', [preimageHash]))309 .to.be.fulfilled;310311 // preimage is executed, and an appropriate event is present312 const events = result.result.events.filter((x: any) => x.event.method === 'IdentitiesInserted' && x.event.section === 'identity');313 expect(events.length).to.be.equal(1);314315 // the preimage goes back to being unrequested316 expect(await helper.preimage.getPreimageInfo(preimageHash)).to.have.property('unrequested');317 });318319 itSub('Does not allow preimage execution with non-root', async ({helper}) => {320 await expect(helper.executeExtrinsic(bob, 'api.tx.maintenance.executePreimage', [preimageHash]))321 .to.be.rejectedWith(/BadOrigin/);322 });323324 itSub('Does not allow execution of non-existent preimages', async ({helper}) => {325 await expect(helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.executePreimage', [326 '0x1010101010101010101010101010101010101010101010101010101010101010',327 ])).to.be.rejectedWith(/Unavailable/);328 });329330 after(async function() {331 await usingPlaygrounds(async (helper) => {332 if (helper.fetchMissingPalletNames([Pallets.Preimage, Pallets.Maintenance]).length != 0) return;333334 await helper.preimage.unnotePreimage(bob, preimageHash);335 });336 });337 });338});tests/src/util/identitySetter.tsdiffbeforeafterboth--- a/tests/src/util/identitySetter.ts
+++ b/tests/src/util/identitySetter.ts
@@ -172,8 +172,6 @@
// identitiesToRemove.push((key as any).toHuman()[0]);
}
- console.log(identitiesToAdd[0][1]);
-
if (identitiesToRemove.length != 0)
await uploadPreimage(
helper,