git.delta.rocks / unique-network / refs/commits / 6ec8a32fcc0b

--- a/Makefile
+++ b/Makefile
@@ -137,9 +137,13 @@
 bench-app-promotion:
 	make _bench PALLET=app-promotion PALLET_DIR=app-promotion
 
+.PHONY: bench-maintenance
+bench-maintenance:
+	make _bench PALLET=maintenance
+
 .PHONY: bench
 # Disabled: bench-scheduler, bench-collator-selection, bench-identity
-bench: bench-common bench-evm-migration bench-unique bench-structure bench-fungible bench-refungible bench-nonfungible bench-configuration bench-foreign-assets
+bench: bench-common bench-evm-migration bench-unique bench-structure bench-fungible bench-refungible bench-nonfungible bench-configuration bench-foreign-assets bench-maintenance
 
 .PHONY: check
 check:

--- a/pallets/maintenance/src/benchmarking.rs
+++ b/pallets/maintenance/src/benchmarking.rs
@@ -17,11 +17,10 @@
 use super::*;
 use crate::{Pallet as Maintenance, Config};
 
+use codec::Encode;
 use frame_benchmarking::benchmarks;
-use frame_system::{Call as RuntimeCall, RawOrigin};
+use frame_system::RawOrigin;
 use frame_support::{ensure, pallet_prelude::Weight, traits::StorePreimage};
-use codec::Encode;
-use sp_std::vec;
 
 benchmarks! {
 	enable {
@@ -38,9 +37,9 @@
 	}
 
 	execute_preimage {
-		let call_hash = RuntimeCall::<T>::set_storage { items: vec![] }.encode();
-		let hash = T::Preimages::note(call_hash.into())?;
-	}: _(RawOrigin::Root, hash, None, Weight::from_parts(100000000000, 100000000000))
+		let call = <T as Config>::RuntimeCall::from(frame_system::Call::<T>::remark { remark: 1u32.encode() });
+		let hash = T::Preimages::note(call.encode().into())?;
+	}: _(RawOrigin::Root, hash, Weight::from_parts(100000000000, 100000000000))
 	verify {
 	}
 }

--- a/pallets/maintenance/src/lib.rs
+++ b/pallets/maintenance/src/lib.rs
@@ -102,19 +102,22 @@
 			Ok(())
 		}
 
+		/// Execute a runtime call stored as a preimage.
+		///
+		/// `weight_bound` is the maximum weight that the caller is willing
+		/// to allow the extrinsic to be executed with.
 		#[pallet::call_index(2)]
 		#[pallet::weight(<T as Config>::WeightInfo::execute_preimage())]
 		pub fn execute_preimage(
 			origin: OriginFor<T>,
 			hash: H256,
-			preimage_length: Option<u32>,
 			weight_bound: Weight,
 		) -> DispatchResultWithPostInfo {
 			use codec::Decode;
 
 			ensure_root(origin)?;
 
-			let data = T::Preimages::fetch(&hash, preimage_length)?;
+			let data = T::Preimages::fetch(&hash, None)?;
 			weight_bound.set_proof_size(
 				weight_bound
 					.proof_size()
@@ -135,15 +138,9 @@
 			);
 
 			match call.dispatch(frame_system::RawOrigin::Root.into()) {
-				Ok(post_info) => Ok(PostDispatchInfo {
-					actual_weight: post_info.actual_weight,
-					pays_fee: Pays::No,
-				}),
+				Ok(_) => Ok(Pays::No.into()),
 				Err(error_and_info) => Err(DispatchErrorWithPostInfo {
-					post_info: PostDispatchInfo {
-						actual_weight: error_and_info.post_info.actual_weight,
-						pays_fee: Pays::No,
-					},
+					post_info: Pays::No.into(),
 					error: error_and_info.error,
 				}),
 			}

--- a/pallets/maintenance/src/weights.rs
+++ b/pallets/maintenance/src/weights.rs
@@ -3,7 +3,7 @@
 //! Autogenerated weights for pallet_maintenance
 //!
 //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
-//! DATE: 2022-11-01, STEPS: `50`, REPEAT: 80, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! DATE: 2023-02-22, STEPS: `50`, REPEAT: 80, LOW RANGE: `[]`, HIGH RANGE: `[]`
 //! EXECUTION: None, WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 1024
 
 // Executed Command:
@@ -26,6 +26,7 @@
 #![cfg_attr(rustfmt, rustfmt_skip)]
 #![allow(unused_parens)]
 #![allow(unused_imports)]
+#![allow(missing_docs)]
 #![allow(clippy::unnecessary_cast)]
 
 use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
@@ -43,19 +44,19 @@
 impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	// Storage: Maintenance Enabled (r:0 w:1)
 	fn enable() -> Weight {
-		Weight::from_ref_time(7_367_000)
-			.saturating_add(T::DbWeight::get().writes(1))
+		Weight::from_ref_time(10_860_000 as u64)
+			.saturating_add(T::DbWeight::get().writes(1 as u64))
 	}
 	// Storage: Maintenance Enabled (r:0 w:1)
 	fn disable() -> Weight {
-		Weight::from_ref_time(7_273_000)
-			.saturating_add(T::DbWeight::get().writes(1))
+		Weight::from_ref_time(10_871_000 as u64)
+			.saturating_add(T::DbWeight::get().writes(1 as u64))
 	}
-	// Storage: 
+	// Storage: Preimage StatusFor (r:1 w:0)
+	// Storage: Preimage PreimageFor (r:1 w:0)
 	fn execute_preimage() -> Weight {
-		Weight::from_ref_time(7_273_000)
-			.saturating_add(T::DbWeight::get().reads(2))
-			.saturating_add(T::DbWeight::get().writes(1))
+		Weight::from_ref_time(10_068_000 as u64)
+			.saturating_add(T::DbWeight::get().reads(2 as u64))
 	}
 }
 
@@ -63,18 +64,18 @@
 impl WeightInfo for () {
 	// Storage: Maintenance Enabled (r:0 w:1)
 	fn enable() -> Weight {
-		Weight::from_ref_time(7_367_000)
-			.saturating_add(RocksDbWeight::get().writes(1))
+		Weight::from_ref_time(10_860_000 as u64)
+			.saturating_add(RocksDbWeight::get().writes(1 as u64))
 	}
 	// Storage: Maintenance Enabled (r:0 w:1)
 	fn disable() -> Weight {
-		Weight::from_ref_time(7_273_000)
-			.saturating_add(RocksDbWeight::get().writes(1))
+		Weight::from_ref_time(10_871_000 as u64)
+			.saturating_add(RocksDbWeight::get().writes(1 as u64))
 	}
-	// Storage: 
+	// Storage: Preimage StatusFor (r:1 w:0)
+	// Storage: Preimage PreimageFor (r:1 w:0)
 	fn execute_preimage() -> Weight {
-		Weight::from_ref_time(7_273_000)
-			.saturating_add(RocksDbWeight::get().reads(2))
-			.saturating_add(RocksDbWeight::get().writes(1))
+		Weight::from_ref_time(10_068_000 as u64)
+			.saturating_add(RocksDbWeight::get().reads(2 as u64))
 	}
 }

--- a/runtime/common/maintenance.rs
+++ b/runtime/common/maintenance.rs
@@ -86,9 +86,6 @@
 				| RuntimeCall::Session(_)
 				| RuntimeCall::Identity(_) => Err(TransactionValidityError::Invalid(InvalidTransaction::Call)),
 
-				#[cfg(feature = "preimage")]
-				RuntimeCall::Preimage(_) => Err(TransactionValidityError::Invalid(InvalidTransaction::Call)),
-
 				#[cfg(feature = "pallet-test-utils")]
 				RuntimeCall::TestUtils(_) => Err(TransactionValidityError::Invalid(InvalidTransaction::Call)),
 

--- a/runtime/common/runtime_apis.rs
+++ b/runtime/common/runtime_apis.rs
@@ -568,6 +568,7 @@
                     #[cfg(feature = "foreign-assets")]
                     list_benchmark!(list, extra, pallet_foreign_assets, ForeignAssets);
 
+                    list_benchmark!(list, extra, pallet_maintenance, Maintenance);
 
                     // list_benchmark!(list, extra, pallet_evm_coder_substrate, EvmCoderSubstrate);
 
@@ -632,6 +633,8 @@
                     #[cfg(feature = "foreign-assets")]
                     add_benchmark!(params, batches, pallet_foreign_assets, ForeignAssets);
 
+                    add_benchmark!(params, batches, pallet_maintenance, Maintenance);
+
                     // add_benchmark!(params, batches, pallet_evm_coder_substrate, EvmCoderSubstrate);
 
                     if batches.is_empty() { return Err("Benchmark not found for this pallet.".into()) }

279  });279  });
280280
281  describe('Preimage Execution', () => {281  describe('Preimage Execution', () => {
282    let preimageHash: string;282    const preimageHashes: string[] = [];
283283
284    async function notePreimage(helper: UniqueHelper, preimage: any): Promise<string> {284    async function notePreimage(helper: UniqueHelper, preimage: any): Promise<string> {
285      const result = await helper.preimage.notePreimage(bob, preimage);285      const result = await helper.preimage.notePreimage(bob, preimage);
306          },306          },
307        ]);307        ]);
308        const preimage = helper.constructApiCall('api.tx.identity.forceInsertIdentities', [randomIdentities]).method.toHex();308        const preimage = helper.constructApiCall('api.tx.identity.forceInsertIdentities', [randomIdentities]).method.toHex();
309        preimageHash = await notePreimage(helper, preimage);309        preimageHashes.push(await notePreimage(helper, preimage));
310      });310      });
311    });311    });
312312
313    itSub('Successfully executes call in a preimage', async ({helper}) => {313    itSub('Successfully executes call in a preimage', async ({helper}) => {
314      const result = await expect(helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.executePreimage', [314      const result = await expect(helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.executePreimage', [
315        preimageHash, null, {refTime: 10000000000, proofSize: 10000000000},315        preimageHashes[0], {refTime: 10000000000, proofSize: 10000000000},
316      ])).to.be.fulfilled;316      ])).to.be.fulfilled;
317317
318      // preimage is executed, and an appropriate event is present318      // preimage is executed, and an appropriate event is present
319      const events = result.result.events.filter((x: any) => x.event.method === 'IdentitiesInserted' && x.event.section === 'identity');319      const events = result.result.events.filter((x: any) => x.event.method === 'IdentitiesInserted' && x.event.section === 'identity');
320      expect(events.length).to.be.equal(1);320      expect(events.length).to.be.equal(1);
321321
322      // the preimage goes back to being unrequested322      // the preimage goes back to being unrequested
323      expect(await helper.preimage.getPreimageInfo(preimageHash)).to.have.property('unrequested');323      expect(await helper.preimage.getPreimageInfo(preimageHashes[0])).to.have.property('unrequested');
324    });324    });
325325
326    itSub('Does not allow execution of a preimage that would fail', async ({helper}) => {326    itSub('Does not allow execution of a preimage that would fail', async ({helper}) => {
330        {Id: zeroAccount.address}, {Id: superuser.address}, 1000n,330        {Id: zeroAccount.address}, {Id: superuser.address}, 1000n,
331      ]).method.toHex();331      ]).method.toHex();
332      const preimageHash = await notePreimage(helper, preimage);332      const preimageHash = await notePreimage(helper, preimage);
333      preimageHashes.push(preimageHash);
333334
334      await expect(helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.executePreimage', [335      await expect(helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.executePreimage', [
335        preimageHash, null, {refTime: 100000000000, proofSize: 100000000000},336        preimageHash, {refTime: 100000000000, proofSize: 100000000000},
336      ])).to.be.rejectedWith(/balances\.InsufficientBalance/);337      ])).to.be.rejectedWith(/balances\.InsufficientBalance/);
337    });338    });
338339
339    itSub('Does not allow preimage execution with non-root', async ({helper}) => {340    itSub('Does not allow preimage execution with non-root', async ({helper}) => {
340      await expect(helper.executeExtrinsic(bob, 'api.tx.maintenance.executePreimage', [341      await expect(helper.executeExtrinsic(bob, 'api.tx.maintenance.executePreimage', [
341        preimageHash, null, {refTime: 100000000000, proofSize: 100000000000},342        preimageHashes[0], {refTime: 100000000000, proofSize: 100000000000},
342      ])).to.be.rejectedWith(/BadOrigin/);343      ])).to.be.rejectedWith(/BadOrigin/);
343    });344    });
344345
345    itSub('Does not allow execution of non-existent preimages', async ({helper}) => {346    itSub('Does not allow execution of non-existent preimages', async ({helper}) => {
346      await expect(helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.executePreimage', [347      await expect(helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.executePreimage', [
347        '0x1010101010101010101010101010101010101010101010101010101010101010', null, {refTime: 100000000000, proofSize: 100000000000},348        '0x1010101010101010101010101010101010101010101010101010101010101010', {refTime: 100000000000, proofSize: 100000000000},
348      ])).to.be.rejectedWith(/Unavailable/);349      ])).to.be.rejectedWith(/Unavailable/);
349    });350    });
350351
351    itSub('Does not allow preimage execution with less than minimum weights', async ({helper}) => {352    itSub('Does not allow preimage execution with less than minimum weights', async ({helper}) => {
352      await expect(helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.executePreimage', [353      await expect(helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.executePreimage', [
353        preimageHash, null, {refTime: 1000, proofSize: 1000},354        preimageHashes[0], {refTime: 1000, proofSize: 1000},
354      ])).to.be.rejectedWith(/Exhausted/);355      ])).to.be.rejectedWith(/Exhausted/);
355    });356    });
356357
357    after(async function() {358    after(async function() {
358      await usingPlaygrounds(async (helper) => {359      await usingPlaygrounds(async (helper) => {
359        if (helper.fetchMissingPalletNames([Pallets.Preimage, Pallets.Maintenance]).length != 0) return;360        if (helper.fetchMissingPalletNames([Pallets.Preimage, Pallets.Maintenance]).length != 0) return;
360361
362        for (const hash of preimageHashes) {
361        await helper.preimage.unnotePreimage(bob, preimageHash);363          await helper.preimage.unnotePreimage(bob, hash);
364        }
362      });365      });
363    });366    });
364  });367  });