FRAME运行时的作者身份追踪。

这用于追踪当前区块作者和最近的叔块。

许可证：Apache-2.0

// 示例代码：pallet-authorship 基本配置
#[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 {
        /// 处理发现区块作者的事件
        type Event: From<Event<Self>> + IsType<<Self as frame_system::Config>::Event>;
        /// 作者身份处理
        type FindAuthor: FindAuthor<Self::AccountId>;
        /// 处理叔叔区块
        type UncleGenerations: Get<u32>;
        /// 过滤叔叔区块
        type FilterUncle: FilterUncle<Self::Header, Self::AccountId>;
    }

    #[pallet::event]
    #[pallet::generate_deposit(pub(super) fn deposit_event)]
    pub enum Event<T: Config> {
        /// 新区块作者被设置
        NewAuthor(T::AccountId),
    }

    #[pallet::storage]
    #[pallet::getter(fn author)]
    pub(super) type Author<T: Config> = StorageValue<_, T::AccountId, OptionQuery>;

    #[pallet::hooks]
    impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
        fn on_initialize(_n: BlockNumberFor<T>) -> Weight {
            // 清除当前作者
            Author::<T>::kill();
            Weight::zero()
        }

        fn on_finalize(_n: BlockNumberFor<T>) {
            // 确保作者已设置
            assert!(Author::<T>::exists(), "Author must be set at the end of the block.");
        }
    }

    #[pallet::call]
    impl<T: Config> Pallet<T> {
        /// 设置区块作者
        #[pallet::weight(10_000)]
        pub fn set_author(origin: OriginFor<T>, author: T::AccountId) -> DispatchResult {
            ensure_root(origin)?;
            Author::<T>::put(&author);
            Self::deposit_event(Event::NewAuthor(author));
            Ok(())
        }
    }
}

完整示例demo：

// pallet-authorship 完整实现示例
#![cfg_attr(not(feature = "std"), no_std)]

pub use pallet::*;

#[frame_support::pallet]
pub mod pallet {
    use frame_support::{
        pallet_prelude::*,
        traits::{FindAuthor, FilterUncle, Get},
    };
    use frame_system::pallet_prelude::*;
    use sp_runtime::traits::Header as HeaderT;
    use sp_std::prelude::*;

    /// 作者身份模块配置
    #[pallet::config]
    pub trait Config: frame_system::Config {
        /// 系统事件类型
        type Event: From<Event<Self>> + IsType<<Self as frame_system::Config>::Event>;
        /// 查找作者实现
        type FindAuthor: FindAuthor<Self::AccountId>;
        /// 叔叔区块代数
        type UncleGenerations: Get<u32>;
        /// 叔叔区块过滤器
        type FilterUncle: FilterUncle<Self::Header, Self::AccountId>;
        /// 权重信息
        type WeightInfo: WeightInfo;
    }

    /// 作者身份模块
    #[pallet::pallet]
    #[pallet::generate_store(pub(super) trait Store)]
    pub struct Pallet<T>(_);

    /// 模块事件
    #[pallet::event]
    #[pallet::generate_deposit(pub(super) fn deposit_event)]
    pub enum Event<T: Config> {
        /// 新区块作者被设置
        AuthorSet(T::AccountId),
        /// 叔叔区块被添加
        UncleIncluded(u32, T::AccountId),
    }

    /// 错误类型
    #[pallet::error]
    pub enum Error<T> {
        /// 作者未找到
        AuthorNotFound,
        /// 无效的叔叔区块
        InvalidUncle,
        /// 叔叔区块已存在
        UncleAlreadyIncluded,
    }

    /// 当前区块作者存储
    #[pallet::storage]
    #[pallet::getter(fn author)]
    pub(super) type Author<T: Config> = StorageValue<_, T::AccountId, OptionQuery>;

    /// 叔叔区块存储
    #[pallet::storage]
    pub(super) type Uncles<T: Config> = StorageValue<
        _,
        Vec<<T::Header as HeaderT>::Hash>,
        ValueQuery,
    >;

    /// 模块hooks实现
    #[pallet::hooks]
    impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
        /// 区块初始化
        fn on_initialize(_n: BlockNumberFor<T>) -> Weight {
            // 清除当前作者
            Author::<T>::kill();
            T::WeightInfo::on_initialize()
        }

        /// 区块最终化
        fn on_finalize(_n: BlockNumberFor<T>) {
            // 验证作者已设置
            assert!(Author::<T>::exists(), "Block author must be set");
        }
    }

    /// 可调用函数
    #[pallet::call]
    impl<T: Config> Pallet<T> {
        /// 设置区块作者
        #[pallet::weight(T::WeightInfo::set_author())]
        pub fn set_author(
            origin: OriginFor<T>,
            author: T::AccountId,
        ) -> DispatchResultWithPostInfo {
            ensure_root(origin)?;
            
            Author::<T>::put(&author);
            Self::deposit_event(Event::AuthorSet(author));
            
            Ok(().into())
        }

        /// 添加叔叔区块
        #[pallet::weight(T::WeightInfo::add_uncle())]
        pub fn add_uncle(
            origin: OriginFor<T>,
            uncle_hash: <T::Header as HeaderT>::Hash,
            author: T::AccountId,
        ) -> DispatchResultWithPostInfo {
            ensure_root(origin)?;

            // 验证叔叔区块
            ensure!(
                T::FilterUncle::filter_uncle(uncle_hash, &author),
                Error::<T>::InvalidUncle
            );

            // 检查是否已包含
            let mut uncles = Uncles::<T>::get();
            ensure!(
                !uncles.contains(&uncle_hash),
                Error::<T>::UncleAlreadyIncluded
            );

            // 添加叔叔区块
            uncles.push(uncle_hash);
            Uncles::<T>::put(uncles);

            Self::deposit_event(Event::UncleIncluded(
                T::UncleGenerations::get(),
                author,
            ));

            Ok(().into())
        }
    }

    /// 权重信息trait
    pub trait WeightInfo {
        fn on_initialize() -> Weight;
        fn set_author() -> Weight;
        fn add_uncle() -> Weight;
    }

    /// 默认权重实现
    impl WeightInfo for () {
        fn on_initialize() -> Weight {
            Weight::from_ref_time(10_000)
        }
        fn set_author() -> Weight {
            Weight::from_ref_time(20_000)
        }
        fn add_uncle() -> Weight {
            Weight::from_ref_time(30_000)
        }
    }

    /// 作者身份模块接口
    impl<T: Config> Pallet<T> {
        /// 获取当前作者
        pub fn current_author() -> Option<T::AccountId> {
            Author::<T>::get()
        }

        /// 获取所有叔叔区块
        pub fn uncles() -> Vec<<T::Header as HeaderT>::Hash> {
            Uncles::<T>::get()
        }

        /// 清除叔叔区块
        pub fn clear_uncles() {
            Uncles::<T>::kill();
        }
    }
}

/// 测试模块
#[cfg(test)]
mod tests {
    use super::*;
    use frame_support::{
        assert_ok, parameter_types,
        traits::{ConstU32, ConstU64},
    };
    use sp_core::H256;
    use sp_runtime::{
        testing::Header,
        traits::{BlakeTwo256, IdentityLookup},
    };

    type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Test>;
    type Block = frame_system::mocking::MockBlock<Test>;

    frame_support::construct_runtime!(
        pub enum Test where
            Block = Block,
            NodeBlock = Block,
            UncheckedExtrinsic = UncheckedExtrinsic,
        {
            System: frame_system::{Pallet, Call, Config, Storage, Event<T>},
            Authorship: pallet_authorship::{Pallet, Call, Storage, Event<T>},
        }
    );

    parameter_types! {
        pub const BlockHashCount: u64 = 250;
        pub const SS58Prefix: u8 = 42;
    }

    impl frame_system::Config for Test {
        type BaseCallFilter = frame_support::traits::Everything;
        type BlockWeights = ();
        type BlockLength = ();
        type DbWeight = ();
        type Origin = Origin;
        type Call = Call;
        type Index = u64;
        type BlockNumber = u64;
        type Hash = H256;
        type Hashing = BlakeTwo256;
        type AccountId = u64;
        type Lookup = IdentityLookup<Self::AccountId>;
        type Header = Header;
        type Event = Event;
        type BlockHashCount = ConstU64<250>;
        type Version = ();
        type PalletInfo = PalletInfo;
        type AccountData = ();
        type OnNewAccount = ();
        type OnKilledAccount = ();
        type SystemWeightInfo = ();
        type SS58Prefix = ConstU8<42>;
        type OnSetCode = ();
        type MaxConsumers = ConstU32<16>;
    }

    parameter_types! {
        pub const UncleGenerations: u32 = 5;
    }

    pub struct TestFindAuthor;
    impl FindAuthor<u64> for TestFindAuthor {
        fn find_author<'a, I>(_digests: I) -> Option<u64>
        where
            I: 'a + IntoIterator<Item = (frame_support::ConsensusEngineId, &'a [u8])>,
        {
            Some(1)
        }
    }

    pub struct TestFilterUncle;
    impl FilterUncle<Header, u64> for TestFilterUncle {
        fn filter_uncle(_hash: H256, _author: &u64) -> bool {
            true
        }
    }

    impl Config for Test {
        type Event = Event;
        type FindAuthor = TestFindAuthor;
        type UncleGenerations = UncleGenerations;
        type FilterUncle = TestFilterUncle;
        type WeightInfo = ();
    }

    #[test]
    fn test_set_author() {
        new_test_ext().execute_with(|| {
            // 设置作者
            assert_ok!(Authorship::set_author(Origin::root(), 42));
            
            // 验证事件
            assert_eq!(
                System::events().last().unwrap().event,
                Event::Authorship(crate::Event::AuthorSet(42))
            );
            
            // 验证存储
            assert_eq!(Authorship::author(), Some(42));
        });
    }

    #[test]
    fn test_add_uncle() {
        new_test_ext().execute_with(|| {
            let uncle_hash = H256::repeat_byte(1);
            
            // 添加叔叔区块
            assert_ok!(Authorship::add_uncle(Origin::root(), uncle_hash, 123));
            
            // 验证事件
            assert_eq!(
                System::events().last().unwrap().event,
                Event::Authorship(crate::Event::UncleIncluded(5, 123))
            );
            
            // 验证存储
            assert!(Authorship::uncles().contains(&uncle_hash));
        });
    }
}