Merge pull request #16 from marc-aurele-besner/dev

Add new features 💪

Author: marc-aurele-besner

README.md

@@ -56,7 +56,8 @@ npm link hardhat-awesome-cli
 - More settings
     - Exclude test file from the tests selection list
     - Exclude script file from the scripts selection list
-- Create Mock contracts
+    - Install/Uninstall other Hardhat plugins (Still not very stable)
+- Create Mock contracts + (Deployment scripts and tests scripts (currently only for MockERC20))
     - MockERC20
     - MockERC721
     - MockERC1155
@@ -113,7 +114,7 @@ await addressBook.retrieveContract('MockERC20', 'ethereum')
 - More settings
     - Exclude files from, tests and scripts selection (useful for config and share helper file)
     - Add other hardhat plugins
-- Create Mock contracts (ERC20, ERC721, ERC1155 + Upgradeable version)
+- Create Mock contracts (ERC20, ERC721, ERC1155 + Upgradeable version) + (Deployment scripts and tests scripts (currently only for MockERC20))
     - Add @openzeppelin/contracts || @openzeppelin/contracts-upgradeable if not already installed
 - Tool to log all contracts deploy on each chain (1 unique contractName/chain + full log) and retrieve them (not tested yet)
     - hre.addressBook.{ saveContract, retrieveContract }
@@ -122,12 +123,10 @@ await addressBook.retrieveContract('MockERC20', 'ethereum')
 ## 🏗️ To do:
 - Start working on documentation
 - Inject chain settings, rpc and accounts in hardhat.config
-- Offer to generate deployment script and test script for Mock contract created
+- Create deployment and test scripts for all Mock contracts
 - Deployment contract generator
 - Make 'Run coverage tests' available only if task is exported by hardhat
-- Run coverage test (if solidity-coverage is installed)
 - Setup chains, RPC and accounts:
-    - Disabling chains seams to be broken
     - See list of .env config and chains setup in a table
 - More Settings:
     - Create github workflows file to run test and coverage test

package.json

@@ -1,16 +1,16 @@
 {
   "name": "hardhat-awesome-cli",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "Hardhat made awesome with a flexible CLI to help run test, deploy and more.",
-  "repository": "https://github.com/marc-aurele-besner/hardhat-easy-cli.git",
+  "repository": "https://github.com/marc-aurele-besner/hardhat-awesome-cli.git",
   "author": "Marc-Aurele Besner <82244926+marc-aurele-besner@users.noreply.github.com>",
   "license": "MIT",
   "main": "dist/index.js",
   "bin": {
-    "hardhat-easy-cli": "./src/index-cli.ts"
+    "hardhat-awesome-cli": "./src/index-cli.ts"
   },
   "bugs": {
-    "url": "https://github.com/marc-aurele-besner/hardhat-easy-cli/issues"
+    "url": "https://github.com/marc-aurele-besner/hardhat-awesome-cli/issues"
   },
   "types": "dist/src/index.d.ts",
   "keywords": [

src/index.ts

@@ -314,6 +314,51 @@ const buildMockContract = async (contractName: string) => {
     }
 }
 
+const buildMockDeploymentScriptOrTest = async (contractName: string, type: string) => {
+    if (require && require.main) {
+        const packageRootPath = path.join(path.dirname(require.main.filename), '../../../hardhat-awesome-cli/src/mockContracts')
+        if (fs.existsSync(packageRootPath)) {
+            if (fs.existsSync('contracts')) {
+                if (MockContractsList) {
+                    let deploymentScriptOrTestPath: string = ''
+                    const contractToMock: IMockContractsList[] = MockContractsList.filter((contract) => contract.name === contractName)
+                    if (contractToMock && type === 'deployment') {
+                        if (fs.existsSync('hardhat.config.js')) {
+                            if (contractToMock[0].deploymentScriptJs !== undefined) deploymentScriptOrTestPath = contractToMock[0].deploymentScriptJs
+                        } else if (fs.existsSync('hardhat.config.ts')) {
+                            if (contractToMock[0].deploymentScriptTs !== undefined) deploymentScriptOrTestPath = contractToMock[0].deploymentScriptTs
+                            else if (contractToMock[0].deploymentScriptJs !== undefined) deploymentScriptOrTestPath = contractToMock[0].deploymentScriptJs
+                        }
+                    }
+                    if (contractToMock && type === 'test') {
+                        if (fs.existsSync('hardhat.config.js')) {
+                            if (contractToMock[0].testScriptJs !== undefined) deploymentScriptOrTestPath = contractToMock[0].testScriptJs
+                        } else if (fs.existsSync('hardhat.config.ts')) {
+                            if (contractToMock[0].testScriptTs !== undefined) deploymentScriptOrTestPath = contractToMock[0].testScriptTs
+                            else if (contractToMock[0].testScriptJs !== undefined) deploymentScriptOrTestPath = contractToMock[0].testScriptJs
+                        }
+                    }
+                    if (contractToMock && deploymentScriptOrTestPath) {
+                        if (fs.existsSync(deploymentScriptOrTestPath)) {
+                            console.log('\x1b[33m%s\x1b[0m', 'The ' + type + ' scripts already exists')
+                        } else {
+                            if (fs.existsSync(deploymentScriptOrTestPath)) {
+                                console.log('\x1b[33m%s\x1b[0m', "Can't locate the " + type + ' script')
+                            } else {
+                                console.log('\x1b[32m%s\x1b[0m', 'Creating ' + type + ' for ', contractName, ' in scripts/')
+                                const rawdata: any = fs.readFileSync(packageRootPath + '/' + deploymentScriptOrTestPath)
+                                const scriptsTestRawdataModify = rawdata.toString().slice(2).replace(/\*\//g, '').trim()
+                                await sleep(500)
+                                fs.writeFileSync(deploymentScriptOrTestPath, `${scriptsTestRawdataModify}`)
+                            }
+                        }
+                    }
+                }
+            } else console.log('\x1b[33m%s\x1b[0m', 'Error creating ' + type + ' script')
+        }
+    }
+}
+
 const buildExcludedFile = async () => {
     let fileSetting: any = []
     if (fs.existsSync(fileHardhatAwesomeCLI)) {
@@ -1147,7 +1192,7 @@ const servePackageUninstaller = async () => {
                 }
             })
         })
-        await sleep(1000)
+    await sleep(1000)
 }
 
 const serveMockContractCreatorSelector = async () => {
@@ -1162,10 +1207,28 @@ const serveMockContractCreatorSelector = async () => {
                     name: 'mockContract',
                     message: 'Select a mock contract',
                     choices: mockContractsList
+                },
+                {
+                    type: 'list',
+                    name: 'mockDeploymentScript',
+                    message: 'Create a deployment script for this mock contract',
+                    choices: ['yes', 'no']
+                },
+                {
+                    type: 'list',
+                    name: 'mockTestScript',
+                    message: 'Create a test script for this mock contract',
+                    choices: ['yes', 'no']
                 }
             ])
-            .then(async (mockContractSelected: { mockContract: string }) => {
+            .then(async (mockContractSelected: { mockContract: string; mockDeploymentScript: string; mockTestScript: string }) => {
                 await buildMockContract(mockContractSelected.mockContract)
+                if (mockContractSelected.mockDeploymentScript === 'yes') {
+                    await buildMockDeploymentScriptOrTest(mockContractSelected.mockContract, 'deployment')
+                }
+                if (mockContractSelected.mockTestScript === 'yes') {
+                    await buildMockDeploymentScriptOrTest(mockContractSelected.mockContract, 'test')
+                }
             })
     }
 }

src/mockContracts/index.ts

@@ -4,7 +4,11 @@ const MockContractsList: IMockContractsList[] = [
     {
         name: 'MockERC20',
         desc: 'Basic ERC20 Token contract',
-        dependencies: ['@openzeppelin/contracts']
+        dependencies: ['@openzeppelin/contracts'],
+        deploymentScriptJs: 'scripts/deploy-mock-erc20.js',
+        deploymentScriptTs: 'scripts/deploy-mock-erc20.ts',
+        testScriptJs: 'test/test-mock-erc20.js',
+        testScriptTs: 'test/test-mock-erc20.ts'
     },
     {
         name: 'MockERC721',

src/mockContracts/scripts/deploy-mock-erc20.js

@@ -0,0 +1,19 @@
+/*
+const hre = require('hardhat')
+
+async function main() {
+    const MockERC20 = await hre.ethers.getContractFactory('MockERC20')
+    const mockERC20 = await MockERC20.deploy()
+
+    await mockERC20.deployed()
+
+    console.log('MockERC20 deployed to:', mockERC20.address)
+}
+
+main()
+    .then(() => process.exit(0))
+    .catch((error) => {
+        console.error(error)
+        process.exit(1)
+    })
+*/

src/mockContracts/scripts/deploy-mock-erc20.ts

@@ -0,0 +1,17 @@
+/*
+import { ethers } from 'hardhat'
+
+async function main() {
+    const MockERC20 = await ethers.getContractFactory('MockERC20')
+    const mockERC20 = await MockERC20.deploy()
+
+    await mockERC20.deployed()
+
+    console.log('MockERC20 deployed to:', mockERC20.address)
+}
+
+main().catch((error) => {
+    console.error(error)
+    process.exitCode = 1
+})
+*/

src/mockContracts/test/test-mock-erc20.js

@@ -0,0 +1,22 @@
+/*
+const { expect } = require("chai");
+const { ethers } = require("hardhat");
+
+describe("MockERC20", function () {
+  it("Should return the name of the token", async function () {
+    const MockERC20 = await ethers.getContractFactory("MockERC20");
+    const mockERC20 = await MockERC20.deploy();
+    await mockERC20.deployed();
+
+    expect(await mockERC20.name()).to.equal("MockERC20");
+  });
+
+  it("Should return the symbol of the token", async function () {
+    const MockERC20 = await ethers.getContractFactory("MockERC20");
+    const mockERC20 = await MockERC20.deploy();
+    await mockERC20.deployed();
+
+    expect(await mockERC20.symbol()).to.equal("MOCK");
+  });
+});
+*/

src/mockContracts/test/test-mock-erc20.ts

@@ -0,0 +1,22 @@
+/*
+import { expect } from "chai";
+import { ethers } from "hardhat";
+
+describe("MockERC20", function () {
+    it("Should return the name of the token", async function () {
+        const MockERC20 = await ethers.getContractFactory("MockERC20");
+        const mockERC20 = await MockERC20.deploy();
+        await mockERC20.deployed();
+    
+        expect(await mockERC20.name()).to.equal("MockERC20");
+    });
+
+    it("Should return the symbol of the token", async function () {
+        const MockERC20 = await ethers.getContractFactory("MockERC20");
+        const mockERC20 = await MockERC20.deploy();
+        await mockERC20.deployed();
+    
+        expect(await mockERC20.symbol()).to.equal("MOCK");
+    });
+});
+*/

src/types.ts

@@ -21,6 +21,10 @@ export interface IMockContractsList {
     name: string
     desc: string
     dependencies: string[]
+    deploymentScriptJs?: string
+    deploymentScriptTs?: string
+    testScriptJs?: string
+    testScriptTs?: string
     upgradeable?: boolean
 }