สร้าง ERC-20 Token ด้วย ink! Part 1/2

1
#![cfg_attr(not(feature = "std"), no_std)]
2

3
use ink_lang as ink;
4

5
#[ink::contract]
6
mod erc20 {
7
    use ink_storage::{
8
        traits::SpreadAllocate,
9
        Mapping,
10
    };
11

12
    /// Create storage for a simple ERC-20 contract.
13
    #[ink(storage)]
14
    #[derive(SpreadAllocate)]
15
    pub struct Erc20 {
16
        /// Total token supply.
17
        total_supply: Balance,
18
        /// Mapping from owner to number of owned tokens.
19
        balances: Mapping<AccountId, Balance>,
20
    }
21

22
    impl Erc20 {
23
        /// Create a new ERC-20 contract with an initial supply.
24
        #[ink(constructor)]
25
        pub fn new(initial_supply: Balance) -> Self {
26
            // Initialize mapping for the contract.
27
            ink_lang::utils::initialize_contract(|contract| {
28
                Self::new_init(contract, initial_supply)
29
            })
30
        }
31

32
        /// Initialize the ERC-20 contract with the specified initial supply.
33
        fn new_init(&mut self, initial_supply: Balance) {
34
            let caller = Self::env().caller();
35
            self.balances.insert(&caller, &initial_supply);
36
            self.total_supply = initial_supply;
37
        }
38

39
        /// Returns the total token supply.
40
        #[ink(message)]
41
        pub fn total_supply(&self) -> Balance {
42
            self.total_supply
43
        }
44

45
        /// Returns the account balance for the specified `owner`.
46
        #[ink(message)]
47
        pub fn balance_of(&self, owner: AccountId) -> Balance {
48
            self.balances.get(owner).unwrap_or_default()
49
        }
50
    }
51

52
        #[cfg(test)]
53
        mod tests {
54
        use super::*;
55

56
        use ink_lang as ink;
57

58
        #[ink::test]
59
        fn new_works() {
60
            let contract = Erc20::new(777);
61
            assert_eq!(contract.total_supply(), 777);
62
        }
63

64
        #[ink::test]
65
        fn balance_works() {
66
            let contract = Erc20::new(100);
67
            assert_eq!(contract.total_supply(), 100);
68
            assert_eq!(contract.balance_of(AccountId::from([0x1; 32])), 100);
69
            assert_eq!(contract.balance_of(AccountId::from([0x0; 32])), 0);
70
        }
71
    }
72
}

1
#[derive(Debug, PartialEq, Eq, scale::Encode, scale::Decode)]
2
#[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
3
pub enum Error {
4
    /// Return if the balance cannot fulfill a request.
5
    InsufficientBalance,
6
}
7

8
pub type Result<T> = core::result::Result<T, Error>;

1
fn new_init(&mut self, initial_supply: Balance) {
2
  let caller = Self::env().caller();
3
  self.balances.insert(&caller, &initial_supply);
4
  self.total_supply = initial_supply;
5
  Self::env().emit_event(Transfer {
6
      from: None,
7
      to: Some(caller),
8
      value: initial_supply,
9
  });
10
}

1
fn transfer_from_to(
2
    &mut self,
3
    from: &AccountId,
4
    to: &AccountId,
5
    value: Balance,
6
) -> Result<()> {
7
    let from_balance = self.balance_of_impl(from);
8

9
    // 1. เช็คว่า ถ้า balance ของ from น้อยกว่า value ที่จะส่ง ต้องส่งไม่ได้
10
    if from_balance < value {
11
        return Err(Error::InsufficientBalance);
12
    }
13

14
    // 2. ลด balance ของ from
15
    self.balances.insert(from, &(from_balance - value));
16
    let to_balance = self.balance_of_impl(to);
17

18
    // 3. เพิ่ม balance ให้ to
19
    self.balances.insert(to, &(to_balance + value));
20

21
    self.env().emit_event(Transfer {
22
        from: Some(*from),
23
        to: Some(*to),
24
        value,
25
    });
26
    Ok(())
27
}

1
#[ink::test]
2
fn transfer_works() {
3
    let mut erc20 = Erc20::new(100);
4
    assert_eq!(erc20.balance_of(AccountId::from([0x0; 32])), 0);
5
    assert_eq!(erc20.transfer(AccountId::from([0x0; 32]), 10), Ok(()));
6
    assert_eq!(erc20.balance_of(AccountId::from([0x0; 32])), 10);
7
}