substrate基础(8)-添加智能合约pallet到runtime

区块链 / Substrate / 基础
Word count: 2k   |   Reading time≈ 9 min

本文依旧基于substrate-node-template 进行操作.
该项目主要是为了方便开发人员调试和测试，以及初次接触substrate的入门者首选，掌握该项目后，再去接触正式项目，会容易很多
本文假定你已经编译好了这个项目，具体编译可以参考本系列第一篇文章：substrate基础(1)-substrate-node-template编译及部署

本文是要将智能合约的pallet添加到runtime中

1. 添加合约模块

1.1 添加依赖

在项目根目录，编辑文件runtime/Cargo.toml：
在[dependencies]下添加：

1
2
3
4
# pallet-contracts：不要直接复制我的。其中的version default-features branch请参考该[dependencies]中相同git属性别的依赖所使用的，保持一致即可，否则编译很可能会失败。
pallet-contracts = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.24" }
# pallet-contracts-primitives：建议前往substrate的branch分支，找对应的pallet-contracts，在cargo.toml文件中，找到正确的pallet-contracts-primitives版本号
pallet-contracts-primitives = { version = "6.0.0", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.24" }

在[features]的std[]中，添加如下两行：

1
2
'pallet-contracts/std',
'pallet-contracts-primitives/std',

然后在当前目录runtime/下检测是否能够编译成功：

1
2
cargo check -p pallet-contracts
cargo check -p pallet-contracts-primitives

1.2 在runtime中添加contract相关配置

注：由于合约版本问题，需要根据编译提示，对以下代码做相应调整。（默认官方提供的示例代码我是跑不通，自己按如下做的调整），具体每步骤如下：

  1. 编辑runtime/src/lib.rs，在pub use frame_support代码块中的traits中添加上Nothing，如下：
1
2
3
traits::{
    ConstU128, ConstU32, ConstU64, ConstU8, KeyOwnerProofSystem, Randomness, StorageInfo,Nothing
},
  1. 编辑runtime/src/lib.rs，添加如下：
1
2
3
4
//在这行代码之后
use pallet_transaction_payment::CurrencyAdapter;
//添加这一行
use pallet_contracts::weights::WeightInfo;
  1. 编辑runtime/src/lib.rs，添加如下静态变量：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//索引到在这三行之后
pub const MINUTES: BlockNumber = 60_000 / (MILLISECS_PER_BLOCK as BlockNumber);
pub const HOURS: BlockNumber = MINUTES * 60;
pub const DAYS: BlockNumber = HOURS * 24;

/* 添加下方代码 */
// Contracts price units.
pub const MILLICENTS: Balance = 1_000_000_000;
pub const CENTS: Balance = 1_000 * MILLICENTS;
pub const DOLLARS: Balance = 100 * CENTS;

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

/// Assume ~10% of the block weight is consumed by `on_initialize` handlers.
/// This is used to limit the maximal weight of a single extrinsic.
const AVERAGE_ON_INITIALIZE_RATIO: Perbill = Perbill::from_percent(10);
  1. 编辑runtime/src/lib.rs，在方法impl pallet_timestamp::Config for Runtime{ xxx }之后增加如下代码块：
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
parameter_types! {
	pub const DepositPerStorageByte: Balance = deposit(0, 1);
	pub const DepositPerStorageItem: Balance = deposit(1, 0);
	pub RentFraction: Perbill = Perbill::from_rational(1u32, 30 * DAYS);
	pub const SurchargeReward: Balance = 150 * MILLICENTS;
	pub const SignedClaimHandicap: u32 = 2;
	pub const MaxValueSize: u32 = 16 * 1024;
	// The lazy deletion runs inside on_initialize.
	pub DeletionWeightLimit: Weight = AVERAGE_ON_INITIALIZE_RATIO *
	 BlockWeights::get().max_block;
	// The weight needed for decoding the queue should be less or equal than a fifth
	// of the overall weight dedicated to the lazy deletion.
	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 WeightPrice = pallet_transaction_payment::Pallet<Self>;
    type WeightInfo = pallet_contracts::weights::SubstrateWeight<Self>;
    type ChainExtension = ();
    type DeletionQueueDepth = DeletionQueueDepth;
    type DeletionWeightLimit = DeletionWeightLimit;
    type Call = Call;
    /// The safest default is to allow no calls at all.
    ///
    /// Runtimes should whitelist dispatchables that are allowed to be called from contracts
    /// and make sure they are stable. Dispatchables exposed to contracts are not allowed to
    /// change because that would break already deployed contracts. The `Call` structure itself
    /// is not allowed to change the indices of existing pallets, too.
    type CallFilter = Nothing;
    type Schedule = Schedule;
    type CallStack = [pallet_contracts::Frame<Self>; 31];

    type DepositPerByte = DepositPerStorageByte;
    type ContractAccessWeight = pallet_contracts::DefaultContractAccessWeight<BlockWeights>;
    type DepositPerItem = DepositPerStorageItem;
    type AddressGenerator =  pallet_contracts::DefaultAddressGenerator;
    type MaxCodeLen = ConstU32<{ 128 * 1024 }>;
    type RelaxedMaxCodeLen = ConstU32<{ 256 * 1024 }>;
}

6runtime/src/lib.rs，在construct_runtime!宏代码块中的Runtime枚举添加下方代码：

1
Contracts: pallet_contracts::{Pallet, Call, Storage, Event<T>},
  1. 然后在runtime/目录下检测是否能够编译成功：
1
cargo check -p node-template-runtime

2. 公开contract的接口

2.1 添加依赖

在项目根目录，编辑文件runtime/Cargo.toml：
在[dependencies]下添加：

1
2
# pallet-contracts：不要直接复制我的。其中的version default-features branch请参考该[dependencies]中相同git属性别的依赖所使用的，保持一致即可，否则编译很可能会失败。
pallet-contracts-rpc-runtime-api = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.24" }

在[features]的std[]中，添加如下两行：

1
'pallet-contracts-rpc-runtime-api/std',

然后在当前目录runtime/下检测是否能够编译成功：

1
cargo check -p pallet-contracts-rpc-runtime-api

2.2 在runtime中添加contract接口相关配置

  1. 在代码块impl_runtime_apis!{xxx}中追加如下代码：
    注：需要根据导入的依赖版本号对如下代码进行调整，我这里直接用官方提供的代码会报错，根据自己的版本号做了改动。具体你也可以去substrate对应版本中找相应新的代码该如何更改
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
impl pallet_contracts_rpc_runtime_api::ContractsApi<
		Block, AccountId, Balance, BlockNumber, Hash,
	>
		for Runtime
	{
		fn call(
			origin: AccountId,
			dest: AccountId,
			value: Balance,
			gas_limit: u64,
			storage_deposit_limit: Option<Balance>,
			input_data: Vec<u8>,
		) -> pallet_contracts_primitives::ContractExecResult<Balance> {
			Contracts::bare_call(origin, dest, value, gas_limit, storage_deposit_limit, input_data, true)
		}

		fn instantiate(
			origin: AccountId,
			value: Balance,
			gas_limit: u64,
			storage_deposit_limit: Option<Balance>,
			code: pallet_contracts_primitives::Code<Hash>,
			data: Vec<u8>,
			salt: Vec<u8>,
		) -> pallet_contracts_primitives::ContractInstantiateResult<AccountId, Balance>
		{
			Contracts::bare_instantiate(origin, value, gas_limit, storage_deposit_limit, code, data, salt, true)
		}

		fn upload_code(
			origin: AccountId,
			code: Vec<u8>,
			storage_deposit_limit: Option<Balance>,
		) -> pallet_contracts_primitives::CodeUploadResult<Hash, Balance>
		{
			Contracts::bare_upload_code(origin, code, storage_deposit_limit)
		}

		fn get_storage(
			address: AccountId,
			key: [u8; 32],
		) -> pallet_contracts_primitives::GetStorageResult {
			Contracts::get_storage(address, key)
		}
	}
  1. 然后在runtime/目录下检测是否能够编译成功：
1
cargo check -p node-template-runtime

3. 更新外部节点

前面对合约做了变更，那外部节点相应的代码也需要做一些调整，以便兼容合约

3.1 添加依赖

在项目根目录，编辑文件node/Cargo.toml：
在[dependencies]下添加：

1
2
3
# pallet-contracts：不要直接复制我的。其中的version default-features branch请参考该[dependencies]中相同git属性别的依赖所使用的，保持一致即可，否则编译很可能会失败。
pallet-contracts = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.24" }
pallet-contracts-rpc = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.24" }

然后在当前目录runtime/下检测是否能够编译成功：

1
cargo check -p pallet-contracts

3.2 添加配置

和官方提供文档提供的有些许不一样，根据实际情况要做调整，此处只是满足我能够正常运行起来
在项目根目录，编辑文件node/src/rpc.rs：

  1. 增加两行：
1
2
3
4
//这个是原本就有这一行，后面加上BlockNumber和Hash
use node_template_runtime::{opaque::Block, AccountId, Balance, Index, BlockNumber, Hash};  //这个是原本就有这一行，后面加上BlockNumber和Hash
//新增这一行
use pallet_contracts_rpc::{Contracts, ContractsApi};
  1. 在pub fn create_full<C, P>代码块中：
1
2
3
4
5
6
7
8
// 该行之后
C::Api: substrate_frame_rpc_system::AccountNonceApi<Block, AccountId, Index>,
//新增这一行：
C::Api: pallet_contracts_rpc::ContractsRuntimeApi<Block, AccountId, Balance, BlockNumber, Hash>,
//该行之后
module.merge(TransactionPayment::new(client).into_rpc())?;
//新增这一行
module.merge(Contracts::new(client.clone()).into_rpc())?;

3然后在项目根目录下检测是否能够编译成功：

1
cargo check -p node-template-runtime

4. 启动节点并连接页面进行交互

4.1 编译并启动节点

回到项目根目录，编译节点：

1
cargo build --release

启动节点

1
./target/release/node-template --dev --base-path ./tmp/

4.2 启动web

substrate-front-end-template 可视化，具体编译和部署，请自行查阅资料或参考:substrate基础(1)-substrate-node-template编译及部署

4.3 操作相应接口

在web页面中，根据需要操作相应接口

总结

本文通过加入智能合约模块到节点中的流程，来让开发者了解模块功能整合的整体过程，由浅及深。
按照本文流程，每个结果都可以复现的，亲自实现的。

本文编辑完毕

参考

[1] Substrate官方文档

Donate
  • Copyright： Copyright is owned by the author. For commercial reprints, please contact the author for authorization. For non-commercial reprints, please indicate the source.
  • Copyrights © 2017-2023 Jason
  • Visitors: | Views:

谢谢打赏～

微信