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/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()) }

--- a/tests/src/maintenance.seqtest.ts
+++ b/tests/src/maintenance.seqtest.ts
@@ -279,7 +279,7 @@
   });
 
   describe('Preimage Execution', () => {
-    let preimageHash: string;
+    const preimageHashes: string[] = [];
 
     async function notePreimage(helper: UniqueHelper, preimage: any): Promise<string> {
       const result = await helper.preimage.notePreimage(bob, preimage);
@@ -306,13 +306,13 @@
           },
         ]);
         const preimage = helper.constructApiCall('api.tx.identity.forceInsertIdentities', [randomIdentities]).method.toHex();
-        preimageHash = await notePreimage(helper, preimage);
+        preimageHashes.push(await notePreimage(helper, preimage));
       });
     });
 
     itSub('Successfully executes call in a preimage', async ({helper}) => {
       const result = await expect(helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.executePreimage', [
-        preimageHash, null, {refTime: 10000000000, proofSize: 10000000000},
+        preimageHashes[0], {refTime: 10000000000, proofSize: 10000000000},
       ])).to.be.fulfilled;
 
       // preimage is executed, and an appropriate event is present
@@ -320,7 +320,7 @@
       expect(events.length).to.be.equal(1);
 
       // the preimage goes back to being unrequested
-      expect(await helper.preimage.getPreimageInfo(preimageHash)).to.have.property('unrequested');
+      expect(await helper.preimage.getPreimageInfo(preimageHashes[0])).to.have.property('unrequested');
     });
 
     itSub('Does not allow execution of a preimage that would fail', async ({helper}) => {
@@ -330,27 +330,28 @@
         {Id: zeroAccount.address}, {Id: superuser.address}, 1000n,
       ]).method.toHex();
       const preimageHash = await notePreimage(helper, preimage);
+      preimageHashes.push(preimageHash);
 
       await expect(helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.executePreimage', [
-        preimageHash, null, {refTime: 100000000000, proofSize: 100000000000},
+        preimageHash, {refTime: 100000000000, proofSize: 100000000000},
       ])).to.be.rejectedWith(/balances\.InsufficientBalance/);
     });
 
     itSub('Does not allow preimage execution with non-root', async ({helper}) => {
       await expect(helper.executeExtrinsic(bob, 'api.tx.maintenance.executePreimage', [
-        preimageHash, null, {refTime: 100000000000, proofSize: 100000000000},
+        preimageHashes[0], {refTime: 100000000000, proofSize: 100000000000},
       ])).to.be.rejectedWith(/BadOrigin/);
     });
 
     itSub('Does not allow execution of non-existent preimages', async ({helper}) => {
       await expect(helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.executePreimage', [
-        '0x1010101010101010101010101010101010101010101010101010101010101010', null, {refTime: 100000000000, proofSize: 100000000000},
+        '0x1010101010101010101010101010101010101010101010101010101010101010', {refTime: 100000000000, proofSize: 100000000000},
       ])).to.be.rejectedWith(/Unavailable/);
     });
 
     itSub('Does not allow preimage execution with less than minimum weights', async ({helper}) => {
       await expect(helper.getSudo().executeExtrinsic(superuser, 'api.tx.maintenance.executePreimage', [
-        preimageHash, null, {refTime: 1000, proofSize: 1000},
+        preimageHashes[0], {refTime: 1000, proofSize: 1000},
       ])).to.be.rejectedWith(/Exhausted/);
     });
 
@@ -358,7 +359,9 @@
       await usingPlaygrounds(async (helper) => {
         if (helper.fetchMissingPalletNames([Pallets.Preimage, Pallets.Maintenance]).length != 0) return;
 
-        await helper.preimage.unnotePreimage(bob, preimageHash);
+        for (const hash of preimageHashes) {
+          await helper.preimage.unnotePreimage(bob, hash);
+        }
       });
     });
   });