[Tx ext stage 2: 2/4] Introduce #[pallet::authorize(...)] macro attribute and AuthorizeCall system transaction extension

[gui1117]

Meta

This PR is part of 4 PR:

• [Tx ext stage 2: 1/4] Add TransactionSource as argument in TransactionExtension::validate #6323
• [Tx ext stage 2: 2/4] Introduce #[pallet::authorize(...)] macro attribute and AuthorizeCall system transaction extension #6324
• [Tx ext stage 2: 3/4] use #[pallet::authorize(...)] to migrate unsigned in system: tasks + apply_authorized_call #6325
• [Tx ext stage 2: 4/4] use #[pallet::authorize(...)] to migrate all unsigned in polkadot-sdk #6326

Description

• new attribute #[pallet::authorize(..)], this attributes takes a function which returns the validity of the call.
• new attribute #[pallet::weight_of_authorize(..)], same as #[pallet::weight(..)] defines the pre dispatch weight of the authorize function. It can also be retrieved from WeightInfo under the name: authorize_$call_name.
• new trait Authorize in frame-support: implemented on the call for pallets and runtime, and used by AuthorizeCall transaction extension in frame-system.
• new origin variant in frame origin: Origin::Authorized: a bit similar to Unsigned but used for general transactions.
• new transaction extension: AuthorizeCall in frame system. This is meant to be used first in the transaction extension pipeline. It will call the authorize function and change the origin to authorized
• new method: ensure_authorized.

Usage

# #[allow(unused)]
#[frame_support::pallet]
pub mod pallet {
    use frame_support::pallet_prelude::*;
    use frame_system::pallet_prelude::*;
                                                                                   
    #[pallet::pallet]
    pub struct Pallet<T>(_);
                                                                                   
    #[pallet::config]
    pub trait Config: frame_system::Config {}
                                                                                   
    #[pallet::call]
    impl<T: Config> Pallet<T> {
        #[pallet::weight(Weight::zero())]
        #[pallet::authorize(|_source, foo| if *foo == 42 {
            let refund = Weight::zero();
            let validity = ValidTransaction::default();
            Ok((validity, refund))
        } else {
            Err(TransactionValidityError::Invalid(InvalidTransaction::Call))
        })]
        #[pallet::weight_of_authorize(Weight::zero())]
        #[pallet::call_index(0)]
        pub fn some_call(origin: OriginFor<T>, arg: u32) -> DispatchResult {
            ensure_authorized(origin)?;
                                                                                   
            Ok(())
        }
                                                                                   
        #[pallet::weight(Weight::zero())]
        // We can also give the callback as a function
        #[pallet::authorize(Pallet::<T>::authorize_some_other_call)]
        #[pallet::weight_of_authorize(Weight::zero())]
        #[pallet::call_index(1)]
        pub fn some_other_call(origin: OriginFor<T>, arg: u32) -> DispatchResult {
            ensure_authorized(origin)?;
                                                                                   
            Ok(())
        }
    }
                                                                                   
    impl<T: Config> Pallet<T> {
        fn authorize_some_other_call(
            source: TransactionSource,
            foo: &u32
        ) -> TransactionValidityWithRefund {
            if *foo == 42 {
                let refund = Weight::zero();
                let validity = ValidTransaction::default();
                Ok((validity, refund))
            } else {
                Err(TransactionValidityError::Invalid(InvalidTransaction::Call))
            }
        }
    }
                                                                                   
    #[frame_benchmarking::v2::benchmarks]
    mod benchmarks {
        use super::*;
        use frame_benchmarking::v2::BenchmarkError;
                                                                                   
        #[benchmark]
        fn authorize_some_call() -> Result<(), BenchmarkError> {
            let call = Call::<T>::some_call { arg: 42 };
                                                                                   
            #[block]
            {
                use frame_support::pallet_prelude::Authorize;
                call.authorize(TransactionSource::External)
                    .ok_or("Call must give some authorization")??;
            }
                                                                                   
            Ok(())
        }
    }
}