pallet-utility: if_else

cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/pallet_utility.rs

@@ -99,4 +99,12 @@ impl<T: frame_system::Config> pallet_utility::WeightInfo for WeightInfo<T> {
 			// Standard Error: 1_745
 			.saturating_add(Weight::from_parts(6_562_902, 0).saturating_mul(c.into()))
 	}
+	fn if_else() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 6_000_000 picoseconds.
+		Weight::from_parts(7_000_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+	}
 }

cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/pallet_utility.rs

@@ -98,4 +98,12 @@ impl<T: frame_system::Config> pallet_utility::WeightInfo for WeightInfo<T> {
 			// Standard Error: 3_765
 			.saturating_add(Weight::from_parts(6_028_416, 0).saturating_mul(c.into()))
 	}
+	fn if_else() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 6_000_000 picoseconds.
+		Weight::from_parts(7_000_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+	}
 }

cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/pallet_utility.rs

@@ -98,4 +98,12 @@ impl<T: frame_system::Config> pallet_utility::WeightInfo for WeightInfo<T> {
 			// Standard Error: 1_601
 			.saturating_add(Weight::from_parts(5_138_293, 0).saturating_mul(c.into()))
 	}
+	fn if_else() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 6_000_000 picoseconds.
+		Weight::from_parts(7_000_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+	}
 }

cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/pallet_utility.rs

@@ -99,4 +99,12 @@ impl<T: frame_system::Config> pallet_utility::WeightInfo for WeightInfo<T> {
 			// Standard Error: 1_601
 			.saturating_add(Weight::from_parts(5_138_293, 0).saturating_mul(c.into()))
 	}
+	fn if_else() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 6_000_000 picoseconds.
+		Weight::from_parts(7_000_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+	}
 }

cumulus/parachains/runtimes/collectives/collectives-westend/src/weights/pallet_utility.rs

@@ -98,4 +98,12 @@ impl<T: frame_system::Config> pallet_utility::WeightInfo for WeightInfo<T> {
 			// Standard Error: 1_395
 			.saturating_add(Weight::from_parts(5_000_971, 0).saturating_mul(c.into()))
 	}
+	fn if_else() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 6_000_000 picoseconds.
+		Weight::from_parts(7_000_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+	}
 }

cumulus/parachains/runtimes/coretime/coretime-rococo/src/weights/pallet_utility.rs

@@ -99,4 +99,12 @@ impl<T: frame_system::Config> pallet_utility::WeightInfo for WeightInfo<T> {
 			// Standard Error: 1_621
 			.saturating_add(Weight::from_parts(3_312_302, 0).saturating_mul(c.into()))
 	}
+	fn if_else() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 6_000_000 picoseconds.
+		Weight::from_parts(7_000_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+	}
 }

cumulus/parachains/runtimes/coretime/coretime-westend/src/weights/pallet_utility.rs

@@ -99,4 +99,12 @@ impl<T: frame_system::Config> pallet_utility::WeightInfo for WeightInfo<T> {
 			// Standard Error: 740
 			.saturating_add(Weight::from_parts(2_800_888, 0).saturating_mul(c.into()))
 	}
+	fn if_else() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 6_000_000 picoseconds.
+		Weight::from_parts(7_000_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+	}
 }

cumulus/parachains/runtimes/people/people-rococo/src/weights/pallet_utility.rs

@@ -96,4 +96,12 @@ impl<T: frame_system::Config> pallet_utility::WeightInfo for WeightInfo<T> {
 			// Standard Error: 3_915
 			.saturating_add(Weight::from_parts(4_372_646, 0).saturating_mul(c.into()))
 	}
+	fn if_else() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 6_000_000 picoseconds.
+		Weight::from_parts(7_000_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+	}
 }

cumulus/parachains/runtimes/people/people-westend/src/weights/pallet_utility.rs

@@ -96,4 +96,12 @@ impl<T: frame_system::Config> pallet_utility::WeightInfo for WeightInfo<T> {
 			// Standard Error: 7_605
 			.saturating_add(Weight::from_parts(4_306_193, 0).saturating_mul(c.into()))
 	}
+	fn if_else() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 6_000_000 picoseconds.
+		Weight::from_parts(7_000_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+	}
 }

polkadot/runtime/rococo/src/weights/pallet_utility.rs

@@ -99,4 +99,12 @@ impl<T: frame_system::Config> pallet_utility::WeightInfo for WeightInfo<T> {
 			// Standard Error: 460
 			.saturating_add(Weight::from_parts(3_173_577, 0).saturating_mul(c.into()))
 	}
+	fn if_else() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 6_000_000 picoseconds.
+		Weight::from_parts(7_000_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+	}
 }

polkadot/runtime/westend/src/weights/pallet_utility.rs

@@ -99,4 +99,12 @@ impl<T: frame_system::Config> pallet_utility::WeightInfo for WeightInfo<T> {
 			// Standard Error: 2_817
 			.saturating_add(Weight::from_parts(5_113_539, 0).saturating_mul(c.into()))
 	}
+	fn if_else() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 6_000_000 picoseconds.
+		Weight::from_parts(7_000_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+	}
 }

prdoc/pr_6321.prdoc

@@ -0,0 +1,32 @@
+title: pallet-utility: if_else
+
+doc:
+  - audience: Runtime Dev
+    description: This PR adds the `if_else` call to `pallet-utility`
+    enabling an error fallback when the main call is unsuccessful.
+
+crates:
+    - name: asset-hub-rococo-runtime
+      bump: major
+    - name: asset-hub-westend-runtime
+      bump: major
+    - name: bridge-hub-rococo-runtime
+      bump: major
+    - name: bridge-hub-westend-runtime
+      bump: major
+    - name: collectives-westend-runtime
+      bump: major
+    - name: coretime-rococo-runtime
+      bump: major
+    - name: coretime-westend-runtime
+      bump: major
+    - name: people-rococo-runtime
+      bump: major
+    - name: people-westend-runtime
+      bump: major
+    - name: rococo-runtime
+      bump: major
+    - name: westend-runtime
+      bump: major
+    - name: pallet-utility
+      bump: major

substrate/frame/utility/src/benchmarking.rs

@@ -92,6 +92,18 @@ mod benchmark {
 		assert_last_event::<T>(Event::BatchCompleted.into());
 	}
 
+	#[benchmark]
+	fn if_else() {
+		let main_call = Box::new(frame_system::Call::remark { remark: vec![0] }.into());
+		let fallback_call = Box::new(frame_system::Call::remark { remark: vec![1] }.into());
+		let caller = whitelisted_caller();
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller), main_call, fallback_call);
+
+		assert_last_event::<T>(Event::IfElseMainSuccess.into());
+	}
+
 	impl_benchmark_test_suite! {
 		Pallet,
 		tests::new_test_ext(),

substrate/frame/utility/src/lib.rs

@@ -120,6 +120,12 @@ pub mod pallet {
 		ItemFailed { error: DispatchError },
 		/// A call was dispatched.
 		DispatchedAs { result: DispatchResult },
+		/// Main call was dispatched.
+		IfElseMainSuccess,
+		/// The fallback call was dispatched.
+		IfElseFallbackSuccess { main_error: DispatchError }, 
+		/// Both calls failed.
+		IfElseBothFailure { main_error: DispatchError, fallback_error: DispatchError },
 	}
 
 	// Align the call size to 1KB. As we are currently compiling the runtime for native/wasm
@@ -159,6 +165,8 @@ pub mod pallet {
 	pub enum Error<T> {
 		/// Too many calls batched.
 		TooManyCalls,
+		/// Multiple call failure.
+		InvalidCalls,
 	}
 
 	#[pallet::call]
@@ -454,6 +462,98 @@ pub mod pallet {
 			let res = call.dispatch_bypass_filter(frame_system::RawOrigin::Root.into());
 			res.map(|_| ()).map_err(|e| e.error)
 		}
+
+		/// Dispatch a fallback call in the event the main call fails to execute.
+		///
+		/// This function first attempts to dispatch the `main` call. If the `main` call fails, the `fallback` call
+		/// is dispatched instead. Both calls are executed with the same origin, and the weight of both calls
+		/// is accumulated and returned. The success or failure of the main and fallback calls is tracked and
+		/// appropriate events are deposited.
+		///
+		/// May be called from any origin except `None`.
+		///
+		/// - `main`: The main call to be dispatched. This is the primary action to execute.
+		/// - `fallback`: The fallback call to be dispatched in case the `main` call fails.
+		///
+		/// ## Dispatch Logic
+		/// - If the origin is `root`, both the main and fallback calls are executed without applying any origin filters.
+		/// - If the origin is not `root`, the origin filter is applied to both the `main` and `fallback` calls.
+		///
+		/// ## Complexity
+		/// - O(1) for the origin check and dispatching the main call.
+		/// - O(1) for the origin check and dispatching the fallback call (if needed).
+		/// - Overall complexity is O(1) since we only dispatch at most two calls.
+		///
+		/// ## Weight
+		/// The weight of this call is calculated as the sum of:
+		/// - The weight of the `main` call (if it is executed),
+		/// - The weight of the `fallback` call (if the `main` call fails and the `fallback` is executed),
+		/// - A base weight (`WeightInfo::if_else()`), which accounts for the logic involved in dispatching and handling both calls.
+		#[pallet::call_index(6)]
+		#[pallet::weight({
+			let main_dispatch_info = main.get_dispatch_info();
+			let fallback_dispatch_info = fallback.get_dispatch_info();
+			(
+				T::WeightInfo::if_else()
+					.saturating_add(main_dispatch_info.call_weight)
+					.saturating_add(fallback_dispatch_info.call_weight),
+				main_dispatch_info.class,
+			)
+		})]
+		pub fn if_else(
+			origin: OriginFor<T>,
+			main: Box<<T as Config>::RuntimeCall>,
+			fallback: Box<<T as Config>::RuntimeCall>,
+		) -> DispatchResultWithPostInfo {
+			// Do not allow the `None` origin.
+			if ensure_none(origin.clone()).is_ok() {
+				return Err(BadOrigin.into());
+			}
+
+			let is_root = ensure_root(origin.clone()).is_ok();
+
+			// Track the weights
+			let mut weight = T::WeightInfo::if_else();
+
+			let info = main.get_dispatch_info();
+
+			// Execute the main call first
+			let main_result = if is_root {
+				main.dispatch_bypass_filter(origin.clone())
+			} else {
+				main.dispatch(origin.clone())
+			};
+
+			// Add weight of the main call
+			weight = weight.saturating_add(extract_actual_weight(&main_result, &info));
+
+			if let Err(main_error) = main_result {
+				// If the main call failed, execute the fallback call
+				let fallback_info = fallback.get_dispatch_info();
+
+				let fallback_result = if is_root {
+					fallback.dispatch_bypass_filter(origin.clone())
+				} else {
+					fallback.dispatch(origin)
+				};
+
+				// Add weight of the fallback call
+				weight =
+					weight.saturating_add(extract_actual_weight(&fallback_result, &fallback_info));
+
+				if let Err(fallback_error) = fallback_result {
+					// Both calls have faild.
+					Self::deposit_event(Event::IfElseBothFailure { main_error: main_error.error, fallback_error: fallback_error.error });
+					return Err(sp_runtime::DispatchErrorWithPostInfo { error: Error::<T>::InvalidCalls.into(), post_info: Some(weight).into() })
+				}
+				// Fallback succeeded.
+				Self::deposit_event(Event::IfElseFallbackSuccess { main_error: main_error.error });
+				return Ok(Some(weight).into());
+			}
+			// Main call succeeded.
+			Self::deposit_event(Event::IfElseMainSuccess);
+			Ok(Some(weight).into())
+		}
 	}
 
 	impl<T: Config> Pallet<T> {

substrate/frame/utility/src/tests.rs

@@ -914,3 +914,79 @@ fn with_weight_works() {
 		);
 	})
 }
+
+#[test]
+fn if_else_with_root_works() {
+	new_test_ext().execute_with(|| {
+		let k = b"a".to_vec();
+		let call = RuntimeCall::System(frame_system::Call::set_storage {
+			items: vec![(k.clone(), k.clone())],
+		});
+		assert!(!TestBaseCallFilter::contains(&call));
+		assert_eq!(Balances::free_balance(1), 10);
+		assert_eq!(Balances::free_balance(2), 10);
+		assert_ok!(Utility::if_else(
+			RuntimeOrigin::root(),
+			Box::new(RuntimeCall::Balances(BalancesCall::force_transfer {
+				source: 1,
+				dest: 2,
+				value: 11
+			})),
+			Box::new(call),
+		));
+		assert_eq!(Balances::free_balance(1), 10);
+		assert_eq!(Balances::free_balance(2), 10);
+		assert_eq!(storage::unhashed::get_raw(&k), Some(k));
+	});
+}
+
+#[test]
+fn if_else_with_signed_works() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(Balances::free_balance(1), 10);
+		assert_eq!(Balances::free_balance(2), 10);
+		assert_ok!(Utility::if_else(
+			RuntimeOrigin::signed(1),
+			Box::new(call_transfer(2, 11)),
+			Box::new(call_transfer(2, 5))
+		));
+		assert_eq!(Balances::free_balance(1), 5);
+		assert_eq!(Balances::free_balance(2), 15);
+
+		System::assert_last_event(utility::Event::IfElseFallbackSuccess { main_error: TokenError::FundsUnavailable.into() }.into());
+	});
+}
+
+#[test]
+fn if_else_successful_main_call() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(Balances::free_balance(1), 10);
+		assert_eq!(Balances::free_balance(2), 10);
+		assert_ok!(Utility::if_else(
+			RuntimeOrigin::signed(1),
+			Box::new(call_transfer(2, 9)),
+			Box::new(call_transfer(2, 1))
+		));
+		assert_eq!(Balances::free_balance(1), 1);
+		assert_eq!(Balances::free_balance(2), 19);
+
+		System::assert_last_event(utility::Event::IfElseMainSuccess.into());
+	})
+}
+
+#[test]
+fn if_else_failing_else_call() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(Balances::free_balance(1), 10);
+		assert_eq!(Balances::free_balance(2), 10);
+		assert_err_ignore_postinfo!(Utility::if_else(
+			RuntimeOrigin::signed(1),
+			Box::new(call_transfer(2, 11)),
+			Box::new(call_transfer(2, 11))
+		), utility::Error::<Test>::InvalidCalls);
+		assert_eq!(Balances::free_balance(1), 10);
+		assert_eq!(Balances::free_balance(2), 10);
+
+		System::assert_last_event(utility::Event::IfElseBothFailure { main_error: TokenError::FundsUnavailable.into(), fallback_error: TokenError::FundsUnavailable.into()}.into());
+	})
+}