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

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

#[ink(event)]
pub struct Approval {
    #[ink(topic)]
    owner: AccountId,
    #[ink(topic)]
    spender: AccountId,
    value: Balance,
}

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

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

#[ink(message)]
pub fn approve(&mut self, spender: AccountId, value: Balance) -> Result<()> {
  let owner = self.env().caller();
  self.allowances.insert((&owner, &spender), &value);
  self.env().emit_event(Approval {
    owner,
    spender,
    value,
  });
  Ok(())
}

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

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

/// Transfers tokens on the behalf of the `from` account to the `to account
#[ink(message)]
pub fn transfer_from(
    &mut self,
    from: AccountId,
    to: AccountId,
    value: Balance,
) -> Result<()> {
    let caller = self.env().caller();
    let allowance = self.allowance_impl(&from, &caller);
    if allowance < value {
        return Err(Error::InsufficientAllowance)
    }
    self.transfer_from_to(&from, &to, value)?;
    self.allowances
        .insert((&from, &caller), &(allowance - value));
        Ok(())
}

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

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

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

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

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

    // Transfer from Alice to Frank.
    assert_eq!(
        contract.transfer_from(accounts.alice, accounts.frank, 10),
        Ok(())
    );

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

let accounts = ink_env::test::default_accounts::<ink_env::DefaultEnvironment>();

let accounts = await hre.ethers.getSigners();

#[ink::test]
fn allowances_works() {
    let mut contract = Erc20::new(100);
    assert_eq!(contract.balance_of(AccountId::from([0x1; 32])), 100);
    assert_eq!(contract.approve(AccountId::from([0x1; 32]), 200), Ok(()));
    assert_eq!(
        contract.allowance(AccountId::from([0x1; 32]), AccountId::from([0x1; 32])),
        200
    );

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

    assert_eq!(contract.balance_of(AccountId::from([0x0; 32])), 50);
    assert_eq!(
        contract.allowance(AccountId::from([0x1; 32]), AccountId::from([0x1; 32])),
        150
    );

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

    assert_eq!(contract.balance_of(AccountId::from([0x0; 32])), 50);
    assert_eq!(
        contract.allowance(AccountId::from([0x1; 32]), AccountId::from([0x1; 32])),
        150
    );
}

cargo +nightly test

running 5 tests
test erc20::tests::new_works ... ok
test erc20::tests::balance_works ... ok
test erc20::tests::transfer_works ... ok
test erc20::tests::transfer_from_works ... ok
test erc20::tests::allowances_works ... ok

test result: ok. 5 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

substrate-contracts-node --dev

2022-05-15 22:41:52 Substrate Contracts Node
2022-05-15 22:41:52 ✌️  version 0.13.0-1a7fe78
2022-05-15 22:41:52 ❤️  by Parity Technologies <admin@parity.io>, 2021-2022
2022-05-15 22:41:52 📋 Chain specification: Development
2022-05-15 22:41:52 🏷  Node name: brainy-bell-9871
2022-05-15 22:41:52 👤 Role: AUTHORITY
2022-05-15 22:41:52 💾 Database: RocksDb at /var/folders/jx/4609s07j565324l22lmsdn_c0000gn/T/substrateV23MSP/chains/dev/db/full
2022-05-15 22:41:52 ⛓  Native runtime: substrate-contracts-node-100 (substrate-contracts-node-1.tx1.au1)
2022-05-15 22:41:52 🔨 Initializing Genesis block/state (state: 0x4a14…b6b9, header-hash: 0x730d…ce7c)
2022-05-15 22:41:52 🏷  Local node identity is:
2022-05-15 22:41:53 💻 Operating system: macos
2022-05-15 22:41:53 💻 CPU architecture: aarch64
2022-05-15 22:41:53 📦 Highest known block at #0
2022-05-15 22:41:53 〽️ Prometheus exporter started at 127.0.0.1:9615
2022-05-15 22:41:53 Listening for new connections on 127.0.0.1:9944.

cargo +nightly contract build