Substrate高级语法3宠物合约--by Skyh0715

今天我们继续宠物的高级部分

1 随机数

为了kitty 生成唯一的 id 和一些随机 dna, 可以生成随机种子>::random_seed()
但随机种子不会因同一个块中的多个交易而发生变化, 所以我们还引入了一个可以管理的 nonce
random_hash 来填充我们的 kitty 的 id 和 dna
我们可以通过简单地检查此存储项是否已包含了特定 id 的映射来轻松检查冲突。

let sender = ensure_signed(origin)?;
let nonce = >::get();
let random_seed = >::random_seed();

let random_hash = (random_seed, sender, nonce).using_encoded(::Hashing::hash);

>::mutate(|n| *n += 1);
#监测碰撞
ensure!(!>::exists(new_id), "This new id already exists");

2 创建event

为了知道执行函数是否完全成功，我们应该在函数结束时发出一个 Event，不仅要报告成功，还要告诉 "off-chain world" 某些特定的状态转换已经发生了。

// decl_event! 宏:
decl_event!(
    pub enum Event
    where
        ::AccountId,
        ::Balance
    {
        MyEvent(u32, Balance),
        MyOtherEvent(Balance, AccountId),
    }
);
// 生成Event 类型，需要在 module 中暴露:
pub trait Trait: balances::Trait {
    type Event: From> + Into<::Event>;
}
// Depositing 一个 Event
fn deposit_event() = 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 类型到你的 module 定义中
// `lib.rs`
...
construct_runtime!(
    pub enum Runtime with Log(InternalLog: DigestItem) where
        Block = Block,
        NodeBlock = opaque::Block,
        InherentData = BasicInherentData
    {
        ...
        MyModule: mymodule::{Module, Call, Storage, Event},
    }
);
...

3 创建List

Substrate 本身不支持 list 类型, 列表迭代通常是坏事。除非明确防范了其危险操作，否则它将为仅花费 O(1) 复杂度的操作添加无限制的 O(N) 复杂度
作为替代，你可以使用映射和计数器模拟列表
没有 "swap and pop" 的逻辑，但是我们会要求你使用一个 Index 存储项来追踪列表中每项的索引

decl_storage! {
    trait Store for Module 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 {
    id: Hash,
    dna: Hash,
    price: Balance,
    gen: u64,
}

pub trait Trait: balances::Trait {
    type Event: From> + Into<::Event>;
}

decl_event!(
    pub enum Event
    where
        ::AccountId,
        ::Hash
    {
        Created(AccountId, Hash),
    }
);

decl_storage! {
    trait Store for Module as KittyStorage {
        Kitties get(kitty): map T::Hash => Kitty;
        KittyOwner get(owner_of): map T::Hash => Option;

        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 for enum Call where origin: T::Origin {

        fn deposit_event() = 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 = >::get();
            let random_hash = (>::random_seed(), &sender, nonce)
                .using_encoded(::Hashing::hash);

            ensure!(!>::exists(random_hash), "Kitty already exists");

            let new_kitty = Kitty {
                id: random_hash,
                dna: random_hash,
                price: >::sa(0),
                gen: 0,
            };

            >::insert(random_hash, new_kitty);
            >::insert(random_hash, &sender);

            >::insert(all_kitties_count, random_hash);
            >::put(new_all_kitties_count);
            >::insert(random_hash, all_kitties_count);

            >::insert((sender.clone(), owned_kitty_count), random_hash);
            >::insert(&sender, new_owned_kitty_count);
            >::insert(random_hash, owned_kitty_count);

            >::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 Module {
    // Your functions here
}

下面由自己实现吧

总结

本文用Rust实现了List和高阶数组功能,
Rust 有一定的随机数,在区块链随机数如何避免伪随机是很大问题
Rust没有list和数组, 都通过map来实现, 有点不直观, 也防止不安全的遍历方式
另外Rust对数据安全有着自己实现, 对于合约开发者必须注意..

还有对代码安全, 为了防止源码泄露, 对暴露代码必须注意
总言之就是为了安全放弃了开发效率, Rust也有很多和传统不一样的地方