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

1
pub struct Erc20 {
2
    /// Balances that can be transferred by non-owners: (owner, spender) -> allowed
3
    allowances: Mapping<(AccountId, AccountId), Balance>,
4
}

1
#[ink(event)]
2
pub struct Approval {
3
    #[ink(topic)]
4
    owner: AccountId,
5
    #[ink(topic)]
6
    spender: AccountId,
7
    value: Balance,
8
}

1
#[derive(Debug, PartialEq, Eq, scale::Encode, scale::Decode)]
2
#[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
3
pub enum Error {
4
    InsufficientBalance,
5
    InsufficientAllowance,
6
}

1
/// Create storage for a simple ERC-20 contract.
2
#[ink(storage)]
3
#[derive(SpreadAllocate)]
4
pub struct Erc20 {
5
    /// Total token supply.
6
    total_supply: Balance,
7
    /// Mapping from owner to number of owned tokens.
8
    balances: Mapping<AccountId, Balance>,
9
    /// Balances that can be transferred by non-owners: (owner, spender) -> allowed
10
    allowances: Mapping<(AccountId, AccountId), Balance>,
11
}

1
#[ink(message)]
2
pub fn approve(&mut self, spender: AccountId, value: Balance) -> Result<()> {
3
  let owner = self.env().caller();
4
  self.allowances.insert((&owner, &spender), &value);
5
  self.env().emit_event(Approval {
6
    owner,
7
    spender,
8
    value,
9
  });
10
  Ok(())
11
}

1
#[ink(message)]
2
pub fn allowance(&self, owner: AccountId, spender: AccountId) -> Balance {
3
    self.allowance_impl(&owner, &spender)
4
}
5

6
#[inline]
7
fn allowance_impl(&self, owner: &AccountId, spender: &AccountId) -> Balance {
8
    self.allowances.get((owner, spender)).unwrap_or_default()
9
}

1
/// Transfers tokens on the behalf of the `from` account to the `to account
2
#[ink(message)]
3
pub fn transfer_from(
4
    &mut self,
5
    from: AccountId,
6
    to: AccountId,
7
    value: Balance,
8
) -> Result<()> {
9
    let caller = self.env().caller();
10
    let allowance = self.allowance_impl(&from, &caller);
11
    if allowance < value {
12
        return Err(Error::InsufficientAllowance)
13
    }
14
    self.transfer_from_to(&from, &to, value)?;
15
    self.allowances
16
        .insert((&from, &caller), &(allowance - value));
17
        Ok(())
18
}

1
#[ink::test]
2
fn transfer_from_works() {
3
    let mut contract = Erc20::new(100);
4
    let accounts = ink_env::test::default_accounts::<ink_env::DefaultEnvironment>();
5

6
    // Balance of alice (owner of token)
7
    assert_eq!(contract.balance_of(accounts.alice), 100);
8

9
    // Bob fails to transfer tokens owned by Alice.
10
    assert_eq!(
11
        contract.transfer_from(accounts.alice, accounts.frank, 10),
12
        Err(Error::InsufficientAllowance)
13
    );
14

15
    // Alice approves Bob for token transfer on behalf.
16
    assert_eq!(contract.approve(accounts.bob, 10), Ok(()));
17

18
    // Set the contract as callee and Bob as caller.
19
    let default_contract = ink_env::account_id::<ink_env::DefaultEnvironment>();
20
    ink_env::test::set_callee::<ink_env::DefaultEnvironment>(default_contract);
21
    ink_env::test::set_caller::<ink_env::DefaultEnvironment>(accounts.bob);
22

23
    // Transfer from Alice to Frank.
24
    assert_eq!(
25
        contract.transfer_from(accounts.alice, accounts.frank, 10),
26
        Ok(())
27
    );
28

29
    // Frank owns 10 tokens.
30
    assert_eq!(contract.balance_of(accounts.frank), 10);
31
}

1
#[ink::test]
2
fn allowances_works() {
3
    let mut contract = Erc20::new(100);
4
    assert_eq!(contract.balance_of(AccountId::from([0x1; 32])), 100);
5
    assert_eq!(contract.approve(AccountId::from([0x1; 32]), 200), Ok(()));
6
    assert_eq!(
7
        contract.allowance(AccountId::from([0x1; 32]), AccountId::from([0x1; 32])),
8
        200
9
    );
10

11
    assert_eq!(
12
        contract.transfer_from(AccountId::from([0x1; 32]), AccountId::from([0x0; 32]), 50),
13
        Ok(())
14
    );
15

16
    assert_eq!(contract.balance_of(AccountId::from([0x0; 32])), 50);
17
    assert_eq!(
18
        contract.allowance(AccountId::from([0x1; 32]), AccountId::from([0x1; 32])),
19
        150
20
    );
21

22
    contract
23
        .transfer_from(AccountId::from([0x1; 32]), AccountId::from([0x0; 32]), 100)
24
        .unwrap_or_default();
25

26
    assert_eq!(contract.balance_of(AccountId::from([0x0; 32])), 50);
27
    assert_eq!(
28
        contract.allowance(AccountId::from([0x1; 32]), AccountId::from([0x1; 32])),
29
        150
30
    );
31
}