feat: support hardhat

Author: joshstevens19

README.md

@@ -34,18 +34,19 @@ A CLI tool which allows you to convert an ABI json file into fully loaded interf
 - Web3 1.x and 2.x
 - Ethers 5.x
 - Ethers 4.x
+- Hardhat
 
 ## ethereum-abi-types-generator vs TypeChain
 
 The first question I normally get is “have you seen TypeChain”, yes I have of course and it is a great tool but it was missing and did a few things which I didn't want as a developer. The main differences with this ethereum-abi-types-generator vs typechain are:
 
 ### No bundle size at all added
 
-With TypeChain you have a class factory you have to connect to adding size into the final bundle. This package is all interfaces meaning nothing is added to your final    bundle size.
+With TypeChain you have a class factory you have to connect to adding size into the final bundle. This package is all interfaces meaning nothing is added to your final bundle size.
 
 ### Exposes proper typed interfaces meaning you can use them in your application
 
-TypeChain has dynamic interfaces aka ```public contractCall(): Promise<{ foo: BigNumber }>``` so if you wanted to use that interface somewhere in your app its not exported so can not be used. This lib generates response interfaces which are exported aka:
+TypeChain has dynamic interfaces aka `public contractCall(): Promise<{ foo: BigNumber }>` so if you wanted to use that interface somewhere in your app its not exported so can not be used. This lib generates response interfaces which are exported aka:
 
 ```ts
 export interface ContractCallResponse {
@@ -66,12 +67,12 @@ export interface FooRequest {
 public contractCall(request: FooRequest): Promise<ContractCallResponse>
 ```
 
-If you have worked with dynamic interfaces you understand the pain it brings having to recreate everytime. 
+If you have worked with dynamic interfaces you understand the pain it brings having to recreate everytime.
 
 ### Use your provider interface your use too
 
-TypeChain you have to connect to the factory then use the contract that way. With this lib you just use web3 or ethers interface for every contract call meaning you don't have to get use to another process it just works and zero code changes just cast and you got compile time errors for contracts. 
-  
+TypeChain you have to connect to the factory then use the contract that way. With this lib you just use web3 or ethers interface for every contract call meaning you don't have to get use to another process it just works and zero code changes just cast and you got compile time errors for contracts.
+
 ## Motivation
 
 Blockchain development in JavaScript is already super hard. You have all these tools like `truffle,` `ethers`, `web3` (the list goes on) which you have to get use to and the learning curve is already quite high. On top of this, you have loads of other tools to get things to work as you need. TypeScript allows you to bring runtime errors in the compiler but on contract calls most developers have to either build their own types meaning maintaining them and easily getting out of sync or have no compile type errors using the dreaded `any` hoping and praying you don't break anything. The idea was to not have to make the developer wrap any kind of `web3` or `ethers` instance or use a new tool to get this working but with a simple 1 line change you can use all the same libraries interfaces as what the developer is use to but with `types` `auto-generated` for you to bring back compile-time errors on any contract calls with super ease.
@@ -100,6 +101,8 @@ If you get compile time errors due to it waiting `web3` dependencies when using
 
 ## CLI usage
 
+### Web3 1.x and 2.x & Ethers 5.x & Ethers 4.x
+
 ```ts
 $ abi-types-generator <abiFileLocation>
 $ abi-types-generator <abiFileLocation> --name=ABI_NAME
@@ -119,6 +122,12 @@ $ abi-types-generator <abiFileLocation> --output=PATH_DIRECTORY --name=ABI_NAME
 $ abi-types-generator <abiFileLocation> --output=PATH_DIRECTORY --name=ABI_NAME --provider=web3|ethers|ethers_v5 --watch
 ```
 
+#### Hardhat
+
+```ts
+$ abi-types-generator hardhat
+```
+
 We suggest running these within the `script` commands in npm or yarn this way you will not lose your commands and can be run on build agents as well. Also you will not get confused with sharing the script and others running in the wrong paths. Examples below:
 
 ```json
@@ -142,7 +151,8 @@ We suggest running these within the `script` commands in npm or yarn this way yo
     "ethers-v5-token-abi": "abi-types-generator './abi-examples/token-abi.json' --output='./ethers_v5/uniswap-example/generated-typings' --name=token-contract --provider=ethers_v5",
     "ethers-v5-uniswap-exchange-abi": "abi-types-generator './abi-examples/uniswap-exchange-abi.json' --output='./ethers_v5/uniswap-example/generated-typings' --name=uniswap-exchange-contract --provider=ethers_v5",
     "ethers-v5-uniswap-factory-abi": "abi-types-generator './abi-examples/uniswap-factory-abi.json' --output='./ethers_v5/uniswap-example/generated-typings' --name=uniswap-factory-contract --provider=ethers_v5",
-    "ethers-v5-uniswap": "npm run ethers-token-abi && npm run ethers-uniswap-exchange-abi && npm run ethers-uniswap-factory-abi"
+    "ethers-v5-uniswap": "npm run ethers-token-abi && npm run ethers-uniswap-exchange-abi && npm run ethers-uniswap-factory-abi",
+    "hardhat-example": "abi-types-generator hardhat"
   }
 }
 ```
@@ -275,6 +285,59 @@ We use `prettier` to format all files, to make sure it matches your coding style
 
 Right now the package does not try to find any of your `tslint.json` settings. It will support this soon. For now if you get any `tslint` errors when running the linter it's best to ignore any generated file in the `linterOptions` > `exclude` of the `tslint.json`. I tend to put all my generated files in 1 place so I can ignore the entire folder.
 
+### Using with hardhat
+
+First you create a script in your `package.json` that runs the `abi-types-generator` script after it compiles everytime.
+
+```json
+{
+  "scripts": {
+    "compile": "npx hardhat compile && abi-types-generator hardhat"
+  }
+}
+```
+
+If your contracts are ready to compile run:
+
+```bash
+$ npm run compile
+```
+
+You types are now created within the root of your hardhat project in a folder called `ethereum-abi-types` and you can use them throughout your tests/scripts or anything `ts` related.
+
+### Test example
+
+```ts
+import { expect } from 'chai';
+import { ethers } from 'hardhat';
+import {
+  ContractContext as MyVeryFirstContract,
+  GetFooResponse,
+  GetFooRequest,
+} from '../ethereum-abi-types/MyVeryFirstContract';
+
+describe('Example test', function () {
+  let contract: NftMetadataHelper;
+  beforeEach(async () => {
+    const contractFactory = await ethers.getContractFactory(
+      'MyVeryFirstContract'
+    );
+
+    // thats it you now have full typings on your contract
+    contract =
+      (await contractFactory.deploy()) as unknown as MyVeryFirstContract;
+  });
+
+  it('I love to write unit tests', async () => {
+    const foo: GetFooRequest = { fooBoo: true };
+    const result = await contract.getFoo(foo);
+
+    expect(result).to.equal(
+      { fooResponse: 'boo' }
+  });
+});
+```
+
 ### Using with web3 and ethers
 
 #### Web3 - https://www.npmjs.com/package/web3

abi-types-generator/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ethereum-abi-types-generator",
-  "version": "1.1.9",
+  "version": "1.2.0",
   "description": "Generate types from an ethereum ABI json file.",
   "main": "dist/index.js",
   "scripts": {

abi-types-generator/src/commands/generate.ts

@@ -4,7 +4,7 @@ import { ProgramOptions } from '../common/models/program-options';
 import { ConverterType } from '../converters/enums/converter-type';
 import AbiGenerator from '../converters/typescript/abi-generator';
 import { Provider } from '../converters/typescript/enums/provider';
-import { GenerateResponse } from '../converters/typescript/models/generate-response';
+import { HardhatFactory } from '../converters/typescript/hardhat-factory';
 import { CommandTypes } from './enums/command-types';
 
 const help = Helpers.getHelpMessageByCommandType(CommandTypes.generate);
@@ -17,18 +17,29 @@ export = {
 
     const language = cmd.options.lang || ConverterType.ts;
 
-    let generateResponse: GenerateResponse;
-
     try {
       switch (language) {
         case ConverterType.ts:
-          generateResponse = new AbiGenerator({
-            provider: (cmd.options.provider as Provider) || Provider.web3,
-            abiFileLocation: cmd.command,
-            outputPathDirectory: cmd.options.output,
-            name: cmd.options.name,
-            watch: cmd.options.watch !== undefined,
-          }).generate();
+          if (cmd.command === 'hardhat') {
+            const response = await new HardhatFactory().generate();
+            if (response) {
+              Logger.log(
+                `successfully created typings for all contracts for hardhat, these are saved in ${response}`
+              );
+            }
+          } else {
+            const generateResponse = new AbiGenerator({
+              provider: (cmd.options.provider as Provider) || Provider.web3,
+              abiFileLocation: cmd.command,
+              outputPathDirectory: cmd.options.output,
+              name: cmd.options.name,
+              watch: cmd.options.watch !== undefined,
+            }).generate();
+
+            Logger.log(
+              `successfully created typings for abi file ${generateResponse.abiJsonFileLocation} saved in ${generateResponse.outputLocation}`
+            );
+          }
           break;
         default:
           Logger.error(
@@ -40,9 +51,5 @@ export = {
       Logger.error(error.message);
       return;
     }
-
-    Logger.log(
-      `successfully created typings for abi file ${generateResponse.abiJsonFileLocation} saved in ${generateResponse.outputLocation}`
-    );
   },
 };

abi-types-generator/src/converters/typescript/abi-generator.ts

@@ -33,7 +33,7 @@ export default class AbiGenerator {
    */
   public generate(): GenerateResponse {
     this.clearAllQuotesFromContextInfo();
-    if (!this.isDirectory(this.getOutputPathDirectory())) {
+    if (!TypeScriptHelpers.isDirectory(this.getOutputPathDirectory())) {
       throw new Error('output path must be a directory');
     }
 
@@ -258,11 +258,14 @@ export default class AbiGenerator {
     }
 
     try {
-      const result: AbiItem[] = JSON.parse(
-        fs.readFileSync(abiFileFullPath, 'utf8')
-      );
+      // tslint:disable-next-line: no-any
+      const result: any = JSON.parse(fs.readFileSync(abiFileFullPath, 'utf8'));
+
+      if (result.abi) {
+        return result.abi;
+      }
 
-      return result;
+      return result as AbiItem[];
     } catch (error) {
       throw new Error(
         `Abi file ${abiFileFullPath} is not a json file. Abi must be a json file.`
@@ -281,15 +284,7 @@ export default class AbiGenerator {
    * Build the executing path
    */
   private buildExecutingPath(joinPath: string): string {
-    return path.resolve(process.cwd(), joinPath);
-  }
-
-  /**
-   * Check is a path is a directory
-   * @param pathValue The path value
-   */
-  private isDirectory(pathValue: string): boolean {
-    return fs.existsSync(pathValue) && fs.lstatSync(pathValue).isDirectory();
+    return TypeScriptHelpers.buildExecutingPath(joinPath);
   }
 
   /**

abi-types-generator/src/converters/typescript/common/helpers.ts

@@ -1,3 +1,5 @@
+import fs from 'fs-extra';
+import path from 'path';
 import { AbiInput, AbiOutput, SolidityType } from '../../../abi-properties';
 import Helpers from '../../../common/helpers';
 import { Provider } from '../enums/provider';
@@ -352,4 +354,19 @@ export default class TypeScriptHelpers {
 
     return `export type ${typeName} = ${result};`;
   }
+
+  /**
+   * Check is a path is a directory
+   * @param pathValue The path value
+   */
+  public static isDirectory(pathValue: string): boolean {
+    return fs.existsSync(pathValue) && fs.lstatSync(pathValue).isDirectory();
+  }
+
+  /**
+   * Build the executing path
+   */
+  public static buildExecutingPath(joinPath: string): string {
+    return path.resolve(process.cwd(), joinPath);
+  }
 }

abi-types-generator/src/converters/typescript/hardhat-factory.ts

@@ -0,0 +1,94 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { Logger } from '../../common/logger';
+import AbiGenerator from './abi-generator';
+import TypeScriptHelpers from './common/helpers';
+import { Provider } from './enums/provider';
+
+interface AbiFilePathContext {
+  path: string;
+  contractName?: string | undefined;
+}
+
+export class HardhatFactory {
+  /**
+   * Generate all hardhat contract typings
+   */
+  public async generate(): Promise<string | undefined> {
+    const contracts = TypeScriptHelpers.buildExecutingPath(
+      './artifacts/contracts'
+    );
+    if (!TypeScriptHelpers.isDirectory(contracts)) {
+      throw new Error(
+        'can not find the artifacts > contracts directory please make sure you run this command on the route of the project and have compiled your smart contracts'
+      );
+    }
+
+    const abiFilesPaths = await this.buildAbiFilesPathContext(contracts);
+    if (abiFilesPaths.length === 0) {
+      Logger.log(
+        'No contracts found in artifacts > contracts please make sure you have compiled your smart contracts'
+      );
+      return undefined;
+    }
+
+    const saveTypingsFolder = TypeScriptHelpers.buildExecutingPath(
+      './ethereum-abi-types'
+    );
+
+    if (!fs.existsSync(saveTypingsFolder)) {
+      fs.mkdirSync(saveTypingsFolder);
+    }
+
+    for (let i = 0; i < abiFilesPaths.length; i++) {
+      const generateResponse = new AbiGenerator({
+        provider: Provider.ethers_v5,
+        abiFileLocation: abiFilesPaths[i].path,
+        outputPathDirectory: saveTypingsFolder,
+        name: abiFilesPaths[i].contractName,
+      }).generate();
+
+      Logger.log(
+        `successfully created typings for abi file ${generateResponse.abiJsonFileLocation} saved in ${generateResponse.outputLocation}`
+      );
+    }
+
+    return saveTypingsFolder;
+  }
+
+  /**
+   * Build abi files path context
+   * @param directoryPath The directory path
+   * @param abiFiles The abi files
+   */
+  private async buildAbiFilesPathContext(
+    directoryPath: string,
+    abiFiles: AbiFilePathContext[] = []
+  ): Promise<AbiFilePathContext[]> {
+    const folder = await fs.promises.readdir(directoryPath);
+    for (let i = 0; i < folder.length; i++) {
+      const item = folder[i];
+      const itemPath = path.join(directoryPath, item);
+      //   console.log(item, itemPath);
+      if (TypeScriptHelpers.isDirectory(itemPath)) {
+        await this.buildAbiFilesPathContext(itemPath, abiFiles);
+      } else {
+        if (item.includes('.json')) {
+          try {
+            const metadata = JSON.parse(fs.readFileSync(itemPath, 'utf8'));
+            if (metadata.abi && Array.isArray(metadata.abi)) {
+              abiFiles.push({
+                path: itemPath,
+                contractName: metadata.contractName,
+              });
+            }
+          } catch (error) {
+            // mute it
+          }
+        }
+      }
+    }
+
+    return abiFiles;
+  }
+}