├── package.json
├── LICENSE
├── scripts
    └── sample-script.js
├── hardhat.config.js
├── contracts
    └── SampleICO.sol
├── .gitignore
├── README.md
└── test
    └── script-test.js


/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "ico-contract",
 3 |   "version": "1.0.0",
 4 |   "description": "Initial Coin Offering (ICO) contract in Ethereum",
 5 |   "main": "index.js",
 6 |   "scripts": {
 7 |     "clean": "npx hardhat clean && rm -rf cache coverage coverage.json",
 8 |     "compile": "npx hardhat compile",
 9 |     "test": "npx hardhat test",
10 |     "test-rpc": "npx hardhat node",
11 |     "deploy-local": "npx hardhat run scripts/sample-script.js --network localhost",
12 |     "coverage": "npx hardhat coverage"
13 |   },
14 |   "keywords": [],
15 |   "author": "",
16 |   "license": "ISC",
17 |   "devDependencies": {
18 |     "@nomiclabs/hardhat-ethers": "^2.0.1",
19 |     "@nomiclabs/hardhat-waffle": "^2.0.1",
20 |     "chai": "^4.2.0",
21 |     "ethereum-waffle": "^3.2.1",
22 |     "ethers": "^5.0.24",
23 |     "hardhat": "^2.0.6",
24 |     "solidity-coverage": "^0.7.17"
25 |   },
26 |   "dependencies": {
27 |     "@openzeppelin/contracts": "^4.3.2"
28 |   }
29 | }
30 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2024 Steven Piao
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/scripts/sample-script.js:
--------------------------------------------------------------------------------
 1 | // We require the Hardhat Runtime Environment explicitly here. This is optional 
 2 | // but useful for running the script in a standalone fashion through `node <script>`.
 3 | //
 4 | // When running the script with `hardhat run <script>` you'll find the Hardhat
 5 | // Runtime Environment's members available in the global scope.
 6 | const hre = require("hardhat");
 7 | 
 8 | async function main() {
 9 |   // Hardhat always runs the compile task when running scripts with its command
10 |   // line interface.
11 |   //
12 |   // If this script is run directly using `node` you may want to call compile 
13 |   // manually to make sure everything is compiled
14 |   // await hre.run('compile');
15 | 
16 |   // We get the contract to deploy
17 |   const contract = await hre.ethers.getContractFactory("ICO");
18 |   const token = await contract.deploy();
19 | 
20 |   await token.deployed();
21 |   console.log("Initial Coin Offering (ICO) contract deployed to:", token.address);
22 | }
23 | 
24 | // We recommend this pattern to be able to use async/await everywhere
25 | // and properly handle errors.
26 | main()
27 |   .then(() => process.exit(0))
28 |   .catch(error => {
29 |     console.error(error);
30 |     process.exit(1);
31 |   });


--------------------------------------------------------------------------------
/hardhat.config.js:
--------------------------------------------------------------------------------
 1 | const { task } = require("hardhat/config");
 2 | // require("hardhat-gas-reporter");
 3 | require("@nomiclabs/hardhat-waffle");
 4 | require("solidity-coverage");
 5 | 
 6 | // This is a sample Hardhat task. To learn how to create your own go to
 7 | // https://hardhat.org/guides/create-task.html
 8 | task("accounts", "Prints the list of accounts", async () => {
 9 |   const accounts = await ethers.getSigners();
10 | 
11 |   for (const account of accounts) {
12 |     console.log("address :",account.address);
13 |   }
14 | });
15 | 
16 | // You need to export an object to set up your config
17 | // Go to https://hardhat.org/config/ to learn more
18 | 
19 | /**
20 |  * @type import('hardhat/config').HardhatUserConfig
21 |  */
22 | module.exports = {
23 |   networks: {
24 |     localhost: {
25 |       url: "http://localhost:8545",
26 |       chainId: 1337
27 |     },
28 |     hardhat: {
29 |       chainId: 1337
30 |     }
31 |   },
32 |   solidity: {
33 |     compilers: [
34 |       {
35 |         version: "0.8.0",
36 |         settings: {
37 |           optimizer: {
38 |             enabled: true,
39 |             runs: 200,
40 |           }
41 |         }
42 |       }
43 |     ]
44 |   },
45 |   mocha: {
46 |     timeout: 20000,
47 |     slow: '0'
48 |   }
49 | };
50 | 


--------------------------------------------------------------------------------
/contracts/SampleICO.sol:
--------------------------------------------------------------------------------
 1 | // SPDX-License-Identifier: MIT
 2 | pragma solidity ^0.8.0;
 3 | 
 4 | // import from node_modules @openzeppelin/contracts v4.0.
 5 | import "@openzeppelin/contracts/access/Ownable.sol";
 6 | import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 7 | import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
 8 | 
 9 | /**@title Initial Coin Offerring(ICO) contract*/
10 | contract ICO is ERC20, Ownable, ReentrancyGuard {
11 |     
12 |     // Sample constructor
13 |     constructor() ERC20("BasicCoin", "BSC") {
14 |       _mint(msg.sender, 1000000*(10**uint256(decimals())));
15 |     }
16 |     
17 |     /**
18 |       * @param account (type address) address of recipient
19 |       * @param amount (type uint256) amount of token
20 |       * @dev function use to mint token
21 |     */
22 |     function mint(address account, uint256 amount) public onlyOwner returns (bool sucess) {
23 |       require(account != address(0) && amount != uint256(0), "ERC20: function mint invalid input");
24 |       _mint(account, amount);
25 |       return true;
26 |     }
27 | 
28 |     /** 
29 |       * @param account (type address) address of recipient
30 |       * @param amount (type uint256) amount of token
31 |       * @dev function use to burn token
32 |     */
33 |     function burn(address account, uint256 amount) public onlyOwner returns (bool success) {
34 |       require(account != address(0) && amount != uint256(0), "ERC20: function burn invalid input");
35 |       _burn(account, amount);
36 |       return true;
37 |     }
38 | 
39 |     /** 
40 |       * @dev function to buy token with ether
41 |     */
42 |     function buy() public payable nonReentrant returns (bool sucess) {
43 |       require(msg.sender.balance >= msg.value && msg.value != 0 ether, "ICO: function buy invalid input");
44 |       uint256 amount = msg.value * 1000;
45 |       _transfer(owner(), _msgSender(), amount);
46 |       return true;
47 |     }
48 | 
49 |     /** 
50 |       * @param amount (type uint256) amount of ether
51 |       * @dev function use to withdraw ether from contract
52 |     */
53 |     function withdraw(uint256 amount) public onlyOwner returns (bool success) {
54 |       require(amount <= address(this).balance, "ICO: function withdraw invalid input");
55 |       payable(_msgSender()).transfer(amount);
56 |       return true;
57 |     }
58 | }


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | # Logs
  2 | logs
  3 | *.log
  4 | npm-debug.log*
  5 | yarn-debug.log*
  6 | yarn-error.log*
  7 | lerna-debug.log*
  8 | .pnpm-debug.log*
  9 | 
 10 | # Diagnostic reports (https://nodejs.org/api/report.html)
 11 | report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
 12 | 
 13 | # Runtime data
 14 | pids
 15 | *.pid
 16 | *.seed
 17 | *.pid.lock
 18 | 
 19 | # Directory for instrumented libs generated by jscoverage/JSCover
 20 | lib-cov
 21 | 
 22 | # Coverage directory used by tools like istanbul
 23 | coverage
 24 | *.lcov
 25 | 
 26 | # nyc test coverage
 27 | .nyc_output
 28 | 
 29 | # Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
 30 | .grunt
 31 | 
 32 | # Bower dependency directory (https://bower.io/)
 33 | bower_components
 34 | 
 35 | # node-waf configuration
 36 | .lock-wscript
 37 | 
 38 | # Compiled binary addons (https://nodejs.org/api/addons.html)
 39 | build/Release
 40 | 
 41 | # Dependency directories
 42 | node_modules/
 43 | jspm_packages/
 44 | 
 45 | # Snowpack dependency directory (https://snowpack.dev/)
 46 | web_modules/
 47 | 
 48 | # TypeScript cache
 49 | *.tsbuildinfo
 50 | 
 51 | # Optional npm cache directory
 52 | .npm
 53 | 
 54 | # Optional eslint cache
 55 | .eslintcache
 56 | 
 57 | # Optional stylelint cache
 58 | .stylelintcache
 59 | 
 60 | # Microbundle cache
 61 | .rpt2_cache/
 62 | .rts2_cache_cjs/
 63 | .rts2_cache_es/
 64 | .rts2_cache_umd/
 65 | 
 66 | # Optional REPL history
 67 | .node_repl_history
 68 | 
 69 | # Output of 'npm pack'
 70 | *.tgz
 71 | 
 72 | # Yarn Integrity file
 73 | .yarn-integrity
 74 | 
 75 | # dotenv environment variable files
 76 | .env
 77 | .env.development.local
 78 | .env.test.local
 79 | .env.production.local
 80 | .env.local
 81 | 
 82 | # parcel-bundler cache (https://parceljs.org/)
 83 | .cache
 84 | .parcel-cache
 85 | 
 86 | # Next.js build output
 87 | .next
 88 | out
 89 | 
 90 | # Nuxt.js build / generate output
 91 | .nuxt
 92 | dist
 93 | 
 94 | # Gatsby files
 95 | .cache/
 96 | # Comment in the public line in if your project uses Gatsby and not Next.js
 97 | # https://nextjs.org/blog/next-9-1#public-directory-support
 98 | # public
 99 | 
100 | # vuepress build output
101 | .vuepress/dist
102 | 
103 | # vuepress v2.x temp and cache directory
104 | .temp
105 | .cache
106 | 
107 | # Docusaurus cache and generated files
108 | .docusaurus
109 | 
110 | # Serverless directories
111 | .serverless/
112 | 
113 | # FuseBox cache
114 | .fusebox/
115 | 
116 | # DynamoDB Local files
117 | .dynamodb/
118 | 
119 | # TernJS port file
120 | .tern-port
121 | 
122 | # Stores VSCode versions used for testing VSCode extensions
123 | .vscode-test
124 | 
125 | # yarn v2
126 | .yarn/cache
127 | .yarn/unplugged
128 | .yarn/build-state.yml
129 | .yarn/install-state.gz
130 | .pnp.*
131 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Initial Coin Offering (ICO) contract
  2 | 
  3 | Tutorial using Hardhat(Buidler) to complie, deploy and automated unit tests Solidity smart contract.  
  4 | you use this repository as Initial Coin Offering (ICO) contract template or ERC20 template.   
  5 | To run these tutorials, you must have the following installed:
  6 | 
  7 | - [nodejs](https://nodejs.org/en/)
  8 | 
  9 | - [nvm](https://github.com/nvm-sh/nvm)
 10 | 
 11 | ```bash
 12 | $ npm install
 13 | ```
 14 | 
 15 | to compile your smart contract to get an ABI and artifact of a smart contract.
 16 | 
 17 | ```bash
 18 | $ npm run compile
 19 | ```
 20 | 
 21 | for a unit testing smart contract using the command line.
 22 | 
 23 | ```
 24 | $ npm run test
 25 | ```
 26 | expecting `sample-test.js` result.
 27 | ```bash
 28 | 
 29 |   Initial Coin Offering (ICO) contract
 30 |     ✓ Assigns initial balance (97ms)
 31 |     ✓ Do not have permission to minting token (95ms)
 32 |     ✓ Do not have permission to burning token (74ms)
 33 |     ✓ Buy token with ether (212ms)
 34 |     ✓ Do not have permission to withdraw ether from contract (69ms)
 35 |     ✓ Transfer adds amount to destination account (99ms)
 36 |     ✓ Transfer emits event (132ms)
 37 |     ✓ Can not transfer above the amount (63ms)
 38 |     ✓ Can not transfer from empty account (77ms)
 39 |     ✓ Minting token (100ms)
 40 |     ✓ Burning token (73ms)
 41 |     ✓ Withdraw ether from contract (61ms)
 42 |     ✓ Do not have enough ether to buy token (30ms)
 43 | 
 44 | 
 45 |   13 passing (2s)
 46 | 
 47 | ```
 48 | 
 49 | after testing if you want to deploy the contract using the command line.
 50 | 
 51 | ```bash
 52 | 
 53 | $ npm run test-rpc
 54 | # Open another Terminal
 55 | $ npm run deploy-local
 56 | 
 57 | # result in npx hardhat node Terminal
 58 | web3_clientVersion
 59 | eth_chainId
 60 | eth_accounts
 61 | eth_chainId
 62 | eth_estimateGas
 63 | eth_gasPrice
 64 | eth_sendTransaction
 65 |   Contract deployment: <UnrecognizedContract>
 66 |   Contract address:    0x5fb...aa3
 67 |   Transaction:         0x4d8...945
 68 |   From:                0xf39...266
 69 |   Value:               0 ETH
 70 |   Gas used:            323170 of 323170
 71 |   Block #1:            0xee6...85d
 72 | 
 73 | eth_chainId
 74 | eth_getTransactionByHash
 75 | eth_blockNumber
 76 | eth_chainId (2)
 77 | eth_getTransactionReceipt
 78 | 
 79 | # result in npx hardhat run Terminal
 80 | Initial Coin Offering (ICO) contract deployed to: 0x5Fb...aa3
 81 | 
 82 | ```
 83 | your can edit deploy network endpoint at `hardhat.config.js`.
 84 | 
 85 | ```javascript
 86 | module.exports = {
 87 |   networks: {
 88 |         {
 89 |         localhost: {
 90 |           url: "http://127.0.0.1:8545"
 91 |         },
 92 |         hardhat: {
 93 |           // See its defaults
 94 |         }
 95 |   }
 96 | };
 97 | 
 98 | ```
 99 | Example customized function  
100 | If you want to pay token fee to the miner or validator in the network.
101 | ```javascript
102 |     // pragma solidity 0.8.0
103 |     // Solidity 0.8.X has an integrated SafeMath Library
104 |     // override function transfer to distribute fee to miner or validator in the network
105 |     /* Diagram transfer with token fees
106 |       ##### Before #####
107 |       A balance: 101
108 |       B balance: 0
109 |       C balance: 0
110 | 
111 |       A.transfer(B.address,101);
112 |                     A
113 |                     |	
114 |                     | transfer Tx
115 |                     |_____ 
116 |                     |     |
117 |                     v     v				
118 |                     B     C
119 | 
120 |       ##### After #####
121 |       A balance: 0
122 |       B balance: 100
123 |       C balance: 1
124 |     */
125 |     function transfer(address account,uint256 amount) public override returns(bool){
126 |         require(amount % 10 != 0, "ERC20: insufficient funds");
127 |         uint256 fee = amount % 10;
128 |         _transfer(msg.sender,account,amount-fee);
129 |         _transfer(msg.sender,block.coinbase,fee);
130 |         return true;
131 |     }
132 | ```


--------------------------------------------------------------------------------
/test/script-test.js:
--------------------------------------------------------------------------------
  1 | const { expect, assert  } = require("chai");
  2 | 
  3 | describe("Initial Coin Offering (ICO) contract", function() {
  4 |   let token;
  5 |   let accounts;
  6 |   const amount = ethers.utils.parseEther("1")
  7 | 
  8 |   before(async () => {
  9 |     const contract = await ethers.getContractFactory("ICO");
 10 |     token = await contract.deploy();
 11 |     accounts = await ethers.getSigners();
 12 |     await token.deployed();
 13 |   });
 14 | 
 15 |   it("Assigns initial balance", async function() {
 16 |     const totalSupply = await token.totalSupply();
 17 |     expect(await token.balanceOf(accounts[0].address)).to.equal(totalSupply);
 18 |   });
 19 | 
 20 |   it("Do not have permission to minting token", async function(){
 21 |     const wallet = token.connect(accounts[2]);
 22 |     await expect(wallet.mint(accounts[2].address,amount)).to.be.reverted
 23 |   });
 24 | 
 25 |   it("Do not have permission to burning token", async function(){
 26 |     const wallet = token.connect(accounts[2]);
 27 |     await expect(wallet.burn(accounts[2].address,amount)).to.be.reverted
 28 |   });
 29 | 
 30 |   it("Buy token with ether", async function(){
 31 |     const wallet = token.connect(accounts[2]);
 32 |     const option = {value: amount};
 33 |     const calculate = (option.value).mul(1000) // 1000 is declare in smart-contract msg.value * 1000
 34 |     await wallet.buy(option);
 35 |     expect(await wallet.balanceOf(accounts[2].address)).to.equal(calculate);
 36 |   });
 37 | 
 38 |   it("Do not have permission to withdraw ether from contract", async function(){
 39 |     const wallet = token.connect(accounts[2]);
 40 |     await expect(wallet.withdraw(amount)).to.be.reverted;
 41 |   });
 42 | 
 43 |   it("Transfer adds amount to destination account", async function() {
 44 |     await token.transfer(accounts[1].address,amount);
 45 |     expect(await token.balanceOf(accounts[1].address)).to.equal(amount);
 46 |   });
 47 | 
 48 |   it("Transfer emits event", async () => {
 49 |     await expect(token.transfer(accounts[1].address, amount))
 50 |       .to.emit(token, "Transfer")
 51 |       .withArgs(accounts[0].address, accounts[1].address, amount);
 52 |   });
 53 | 
 54 |   it("Can not transfer above the amount", async () => {
 55 |     const wallet = token.connect(accounts[3]);
 56 |     await expect(wallet.transfer(accounts[1].address, 1)).to.be.reverted;
 57 |   });
 58 | 
 59 |   it("Can not transfer from empty account", async () => {
 60 |     const wallet = token.connect(accounts[3]);
 61 |     await expect(wallet.transfer(accounts[0].address, 1)).to.be.reverted;
 62 |   });
 63 |   
 64 |   it("Minting token", async function() {
 65 |     const before_mint = await token.balanceOf(accounts[0].address);
 66 |     await token.mint(accounts[0].address,amount);
 67 |     const after_mint = await token.balanceOf(accounts[0].address);
 68 |     expect(after_mint).to.equal((before_mint.add(amount)));
 69 |   });
 70 | 
 71 |   it("Burning token", async function() {
 72 |     const before_burn = await token.balanceOf(accounts[0].address);
 73 |     await token.burn(accounts[0].address,amount);
 74 |     const after_burn = await token.balanceOf(accounts[0].address);
 75 |     expect(after_burn).to.equal((before_burn.sub(amount)));
 76 |   });
 77 |   
 78 |   it("Withdraw ether from contract", async function(){
 79 |     const before_withdraw = await accounts[0].getBalance()
 80 |     await token.withdraw(amount);
 81 |     const after_withdraw = await accounts[0].getBalance()
 82 |     expect(before_withdraw.lt(after_withdraw)).to.equal(true);
 83 |   });
 84 | 
 85 |   it("Do not have enough ether to buy token", async function(){
 86 |     const wallet = token.connect(accounts[3]);
 87 |     const big_amount = ethers.utils.parseEther("999999")
 88 |     const option = {value: big_amount};
 89 |     let error;
 90 |     try {
 91 |       await wallet.buy(option)
 92 |     }
 93 |     catch (err) {
 94 |       error = "sender doesn't have enough funds"
 95 |     }
 96 |     expect(error).to.equal("sender doesn't have enough funds"); // maybe can refactor
 97 |   });
 98 | 
 99 | });
100 | 


--------------------------------------------------------------------------------