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

[georgepisaltu]

Looks great, just some comments and questions

[georgepisaltu]

Worth mentioning that generally when we have an Option<Result<(... we should have a dedicated type for the return, but I think this will never be manually implemented and having it like this makes it easier to work with in the macros. Users get to see TransactionValidityWithRefund as the authorize closure return type, so in terms of UX it's good.

[github-actions]

Command "update-ui" has started 🚀 See logs here

[github-actions]

Command "update-ui" has finished ✅ See logs here