今天我们继续宠物的高级部分
1 随机数
为了kitty 生成唯一的 id 和一些随机 dna, 可以生成随机种子
<system::Module<T>>::random_seed()
但随机种子不会因同一个块中的多个交易而发生变化, 所以我们还引入了一个可以管理的 nonce
random_hash 来填充我们的 kitty 的 id 和 dna
我们可以通过简单地检查此存储项是否已包含了特定 id 的映射来轻松检查冲突。
let sender = ensure_signed(origin)?;
let nonce = <Nonce<T>>::get();
let random_seed = <system::Module<T>>::random_seed();
let random_hash = (random_seed, sender, nonce).using_encoded(<T as system::Trait>::Hashing::hash);
<Nonce<T>>::mutate(|n| *n += 1);
#监测碰撞
ensure!(!<Kitties<T>>::exists(new_id), "This new id already exists");
2 创建event
为了知道执行函数是否完全成功，我们应该在函数结束时发出一个
Event，不仅要报告成功，还要告诉 "off-chain world" 某些特定的状态转换已经发生了。
// decl_event! 宏:
decl_event!(
pub enum Event<T>
where
<T as system::Trait>::AccountId,
<T as system::Trait>::Balance
{
MyEvent(u32, Balance),
MyOtherEvent(Balance, AccountId),
}
);
// 生成Event 类型，需要在 module 中暴露:
pub trait Trait: balances::Trait {
type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;
}
// Depositing 一个 Event
fn deposit_event<T>() = default;
// 函数结束时调用 deposit event
Self::deposit_event(RawEvent::MyEvent(my_value, my_balance));
更新 lib.rs
// `lib.rs`
...
impl mymodule::Trait for Runtime {
type Event = Event;
}
//construct_runtime! 宏中包含 Event 或Event<T> 类型到你的 module 定义中
// `lib.rs`
...
construct_runtime!(
pub enum Runtime with Log(InternalLog: DigestItem<Hash, Ed25519AuthorityId>) where
Block = Block,
NodeBlock = opaque::Block,
InherentData = BasicInherentData
{
...
MyModule: mymodule::{Module, Call, Storage, Event<T>},
}
);
...
3 创建List
Substrate 本身不支持 list 类型, 列表迭代通常是坏事。除非明确防范了其危险操作，否则它将为仅花费 O(1) 复杂度的操作添加无限制的 O(N) 复杂度
作为替代，你可以使用映射和计数器模拟列表
没有 "swap and pop" 的逻辑，但是我们会要求你使用一个 Index 存储项来追踪列表中每项的索引
decl_storage! {
trait Store for Module<T: Trait> as Example {
AllPeopleArray get(person): map u32 => T::AccountId;
AllPeopleCount get(num_of_people): u32;
}
}
//一个index 删除
AllPeopleIndex: map T::AccountId => u32;
4 检查溢出Overflow/Underflow
在更改存储状态之前，你必须始终主动检查可能的 runtime 错误。请记住，与 Ethereum 不同，当交易失败时，状态不会恢复到交易发生之前，因此你有责任确保在错误处理上不会产生任何副作用
在 Rust 中检查这些类型的错误非常简单，其中原始数字类型具有checked_add()和checked_sub()函数。
let new_all_people_count = all_people_count.checked_add(1).ok_or("Overflow adding a new person")?;
5 用tuple 去模拟高阶数组
只能用map去模拟:
MyFriendsArray get(my_friends_array): map (T::AccountId, u32) => T::AccountId;
MyFriendsCount get(my_friends_count): map T::AccountId => u32;
// 这样:
MyFriendsArray[AccountId][Index] -> AccountId
MyFriendsArray[AccountId].length()
// 相对索引, 定义:
MyFriendsIndex: map (T::AccountId, T::AccountId) => u32;
6 宠物代码
现在宠物的代码如下
use support::{decl_storage, decl_module, StorageValue, StorageMap,
dispatch::Result, ensure, decl_event};
use system::ensure_signed;
use runtime_primitives::traits::{As, Hash};
use parity_codec::{Encode, Decode};
#[derive(Encode, Decode, Default, Clone, PartialEq)]
#[cfg_attr(feature = "std", derive(Debug))]
pub struct Kitty<Hash, Balance> {
id: Hash,
dna: Hash,
price: Balance,
gen: u64,
}
pub trait Trait: balances::Trait {
type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;
}
decl_event!(
pub enum Event<T>
where
<T as system::Trait>::AccountId,
<T as system::Trait>::Hash
{
Created(AccountId, Hash),
}
);
decl_storage! {
trait Store for Module<T: Trait> as KittyStorage {
Kitties get(kitty): map T::Hash => Kitty<T::Hash, T::Balance>;
KittyOwner get(owner_of): map T::Hash => Option<T::AccountId>;
AllKittiesArray get(kitty_by_index): map u64 => T::Hash;
AllKittiesCount get(all_kitties_count): u64;
AllKittiesIndex: map T::Hash => u64;
OwnedKittiesArray get(kitty_of_owner_by_index): map (T::AccountId, u64) => T::Hash;
OwnedKittiesCount get(owned_kitty_count): map T::AccountId => u64;
OwnedKittiesIndex: map T::Hash => u64;
Nonce: u64;
}
}
decl_module! {
pub struct Module<T: Trait> for enum Call where origin: T::Origin {
fn deposit_event<T>() = default;
fn create_kitty(origin) -> Result {
let sender = ensure_signed(origin)?;
let owned_kitty_count = Self::owned_kitty_count(&sender);
let new_owned_kitty_count = owned_kitty_count.checked_add(1)
.ok_or("Overflow adding a new kitty to account balance")?;
let all_kitties_count = Self::all_kitties_count();
let new_all_kitties_count = all_kitties_count.checked_add(1)
.ok_or("Overflow adding a new kitty to total supply")?;
let nonce = <Nonce<T>>::get();
let random_hash = (<system::Module<T>>::random_seed(), &sender, nonce)
.using_encoded(<T as system::Trait>::Hashing::hash);
ensure!(!<KittyOwner<T>>::exists(random_hash), "Kitty already exists");
let new_kitty = Kitty {
id: random_hash,
dna: random_hash,
price: <T::Balance as As<u64>>::sa(0),
gen: 0,
};
<Kitties<T>>::insert(random_hash, new_kitty);
<KittyOwner<T>>::insert(random_hash, &sender);
<AllKittiesArray<T>>::insert(all_kitties_count, random_hash);
<AllKittiesCount<T>>::put(new_all_kitties_count);
<AllKittiesIndex<T>>::insert(random_hash, all_kitties_count);
<OwnedKittiesArray<T>>::insert((sender.clone(), owned_kitty_count), random_hash);
<OwnedKittiesCount<T>>::insert(&sender, new_owned_kitty_count);
<OwnedKittiesIndex<T>>::insert(random_hash, owned_kitty_count);
<Nonce<T>>::mutate(|n| *n += 1);
Self::deposit_event(RawEvent::Created(sender, random_hash));
Ok(())
}
}
}
重新build
./scripts/build.sh
cargo build --release
./target/release/substratekitties purge-chain --dev
./target/release/substratekitties --dev
6 查看结果
我们将让 Alice 创建 3 个 kitties，让 Bob 创建 2 个 kitties，让 Charlie 创建 1 个 kitty
注意: 每一笔交易必须用1个币, 所以要产生必须给bob和charlie打虚拟币
最后看结果,都可以经过map查看到:
image.png
8 重构私有
模块函数应该在, 公共接口应标记为 pub
impl<T: Trait> Module<T> {
// Your functions here
}
下面由自己实现吧
总结
本文用Rust实现了List和高阶数组功能,
Rust 有一定的随机数,在区块链随机数如何避免伪随机是很大问题
Rust没有list和数组, 都通过map来实现, 有点不直观, 也防止不安全的遍历方式
另外Rust对数据安全有着自己实现, 对于合约开发者必须注意..
还有对代码安全, 为了防止源码泄露, 对暴露代码必须注意
总言之就是为了安全放弃了开发效率, Rust也有很多和传统不一样的地方
