substrate进阶(5)-不同pallet之间的使用

区块链 / Substrate / pallet进阶
Word count: 1.6k   |   Reading time≈ 8 min

不同pallet之间的使用

1. 概述

多个pallet之间的调用，主要有以下几种情况：

  1. 调用现有的pallet：即在pallet的config中定义类型，然后runtime中使用时指定这个类型为frame中指定某个现成的pallet；
  2. 调用自定义的pallet：即在pallet的config中定义类型，然后runtime中使用时指定这个类型为frame中指定某个自定义的pallet；
  3. 封装和扩展现有的pallet。

2. 调用现有的pallet

runtime/lib.rs中:

1
2
3
4
5
6
7
8
9
//定义：
construct_runtime!() {
  Balances: pallet_balances,
}

//对应Config中直接引入：
impl pallet_contracts::Config for Runtime {
    type Currency = Balances;
}

3. 调用自定义的pallet

通过案例来说明：pallet2调用pallet1：

  1. pallet1作为被调用者，先实现：
    先定义一个trait.rs文件：
1
2
3
4
5
pub trait StorageInterface{
  type Value;
  fn get_param() -> Self::Value;
  fn set_param(v: Self::Value);
}

lib.rs中内容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
#![cfg_attr(not(feature = "std"), no_std)]
pub use pallet::*;
pub use traits::StorageInterface;
pub mod traits;

#[frame_support::pallet]
pub mod pallet {
  use codec::Codec;
  use frame_support::{
    pallet_prelude::*, 
    sp_runtime::traits::AtLeast32BitUnsigned, 
    sp_std::fmt::Debug,
  };
  use frame_system::pallet_prelude::*;

  #[pallet::pallet]
  #[pallet::generate_store(pub(super) trait Store)]
  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 Value: Member
      + Parameter
      + AtLeast32BitUnsigned
      + Codec
      + From<u32>
      + Into<u32>
      + Copy
      + Debug
      + Default
      + MaxEncodedLen
      + MaybeSerializeDeserialize;
  }

  #[pallet::storage]
  pub type MyValue<T: Config> = 
       StorageValue<_, T::Value, ValueQuery>;

  #[pallet::event]
  #[pallet::generate_deposit(pub(super) fn deposit_event)]
  pub enum Event<T: Config> {
    FunctionCall,
  }

  #[pallet::call]
  impl<T: Config> Pallet<T> {
    #[pallet::weight(0)]
    pub fn my_function(
      origin: OriginFor<T>,
    ) -> DispatchResultWithPostInfo {
      ensure_signed(origin)?;
      log::info!(target: "storage pallet1", "my function!");
      Self::deposit_event(Event::FunctionCall);
      Ok(().into())
    }
  }
}

// 注意此处：我们为pallet实现了前面定义的trait StorageInterface.
impl<T: Config> StorageInterface for Pallet<T> {
  type Value = T::Value;

  fn get_param() -> Self::Value {
    MyValue::<T>::get()
  }

  fn set_param(v: Self::Value) {
    MyValue::<T>::put(v);
  }
}
  1. pallet1做为调用者：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
#![cfg_attr(not(feature = "std"), no_std)]
pub use pallet::*;

#[frame_support::pallet]
pub mod pallet {
  use codec::Codec;
  use frame_support::{
    pallet_prelude::*, 
    sp_runtime::traits::AtLeast32BitUnsigned, 
    sp_std::fmt::Debug,
  };
  use frame_system::pallet_prelude::*;
  //引入pallet1中定义的trait
  use pallet1::traits::StorageInterface;

  #[pallet::pallet]
  #[pallet::generate_store(pub(super) trait Store)]
  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 Value: Member
      + Parameter
      + AtLeast32BitUnsigned
      + Codec
      + From<u32>
      + Into<u32>
      + Copy
      + Debug
      + Default
      + MaxEncodedLen
      + MaybeSerializeDeserialize;
    //定义了MyStorage类型，要求其实现trait StorageInterface
    type MyStorage: StorageInterface<Value = Self::Value>; 
  }

  #[pallet::event]
  #[pallet::generate_deposit(pub(super) fn deposit_event)]
  pub enum Event<T: Config> {
    StoreEvent,
  }

  #[pallet::call]
  impl<T: Config> Pallet<T> {
    #[pallet::weight(0)]
    pub fn storage_value(
      origin: OriginFor<T>,
      value: T::Value, 
    ) -> DispatchResultWithPostInfo {
      ensure_signed(origin)?;

      T::MyStorage::set_param(value);

   //使用trait StorageInterface中的函数
      let v = T::MyStorage::get_param();
      log::info!(target: "pallet1", 
           "Value get from storage is: {:?}", v);
      Self::deposit_event(Event::StoreEvent);
      Ok(().into())
    }
  }
}

在runtime/src/lib.rs中加入相关引用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//添加下面4行
impl pallet2::Config for Runtime {
  type Event = Event;
  type Value = u32;
}

//添加下面5行
impl pallet2::Config for Runtime {
  type Event = Event;
  type Value = u32;
  //调用pallet2  
  type MyStorage = Pallet2; 
}

construct_runtime!(
  pub enum Runtime where
    Block = Block,
    NodeBlock = opaque::Block,
    UncheckedExtrinsic = UncheckedExtrinsic
  {
    System: frame_system,
  ...
  //添加下面两行
    Pallet2: pallet2, 
    Pallet1: pallet1,
  }
);

别的非重要步骤这里就不展示了

4. 封装和扩展现有的pallet

为了更直观解释，这里使用如下案例：
使用substrate提供的contracts pallet，然后对其中的功能进行封装。封装中，将contracts pallet的call函数封装成sudo_call，即需要root权限才能调用。同时，在runtime中加载contracts时，去掉直接调用contracts函数的方式。
也就是说，对外只暴露封装后pallet的方法

整个方式分成两大步骤：

  1. 编写extend-pallet;
  2. 在runtime配置extend-pallet和contracts pallet。

备注：这表示，最终在页面上只能看到extend-pallet对外暴露的方法，而contracts pallet的方法不再对外展示。

4.1 编写extend-pallet

extend-pallet的lib.rs中：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
#![cfg_attr(not(feature = "std"), no_std)]

use codec::{Encode, HasCompact};
use frame_support::traits::Currency;
use scale_info::TypeInfo;
use sp_core::crypto::UncheckedFrom;
use sp_runtime::traits::StaticLookup;
use sp_std::{fmt::Debug, prelude::*};

type BalanceOf<T> = 
  <<T as pallet_contracts::Config>::Currency as Currency<
  <T as frame_system::Config>::AccountId,>>::Balance;
pub use pallet::*;

#[frame_support::pallet]
pub mod pallet {
  use super::*;
  use frame_support::pallet_prelude::*;
  use frame_system::pallet_prelude::*;

  #[pallet::pallet]
  #[pallet::generate_store(pub(super) trait Store)]
  pub struct Pallet<T>(_);

  // 重点关注1：封装pallet的Config需要集成被封装pallet的Config
  #[pallet::config]
  pub trait Config: pallet_contracts::Config + frame_system::Config {}
  
  // 重点关注2：对主要pallet-contracts的call函数进行封装，在这部分里面，添加判断root权限的语句，然后直接调用pallet-contracts的call函数。
  #[pallet::call]
  impl<T: Config> Pallet<T>
  where
    T::AccountId: UncheckedFrom<T::Hash>,
    T::AccountId: AsRef<[u8]>,
    <BalanceOf<T> as HasCompact>::Type: Clone 
     + Eq + PartialEq + Debug + TypeInfo + Encode,
  {
    #[pallet::weight(0)]
    pub fn sudo_call(
      origin: OriginFor<T>,
      dest: <T::Lookup as StaticLookup>::Source,
      #[pallet::compact] value: BalanceOf<T>,
      #[pallet::compact] gas_limit: Weight,
      storage_deposit_limit: Option<<BalanceOf<T> 
           as codec::HasCompact>::Type>,
      data: Vec<u8>,
    ) -> DispatchResultWithPostInfo {
      //添加下面这行，用于判断是否是root权限
      ensure_root(origin.clone())?;

      //直接调用pallet-contracts的call函数
      pallet_contracts::Pallet::<T>::call(
        origin,
        dest,
        value,
        gas_limit,
        storage_deposit_limit,
        data,
      )
    }
  }
}

4.2 在runtime配置extend-pallet和contracts pallet

将extend-pallet和contracts pallet加载到runtime中，需要修改runtime/src/lib.rs如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
// 1、配置Contracts pallet
use pallet_contracts::weights::WeightInfo;
const AVERAGE_ON_INITIALIZE_RATIO: Perbill = Perbill::from_percent(10);

pub mod currency {
  use node_primitives::Balance;

  pub const MILLICENTS: Balance = 1_000_000_000;
  // assume this is worth about a cent.
  pub const CENTS: Balance = 1_000 * MILLICENTS; 
  pub const DOLLARS: Balance = 100 * CENTS;

  pub const fn deposit(items: u32, bytes: u32) -> Balance {
    items as Balance * 15 * CENTS + (bytes as Balance) * 6 * CENTS
  }
}

parameter_types! {
  pub const DepositPerItem: Balance = currency::deposit(1, 0);
  pub const DepositPerByte: Balance = currency::deposit(0, 1);
  pub const MaxValueSize: u32 = 16 * 1024;
  pub DeletionWeightLimit: Weight = AVERAGE_ON_INITIALIZE_RATIO *
    BlockWeights::get().max_block;
  pub DeletionQueueDepth: u32 = ((DeletionWeightLimit::get() / (
      <Runtime as pallet_contracts::Config>::WeightInfo::on_initialize_per_queue_item(1) -
      <Runtime as pallet_contracts::Config>::WeightInfo::on_initialize_per_queue_item(0)
    )) / 5) as u32;
  pub Schedule: pallet_contracts::Schedule<Runtime> = Default::default();
}

impl pallet_contracts::Config for Runtime {
  type Time = Timestamp;
  type Randomness = RandomnessCollectiveFlip;
  type Currency = Balances;
  type Event = Event;
  type Call = Call;
  type CallFilter = Nothing;
  type DepositPerItem = DepositPerItem;
  type DepositPerByte = DepositPerByte;
  type CallStack = [pallet_contracts::Frame<Self>; 31];
  type WeightPrice = pallet_transaction_payment::Pallet<Self>;
  type WeightInfo = pallet_contracts::weights::SubstrateWeight<Self>;
  type ChainExtension = ();
  type DeletionQueueDepth = DeletionQueueDepth;
  type DeletionWeightLimit = DeletionWeightLimit;
  type Schedule = Schedule;
  type AddressGenerator = pallet_contracts::DefaultAddressGenerator;
}

// 2、配置extends pallet
impl pallet_extend_pallet::Config for Runtime {}

// 3、在runtime中定义两个pallet
construct_runtime!(
  pub enum Runtime where
    Block = Block,
    NodeBlock = opaque::Block,
    UncheckedExtrinsic = UncheckedExtrinsic
  {
    System: frame_system,
          //...
    // 注意下面两行的区别: 一定要去掉Call
    // 将它的Call部分去掉了，这也就表示我们在runtime层面没有对外暴露Contracts的调度函数接口，这样用户只能使用ExtendContracts提供的sudo_call函数，而不能使用Contracts的调度函数。 
    // Contracts: pallet_contracts::{Pallet, Call, Storage, Event<T>},
    Contracts: pallet_contracts::{Pallet, Storage, Event<T>},
    ExtendContracts: pallet_extend_pallet,
  }
);

总结

本文编辑完毕

  • Copyrights © 2017-2023 Jason
  • Visitors: | Views:

谢谢打赏～

微信