Utility Module

一个无状态的模块，提供用于调度管理的辅助功能，无需重新认证。

概述

这个模块包含两个基本功能：

1. 批量调度：无状态操作，允许任何来源在单次调度中执行多个调用。这可用于合并提案，将set_code与相应的set_storage结合起来，或用于通过单个签名验证进行高效的多重支付。

2. 伪名调度：无状态操作，允许签名来源从替代签名来源执行调用。每个账户有2 * 2^16个可能的"伪名"(替代账户ID)，这些可以堆叠。作为密钥管理工具非常有用，当您需要多个不同的账户(例如作为许多质押账户的控制器)，但由相同的底层密钥对控制。

由于代理过滤器在这个模块的所有调度中都受到尊重，因此它永远不需要被任何代理过滤。

接口

可调度函数

批量调度

• batch - 从发送者的来源调度多个调用

伪名调度

• as_derivative - 从派生签名来源调度一个调用

许可证：Apache-2.0

完整示例代码

// 导入必要的模块
use frame_support::{dispatch::DispatchResult, traits::Currency};
use frame_system::Config as SystemConfig;
use pallet_utility::{self as utility, Call as UtilityCall};
use sp_runtime::traits::StaticLookup;
use sp_std::prelude::*;

// 定义我们的运行时配置
pub trait Config: utility::Config + SystemConfig {}

// 实现批量调用的示例
pub fn batch_calls<T: Config>(
    origin: T::Origin,
    calls: Vec<<T as SystemConfig>::Call>,
) -> DispatchResult {
    // 创建Utility模块的batch调用
    UtilityCall::<T>::batch(calls).dispatch_bypass_filter(origin)
}

// 实现伪名调用的示例
pub fn as_derivative_call<T: Config>(
    origin: T::Origin,
    index: u16,
    call: Box<<T as SystemConfig>::Call>,
) -> DispatchResult {
    // 创建Utility模块的as_derivative调用
    UtilityCall::<T>::as_derivative(index, call).dispatch_bypass_filter(origin)
}

// 示例测试用例
#[cfg(test)]
mod tests {
    use super::*;
    use crate::mock::{new_test_ext, Runtime, System};
    use frame_support::{assert_ok, dispatch::DispatchError};
    use pallet_balances::Call as BalancesCall;
    
    #[test]
    fn test_batch_calls() {
        new_test_ext().execute_with(|| {
            let alice = 1u64;
            let bob = 2u64;
            System::set_block_number(1);
            
            // 创建批量调用
            let calls = vec![
                RuntimeCall::Balances(BalancesCall::transfer {
                    dest: bob,
                    value: 10,
                }),
                RuntimeCall::Balances(BalancesCall::transfer {
                    dest: alice,
                    value: 20,
                }),
            ];
            
            // 执行批量调用
            assert_ok!(batch_calls::<Runtime>(Origin::signed(alice), calls));
        });
    }
    
    #[test]
    fn test_as_derivative_call() {
        new_test_ext().execute_with(|| {
            let alice = 1u64;
            let bob = 2u64;
            System::set_block_number(1);
            
            // 创建派生调用
            let call = Box::new(RuntimeCall::Balances(BalancesCall::transfer {
                dest: bob,
                value: 10,
            }));
            
            // 执行派生调用
            assert_ok!(as_derivative_call::<Runtime>(Origin::signed(alice), 0, call));
        });
    }
}

这个示例展示了如何使用pallet-utility模块的批量调度和伪名调度功能。批量调度允许在一个交易中执行多个调用，而伪名调度允许从派生账户执行调用。代码包含了基本的实现和测试用例，展示了如何使用这些功能。

扩展完整示例

下面是一个更完整的示例，展示如何在Substrate运行时中使用Utility模块：

//! 演示如何使用Utility模块的完整示例

use frame_support::{
    construct_runtime, parameter_types,
    traits::{Currency, Everything},
    weights::Weight,
};
use frame_system::EnsureRoot;
use sp_core::H256;
use sp_runtime::{
    testing::Header,
    traits::{BlakeTwo256, IdentityLookup},
    Perbill,
};

// 定义类型别名
type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Runtime>;
type Block = frame_system::mocking::MockBlock<Runtime>;

// 构建运行时结构
construct_runtime!(
    pub enum Runtime where
        Block = Block,
        NodeBlock = Block,
        UncheckedExtrinsic = UncheckedExtrinsic,
    {
        System: frame_system::{Pallet, Call, Config, Storage, Event<T>},
        Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
        Utility: pallet_utility::{Pallet, Call, Event},
    }
);

// 参数类型配置
parameter_types! {
    pub const BlockHashCount: u64 = 250;
    pub const MaximumBlockWeight: Weight = 1024;
    pub const MaximumBlockLength: u32 = 2 * 1024;
    pub const AvailableBlockRatio: Perbill = Perbill::from_percent(75);
}

// 实现系统配置
impl frame_system::Config for Runtime {
    type BaseCallFilter = 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 = BlockHashCount;
    type Version = ();
    type PalletInfo = PalletInfo;
    type AccountData = pallet_balances::AccountData<u64>;
    type OnNewAccount = ();
    type OnKilledAccount = ();
    type SystemWeightInfo = ();
    type SS58Prefix = ();
    type OnSetCode = ();
}

// 实现余额配置
parameter_types! {
    pub const ExistentialDeposit: u64 = 1;
}

impl pallet_balances::Config for Runtime {
    type Balance = u64;
    type DustRemoval = ();
    type Event = Event;
    type ExistentialDeposit = ExistentialDeposit;
    type AccountStore = System;
    type WeightInfo = ();
    type MaxLocks = ();
    type MaxReserves = ();
    type ReserveIdentifier = [u8; 8];
}

// 实现Utility模块配置
impl pallet_utility::Config for Runtime {
    type Event = Event;
    type Call = Call;
    type WeightInfo = ();
}

// 测试环境设置
pub fn new_test_ext() -> sp_io::TestExternalities {
    let mut t = frame_system::GenesisConfig::default()
        .build_storage::<Runtime>()
        .unwrap();
    pallet_balances::GenesisConfig::<Runtime> {
        balances: vec![(1, 100), (2, 100)],
    }
    .assimilate_storage(&mut t)
    .unwrap();
    t.into()
}

// 测试Utility模块功能
#[test]
fn test_utility_module() {
    new_test_ext().execute_with(|| {
        // 测试批量调用
        let calls = vec![
            Call::Balances(pallet_balances::Call::transfer {
                dest: 2,
                value: 10,
            }),
            Call::Balances(pallet_balances::Call::transfer {
                dest: 1,
                value: 20,
            }),
        ];
        assert_ok!(Utility::batch(Origin::signed(1), calls));
        
        // 测试伪名调用
        let call = Box::new(Call::Balances(pallet_balances::Call::transfer {
            dest: 2,
            value: 5,
        }));
        assert_ok!(Utility::as_derivative(Origin::signed(1), 0, call));
    });
}

这个完整示例展示了：

1. 如何配置Utility模块作为一个pallet集成到运行时中
2. 如何设置测试环境
3. 如何在实际运行环境中使用批量调度和伪名调度功能
4. 包含完整的类型定义和配置实现

测试用例验证了Utility模块的核心功能，包括批量执行多个调用和通过派生账户执行调用。