Triển khai 1 token từ smart contract trên project

mkdir create-token
cd create-token

npm init # (or npm init --yes)

package name: (create-token)
version: (1.0.0)
description: create token
entry point: (index.js)
test command:
git repository:
keywords:
author:
license: (ISC)

About to write to /Users/.../.../.../hello-world/package.json:

{
   "name": “create-token”,
   "version": "1.0.0",
   "description": "create token",
   "main": "index.js",
   "scripts": {
      "test": "echo \"Error: no test specified\" && exit 1"
   },
   "author": "",
   "license": "ISC"
}

npm install --save-dev hardhat

npx hardhat

888    888                      888 888               888
888    888                      888 888               888
888    888                      888 888               888
8888888888  8888b.  888d888 .d88888 88888b.   8888b.  888888
888    888     "88b 888P"  d88" 888 888 "88b     "88b 888
888    888 .d888888 888    888  888 888  888 .d888888 888
888    888 888  888 888    Y88b 888 888  888 888  888 Y88b.
888    888 "Y888888 888     "Y88888 888  888 "Y888888  "Y888

👷 Welcome to Hardhat v2.0.11 👷‍

What do you want to do? …
Create a sample project
❯ Create an empty hardhat.config.js
Quit

mkdir contracts
mkdir scripts

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    function mint(address account, uint256 amount) external returns (bool);
    
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

contract Token is IERC20 {
    string public name;
    string public symbol;
    uint8 public decimals;
    uint256 private _totalSupply;
    mapping(address => uint256) private _balances;
    mapping(address => mapping(address => uint256)) private _allowances;
    string public message;

    struct Reservation {
        uint256 id;
        address admin;
        address teacher;
        address student;
        uint256 date;
        uint256 amount;
        uint256 amountForAdmin;
        uint256 amountForTeacher;
        bool paid;
        bool fulfilled;
    }

    mapping(uint256 => Reservation) public reservations;
    uint256 public reservationCounter;

    event ReservationCreated(uint256 id, address admin, address teacher, address student, uint256 date, uint256 amount);

    constructor(string memory initMessage) {
        message = initMessage;
        name = "TRT vertsion 1";
        symbol = "TRT";
        decimals = 18;
        _totalSupply = 1000000 * 10**uint256(decimals);
        _balances[msg.sender] = _totalSupply;
    }

    function createReservation(address teacher, address student, uint256 amount, uint256 amountForAdmin, uint256 amountForTeacher, uint256 date) external payable returns(uint256) {
        require(amount > 0, "Gia tri phai lon hon 0");
        reservationCounter++;
        reservations[reservationCounter] = Reservation(reservationCounter, msg.sender, teacher, student, date, amount, amountForAdmin, amountForTeacher, false, false); // create 1 Reservation vào reservations
        _balances[student] -= amount; // tru token cua student
        emit ReservationCreated(reservationCounter, msg.sender, teacher, student, date, amount);
        return reservationCounter;
    }

    function fulfillReservation(uint256 reservationId) external payable returns(bool) {
        Reservation storage reservation = reservations[reservationId];
        require(!reservation.fulfilled, "fulfill da duoc thuc hien");

        reservation.fulfilled = true;
        _balances[reservation.teacher] += reservation.amountForTeacher; // transfer token for teacher
        _balances[reservation.admin] += reservation.amountForAdmin; // transfer token for admin
        return true;
    }

    function canCelReservation(uint256 reservationId) external payable returns(bool) {
        Reservation storage reservation = reservations[reservationId];
        require(!reservation.paid, "Cancel da duoc thuc hien");

        reservation.paid = true;
        _balances[reservation.student] += reservation.amount; // refund token for student
        return true;
    }


    function mint(address account, uint256 amount) public override returns (bool) {
        require(account != address(0), "MintableToken: mint to the zero address");
        _totalSupply += amount;
        _balances[account] += amount;
        return true;
    }

    function totalSupply() public view override returns (uint256) {
        return _totalSupply;
    }

    function balanceOf(address account) public view override returns (uint256) {
        return _balances[account];
    }

    function transfer(address recipient, uint256 amount) public override returns (bool) {
        require(amount <= _balances[msg.sender], "Insufficient balance");

        _balances[msg.sender] -= amount;
        _balances[recipient] += amount;

        emit Transfer(msg.sender, recipient, amount);
        return true;
    }

    function allowance(address owner, address spender) public view override returns (uint256) {
        return _allowances[owner][spender];
    }

    function approve(address spender, uint256 amount) public override returns (bool) {
        _allowances[spender][msg.sender] = amount;

        emit Approval(msg.sender, spender, amount);
        return true;
    }

    function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
        require(amount <= _balances[sender], "Insufficient balance");
        require(amount <= _allowances[sender][msg.sender], "Insufficient allowance");

        _balances[sender] -= amount;
        _balances[recipient] += amount;
        _allowances[sender][msg.sender] -= amount;

        emit Transfer(sender, recipient, amount);
        return true;
    }
}

npm install dotenv --save

API_URL = "https://eth-goerli.alchemyapi.io/v2/your-api-key"
PRIVATE_KEY = "your-metamask-private-key"

npm install --save-dev @nomiclabs/hardhat-ethers "ethers@^5.0.0"

/**
* @type import('hardhat/config').HardhatUserConfig
*/

require('dotenv').config();
require("@nomiclabs/hardhat-ethers");

const { API_URL, PRIVATE_KEY } = process.env;

module.exports = {
   solidity: "0.7.3",
   defaultNetwork: “sepolia”,
   networks: {
      hardhat: {},
      sepolia: {
         url: API_URL,
         accounts: [`0x${PRIVATE_KEY}`]
      }
   },
}

npx hardhat compile

async function main() {
   const Token = await ethers.getContractFactory(“Token”);

   // Start deployment, returning a promise that resolves to a contract object
   const token = await Token();
   console.log("Contract deployed to address:", token);
}

main()
  .then(() => process.exit(0))
  .catch(error => {
    console.error(error);
    process.exit(1);
});

npx hardhat run scripts/deploy.js --network sepolia