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

contract ERC20Interface {
    // Storage Getters
    function totalSupply() public view returns (uint);
    function balanceOf(address tokenOwner) public view returns (uint balance);
    function allowance(address tokenOwner, address spender) public view returns (uint remaining);

    // Public Functions
    function transfer(address to, uint tokens) public returns (bool success);
    function approve(address spender, uint tokens) public returns (bool success);
    function transferFrom(address from, address to, uint tokens) public returns (bool success);

    // Contract Events
    event Transfer(address indexed from, address indexed to, uint tokens);
    event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}

cargo contract new erc20

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

use ink_lang as ink;

#[ink::contract]
mod erc20 {
    use ink_storage::{
        traits::SpreadAllocate,
        Mapping,
    };

    /// 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>,
    }

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

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

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

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

        #[cfg(test)]
        mod tests {
        use super::*;

        use ink_lang as ink;

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

        #[ink::test]
        fn balance_works() {
            let contract = Erc20::new(100);
            assert_eq!(contract.total_supply(), 100);
            assert_eq!(contract.balance_of(AccountId::from([0x1; 32])), 100);
            assert_eq!(contract.balance_of(AccountId::from([0x0; 32])), 0);
        }
    }
}

cargo +nightly test

     Running unittests lib.rs (target/debug/deps/erc20-879749f53b41eace)

running 2 tests
test erc20::tests::new_works ... ok
test erc20::tests::balance_works ... ok

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

cargo +nightly contract build

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

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

#[ink(message)]
pub fn transfer(&mut self, to: AccountId, value: Balance) -> Result<()> {
  // เหมือน msg.sender
  let from = self.env().caller();
  self.transfer_from_to(&from, &to, value)
}

fn transfer_from_to(
  &mut self,
  from: &AccountId,
  to: &AccountId,
  value: Balance,
) -> Result<()> {
  let from_balance = self.balance_of_impl(from);

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

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

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

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

cargo +nightly test

#[ink(event)]
pub struct Transfer {
  #[ink(topic)]
  from: Option<AccountId>,
  #[ink(topic)]
  to: Option<AccountId>,
  value: Balance,
}

fn new_init(&mut self, initial_supply: Balance) {
  let caller = Self::env().caller();
  self.balances.insert(&caller, &initial_supply);
  self.total_supply = initial_supply;
  Self::env().emit_event(Transfer {
      from: None,
      to: Some(caller),
      value: initial_supply,
  });
}

fn transfer_from_to(
    &mut self,
    from: &AccountId,
    to: &AccountId,
    value: Balance,
) -> Result<()> {
    let from_balance = self.balance_of_impl(from);

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

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

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

    self.env().emit_event(Transfer {
        from: Some(*from),
        to: Some(*to),
        value,
    });
    Ok(())
}

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

cargo +nightly test

running 3 tests
test erc20::tests::new_works ... ok
test erc20::tests::balance_works ... ok
test erc20::tests::transfer_works ... ok

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