@0xweb/hardhat 0.1.0 → 0.1.2

package/hardhat.config.sample.js

@@ -1,6 +1,7 @@
 require("@nomiclabs/hardhat-web3");
 require("@nomiclabs/hardhat-waffle");
 require("@nomiclabs/hardhat-etherscan");
+require("@0xweb/hardhat");
 
 module.exports = {
     solidity: {

package/lib/index.js

@@ -0,0 +1,192 @@
+
+// source ./RootModule.js
+(function(){
+	
+	var _src_config = {};
+var _src_constants = {};
+
+// source ./ModuleSimplified.js
+var _src_config;
+(function () {
+    // ensure AMD is not active for the model, so that any UMD exports as commonjs
+    var define = null;
+    var exports = _src_config != null ? _src_config : {};
+    var module = { exports: exports };
+
+    "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveConfig = void 0;
+function resolveConfig(config) {
+    var _a;
+    const defaultConfig = {};
+    return {
+        ...defaultConfig,
+        ...((_a = config['0xweb']) !== null && _a !== void 0 ? _a : {}),
+    };
+}
+exports.resolveConfig = resolveConfig;
+//# sourceMappingURL=config.js.map
+//# sourceMappingURL=config.ts.map;
+
+    function __isObj(x) {
+        return x != null && typeof x === 'object' && x.constructor === Object;
+    }
+    if (_src_config === module.exports) {
+        // do nothing if
+    } else if (__isObj(_src_config) && __isObj(module.exports)) {
+        Object.assign(_src_config, module.exports);
+    } else {
+        _src_config = module.exports;
+    }
+
+    ;
+}());
+
+// end:source ./ModuleSimplified.js
+
+
+// source ./ModuleSimplified.js
+var _src_constants;
+(function () {
+    // ensure AMD is not active for the model, so that any UMD exports as commonjs
+    var define = null;
+    var exports = _src_constants != null ? _src_constants : {};
+    var module = { exports: exports };
+
+    "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TASK_0xWEB_GENERATE = exports.TASK_0xWEB = void 0;
+exports.TASK_0xWEB = '0xweb';
+exports.TASK_0xWEB_GENERATE = '0xweb:generate';
+//# sourceMappingURL=constants.js.map
+//# sourceMappingURL=constants.ts.map;
+
+    function __isObj(x) {
+        return x != null && typeof x === 'object' && x.constructor === Object;
+    }
+    if (_src_constants === module.exports) {
+        // do nothing if
+    } else if (__isObj(_src_constants) && __isObj(module.exports)) {
+        Object.assign(_src_constants, module.exports);
+    } else {
+        _src_constants = module.exports;
+    }
+
+    ;
+}());
+
+// end:source ./ModuleSimplified.js
+
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const alot_1 = require("alot");
+const path = require("path");
+const task_names_1 = require("hardhat/builtin-tasks/task-names");
+const config_1 = require("hardhat/config");
+const config_2 = _src_config;
+const constants_1 = _src_constants;
+const atma_io_1 = require("atma-io");
+const _0xweb_1 = require("0xweb");
+const taskArgsStore = { compileAll: false };
+(0, config_1.extendConfig)((config) => {
+    config['0xweb'] = (0, config_2.resolveConfig)(config);
+});
+(0, config_1.task)(task_names_1.TASK_COMPILE, 'Compiles the entire project, building all artifacts')
+    .addOptionalParam('sources', 'Override the sources directory')
+    .addOptionalParam('artifacts', 'Override the artifacts output directory')
+    .addOptionalParam('watch', 'Re-runs compilation task on changes')
+    .setAction(async (compilationArgs, { run, config }, runSuper) => {
+    if (compilationArgs.sources) {
+        config.paths.sources = path.join(process.cwd(), compilationArgs.sources);
+    }
+    if (compilationArgs.artifacts) {
+        config.paths.artifacts = path.join(process.cwd(), compilationArgs.artifacts);
+    }
+    if (compilationArgs.watch != null) {
+        const directory = `file://${config.paths.sources}/`;
+        atma_io_1.Directory.watch(directory, async (...args) => {
+            console.log('XX', args);
+            await runSuper();
+        });
+        await runSuper();
+        await new Promise(resolve => { });
+        return;
+    }
+    await runSuper();
+});
+(0, config_1.subtask)(task_names_1.TASK_COMPILE_SOLIDITY_COMPILE_JOBS, 'Compiles the entire project, building all artifacts')
+    .setAction(async (taskArgs, { run }, runSuper) => {
+    const compileSolOutput = await runSuper(taskArgs);
+    await run(constants_1.TASK_0xWEB_GENERATE, { compileSolOutput });
+    return compileSolOutput;
+});
+(0, config_1.subtask)(constants_1.TASK_0xWEB_GENERATE)
+    .setAction(async (a, b) => {
+    let { compileSolOutput } = a;
+    let { config, artifacts } = b;
+    const contracts = await getCompiledAbis(config, compileSolOutput);
+    const app = new _0xweb_1.App();
+    await (0, alot_1.default)(contracts)
+        .forEachAsync(async (contract, i) => {
+        console.log(`Generation ${contract.name}(${contract.path}) ${i}/${contracts.length}`);
+        await app.execute([`install`, `${contract.path}`, '--name', contract.name, '--chain', 'hardhat']);
+    })
+        .toArrayAsync({ threads: 1 });
+});
+(0, config_1.task)(constants_1.TASK_0xWEB, 'Generate 0xWeb classes for compiled contracts')
+    .setAction(async (_, { run }) => {
+    taskArgsStore.compileAll = true;
+    await run(task_names_1.TASK_COMPILE, { quiet: true });
+});
+(0, config_1.task)(task_names_1.TASK_CLEAN, 'Clears the cache and deletes all artifacts')
+    .setAction(async ({ global }, { config }, runSuper) => {
+    if (global) {
+        return;
+    }
+    const dir = `/0xweb/hardhat/`;
+    if (await atma_io_1.Directory.existsAsync(dir)) {
+        await atma_io_1.Directory.removeAsync(dir);
+    }
+    await runSuper();
+});
+async function getCompiledAbis(config, compileSolOutput) {
+    const emitedArtifacts = (0, alot_1.default)(compileSolOutput.artifactsEmittedPerJob).mapMany((a) => {
+        return (0, alot_1.default)(a.artifactsEmittedPerFile).mapMany((artifactPerFile) => {
+            return (0, alot_1.default)(artifactPerFile.artifactsEmitted).map((artifactName) => {
+                return {
+                    name: artifactName,
+                    sourceFile: 'file://' + artifactPerFile.file.absolutePath
+                };
+            }).toArray();
+        }).toArray();
+    }).toArray();
+    let namesHash = (0, alot_1.default)(emitedArtifacts).toDictionary(x => x.name);
+    let files = await atma_io_1.Directory.readFilesAsync(`file://${config.paths.artifacts}/`, '**.json');
+    let compileAll = taskArgsStore.compileAll;
+    let arr = files
+        .map(file => {
+        let path = file.uri.toString();
+        let match = /(?<name>[^\\\/]+)\.sol[\\\/]/.exec(path);
+        if (match == null) {
+            return null;
+        }
+        let name = match.groups.name;
+        if (compileAll !== true && name in namesHash === false) {
+            return null;
+        }
+        if (new RegExp(`${name}\\.json$`).test(path) === false) {
+            return null;
+        }
+        return {
+            name: name,
+            path: path
+        };
+    })
+        .filter(Boolean);
+    return arr;
+}
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.ts.map
+
+}());
+// end:source ./RootModule.js

package/package.json

@@ -1,8 +1,8 @@
 {
     "name": "@0xweb/hardhat",
-    "description": "Hardhat addon for 0xweb",
-    "version": "0.1.0",
-    "main": "./index.js",
+    "description": "Hardhat plugin for 0xweb",
+    "version": "0.1.2",
+    "main": "./lib/index.js",
     "author": {
         "name": "Alex Kit",
         "email": "alex.kit@atmajs.com"
@@ -18,16 +18,103 @@
     ],
     "license": "MIT",
     "dependencies": {
+        "0xweb": "^0.9.25",
+        "alot": "^0.3.0",
+        "atma-io": "^1.2.65",
         "memd": "^0.3.10"
     },
     "peerDependencies": {
         "@nomiclabs/hardhat-etherscan": ">=3.0.3",
         "@nomiclabs/hardhat-waffle": ">=2.0.3",
         "@nomiclabs/hardhat-web3": ">=2.0.0",
-        "ethers": ">=5.6.4",
         "hardhat": ">=2.9.3"
     },
     "scripts": {
-
+        "build": "app-bundler",
+        "watch": "app-bundler --watch",
+        "test": "atma --openssl-legacy-provider test",
+        "release": "echo \"Run atma pub -m \"message\"\""
+    },
+    "devDependencies": {
+        "app-bundler": "^0.1.7",
+        "atma": "^0.15.17",
+        "shellbee": "^0.5.22"
+    },
+    "app-bundler": {
+        "file": "src/index.ts",
+        "outputMain": "lib/index.js",
+        "package": {
+            "module": "commonjs",
+            "commonjs": {
+                "output": "simplified"
+            }
+        },
+        "extensions": {
+            "io": {
+                "type": "js"
+            }
+        },
+        "defaultExtensions": {
+            "js": "ts"
+        },
+        "dynamicDependencies": [
+            "alot",
+            "atma-io",
+            "0xweb",
+            "^hardhat",
+            "path"
+        ],
+        "middlewares": {
+            "ts": [
+                "atma-loader-ts:read"
+            ]
+        },
+        "settings": {
+            "atma-loader-ts": {
+                "typescript": {
+                    "compilerOptions": {
+                        "module": "CommonJS",
+                        "lib": [
+                            "ES2019"
+                        ],
+                        "target": "ES2019"
+                    }
+                }
+            }
+        }
+    },
+    "atma": {
+        "plugins": [
+            "atma-loader-ts"
+        ],
+        "settings": {
+            "atma-utest": {
+                "include": {
+                    "amd": true,
+                    "extentionDefault": {
+                        "js": "ts"
+                    }
+                }
+            },
+            "include": {
+                "amd": true,
+                "extentionDefault": {
+                    "js": "ts"
+                }
+            },
+            "atma-loader-ts": {
+                "typescript": {
+                    "compilerOptions": {
+                        "#if (TEST)": {
+                            "module": "AMD"
+                        },
+                        "#if (!TEST)": {
+                            "module": "commonjs"
+                        },
+                        "sourceMap": false
+                    }
+                }
+            }
+        }
     }
 }

package/readme.md

@@ -1,8 +1,99 @@
-# [Hardhat](https://hardhat.org/) addon for [`0xWeb`](https://0xweb.org)
+# [`0xWeb`](https://0xweb.org) plugin for [Hardhat](https://hardhat.org/)
 
 
-### Distribution `as-Source-Code`
+----
+[![npm version](https://badge.fury.io/js/@0xweb%2Fhardhat.svg)](https://badge.fury.io/js/@0xweb%2Fhardhat)
+[![CircleCI](https://circleci.com/gh/0xweb-org/hardhat.svg?style=svg)](https://circleci.com/gh/0xweb-org/hardhat)
+
+
+The plugin generates `0xWeb` classes for compiled solidity contracts, making the blockchain development transparent.
+
+> We use [📦 dequanto library](https://github.com/0xweb-org/dequanto) for the classes
+
+---
+[Documentation 📜](https://docs.0xweb.org/hardhat/info)
+---
+
+# Install
+
+### Install automatically the dependencies and configurations
+```bash
+# install 0xweb
+$ npm i 0xweb -g
+
+# initiallize 0xweb and hardhat project
+$ 0xweb init --hardhat
+```
+
+
+
+# Compile
+
+> `any/directory/Foo.sol`
+
+```solidity
+pragma solidity ^0.8.2;
+
+contract Foo {
+    string public name;
+
+    function setName(string memory _name) public {
+        name = _name;
+    }
+}
+
+```
+
+> Plugin adds also ability to specify the `sources` folder. As per default this is `/contracts/**.sol`
+
+```bash
+$ npx hardhat compile --sources ./any/directory/
+```
+
+# Use in local development
+
+> `example.ts`
+```ts
+import { Foo } from '@0xweb/hardhat/Foo/Foo.ts'
+import { HardhatProvider } from '@dequanto/hardhat/HardhatProvider'
+
+// automatically deploys the contract to hardhat chain
+const deployer = new HardhatProvider();
+const foo = await deployer.resolve(Foo);
+
+// write
+const tx = await foo.setName('Hello world')
+const receipt = await tx.wait();
+
+// read
+const text = await foo.name();
+
+```
+
+# Use already deployed contracts to any chain
+
+If the contract is already deployed, initialize the contract with the Address as normal class. If the contract is deployed to any other chain - set also the client in constructor
+
+> `example.ts`
+```ts
+import { Foo } from '@0xweb/hardhat/Foo/Foo.ts'
+import { EthWeb3Client } from '@dequanto/clients/EthWeb3Client'
+
+
+const client =  new EthWeb3Client();
+const foo = new Foo('0x12345...', client);
+
+// write
+const tx = await foo.setName('Hello world');
+const receipt = tx.wait();
+// read
+const text = await foo.name();
+```
+
+
+# Additional parameters
 
-A factory class to initialize and configurate the generated contract class by `0xweb` to be used in `Hardhat` network - `in-process` or `localhost`
+- `npx hardhat compile --source /foo/bar/qux` - compiles solidity files which are located outside the `/contracts` folder
+- `npx hardhat compile --artifacts /dist` - set custom folder for artifacts (ABI JSONs and TS contracts)
 
 ----

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+    "exclude": ["node_modules"],
+    "compilerOptions": {
+        "outDir": "ts-temp",
+        "lib": ["es2020"],
+        "typeRoots": [
+            "node_modules/@types",
+            "typings",
+            "typings/globals",
+            "typings-other"
+        ],
+        "types": ["node", "assertion", "atma-utest"],
+        "declaration": true,
+        "target": "es2020",
+        "module": "commonjs",
+        "sourceMap": false,
+        "experimentalDecorators": true
+    }
+}

package/index.ts

@@ -1,49 +0,0 @@
-import hre from "hardhat";
-import memd from 'memd';
-import type Ethers from 'ethers'
-import { ContractBase } from '@dequanto/contracts/ContractBase';
-import { type Constructor } from 'atma-utils/mixin';
-import { ChainAccount } from '@dequanto/ChainAccounts';
-import { HardhatWeb3Client } from '@dequanto/clients/HardhatWeb3Client';
-
-export class HardhatWeb {
-
-    @memd.deco.memoize()
-    static deployer(index: number = 0): ChainAccount {
-        const ethers: typeof Ethers = (hre as any).ethers;
-        const accounts: any = hre.config.networks.hardhat.accounts;
-        const wallet = ethers.Wallet.fromMnemonic(accounts.mnemonic, accounts.path + `/${index}`);
-        return {
-            key: wallet.privateKey,
-            address: wallet.address,
-        };
-    }
-
-    @memd.deco.memoize()
-    static async resolve<T extends ContractBase>(Ctor: Constructor<T>): Promise<T> {
-
-        await ContractProvider.compile();
-
-        const ethers = (hre as any).ethers;
-
-        const Factory: Ethers.ContractFactory = await ethers.getContractFactory(Ctor.name);
-        const contract = await Factory.deploy();
-        const receipt = await contract.deployed();
-
-        console.log(`Contract ${Ctor.name} deployed to ${contract.address}`);
-
-        const client = ContractProvider.client();
-        return new Ctor(contract.address, client);
-    }
-
-    static client() {
-        const web3 = (hre as any).web3;
-        const client = new HardhatWeb3Client({ web3, chainId: 1337 });
-        return client;
-    }
-
-    @memd.deco.memoize()
-    private static async compile () {
-        await hre.run('compile');
-    }
-}