@0xweb/hardhat 0.1.0 → 0.1.1

package/.circleci/config.yml

@@ -0,0 +1,31 @@
+# See: https://circleci.com/docs/2.0/configuration-reference
+version: 2.1
+
+orbs:
+  # See the orb documentation here: https://circleci.com/developer/orbs/orb/circleci/node
+  node: circleci/node@5.0.2
+
+jobs:
+  build-and-test:
+    # These next lines define a Docker executor: https://circleci.com/docs/2.0/executor-types/
+    # https://circleci.com/developer/images/image/cimg/node
+    docker:
+      - image: cimg/node:18.0.0
+    steps:
+      - checkout
+      - node/install-packages:
+          pkg-manager: npm
+      - run:
+          name: Build Project
+          command: npm run build
+      - run:
+          name: Run tests
+          command: npm run test
+
+workflows:
+  # Inside the workflow, you provide the jobs you want to run, e.g this workflow runs the build-and-test job above.
+  # CircleCI will run this workflow on every commit.
+  # https://circleci.com/docs/2.0/configuration-reference/#workflows
+  TestRunner:
+    jobs:
+      - build-and-test

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,180 @@
+
+// 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 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')
+    .setAction(async (compilationArgs, { run, config }, runSuper) => {
+    if (compilationArgs.sources) {
+        config.paths.sources = process.cwd() + compilationArgs.sources;
+    }
+    if (compilationArgs.artifacts) {
+        config.paths.artifacts = process.cwd() + compilationArgs.artifacts;
+    }
+    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.1",
+    "main": "./lib/index.js",
     "author": {
         "name": "Alex Kit",
         "email": "alex.kit@atmajs.com"
@@ -18,16 +18,101 @@
     ],
     "license": "MIT",
     "dependencies": {
+        "0xweb": "^0.9.25",
+        "alot": "^0.3.0",
         "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"
+        ],
+        "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)
+# [Hardhat](https://hardhat.org/) plugin for [`0xWeb`](https://0xweb.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/src/config.ts

@@ -0,0 +1,13 @@
+import { HardhatConfig } from 'hardhat/types'
+
+import { _0xwebConfig } from './types'
+
+export function resolveConfig(config: HardhatConfig): _0xwebConfig {
+  const defaultConfig: _0xwebConfig = {
+  }
+
+  return {
+    ...defaultConfig,
+    ...(config['0xweb'] ?? {}),
+  };
+}

package/src/constants.ts

@@ -0,0 +1,2 @@
+export const TASK_0xWEB = '0xweb'
+export const TASK_0xWEB_GENERATE = '0xweb:generate'

package/src/index.ts

@@ -0,0 +1,120 @@
+import alot from 'alot'
+import { TASK_CLEAN, TASK_COMPILE, TASK_COMPILE_SOLIDITY_COMPILE_JOBS } from 'hardhat/builtin-tasks/task-names'
+import { extendConfig, subtask, task } from 'hardhat/config'
+import { resolveConfig } from './config'
+import { TASK_0xWEB, TASK_0xWEB_GENERATE } from './constants'
+import { Directory } from 'atma-io'
+import { App } from '0xweb'
+
+const taskArgsStore = { compileAll: false }
+
+extendConfig((config) => {
+    config['0xweb'] = resolveConfig(config)
+})
+
+task(TASK_COMPILE, 'Compiles the entire project, building all artifacts')
+    .addOptionalParam('sources', 'Override the sources directory')
+    .addOptionalParam('artifacts', 'Override the artifacts output directory')
+    .setAction(async (compilationArgs, { run, config }, runSuper) => {
+
+        if (compilationArgs.sources) {
+            config.paths.sources = process.cwd() + compilationArgs.sources;
+        }
+        if (compilationArgs.artifacts) {
+            config.paths.artifacts = process.cwd() + compilationArgs.artifacts;
+        }
+        await runSuper()
+    });
+
+subtask(TASK_COMPILE_SOLIDITY_COMPILE_JOBS, 'Compiles the entire project, building all artifacts')
+    .setAction(async (taskArgs, { run }, runSuper) => {
+        const compileSolOutput = await runSuper(taskArgs)
+        await run(TASK_0xWEB_GENERATE, { compileSolOutput })
+        return compileSolOutput
+    });
+
+subtask(TASK_0xWEB_GENERATE)
+    .setAction(async (a, b) => {
+        let { compileSolOutput } = a;
+        let { config, artifacts } = b;
+
+        const contracts = await getCompiledAbis(config, compileSolOutput)
+
+        const app = new App();
+        await alot(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 })
+    });
+
+task(TASK_0xWEB, 'Generate 0xWeb classes for compiled contracts')
+    .setAction(async (_, { run }) => {
+        taskArgsStore.compileAll = true
+        await run(TASK_COMPILE, { quiet: true })
+    });
+
+task(TASK_CLEAN, 'Clears the cache and deletes all artifacts')
+    .setAction(async ({ global }: { global: boolean }, { config }, runSuper) => {
+        if (global) {
+            return;
+        }
+        const dir = `/0xweb/hardhat/`;
+        if (await Directory.existsAsync(dir)) {
+            await Directory.removeAsync(dir);
+        }
+        await runSuper()
+    });
+
+async function getCompiledAbis(config: { paths: { artifacts: string } }, compileSolOutput: {
+    artifactsEmittedPerJob: {
+        artifactsEmittedPerFile: {
+            file: {
+                sourceName: string
+                absolutePath: string
+            }
+            artifactsEmitted: string[]
+        }[]
+    }[]
+}): Promise<{ name: string, path: string }[]> {
+
+    const emitedArtifacts = alot(compileSolOutput.artifactsEmittedPerJob).mapMany((a) => {
+        return alot(a.artifactsEmittedPerFile).mapMany((artifactPerFile) => {
+            return alot(artifactPerFile.artifactsEmitted).map((artifactName) => {
+                return {
+                    name: artifactName,
+                    sourceFile: 'file://' + artifactPerFile.file.absolutePath
+                };
+            }).toArray();
+        }).toArray();
+    }).toArray();
+
+    let namesHash = alot(emitedArtifacts).toDictionary(x => x.name);
+    let files = await 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;
+}

package/src/types.ts

@@ -0,0 +1,4 @@
+
+export interface _0xwebConfig {
+
+}

package/test/compile.spec.ts

@@ -0,0 +1,25 @@
+import { run } from 'shellbee'
+import { File, Directory } from 'atma-io'
+
+const PROJ = `./test/fixtures/hardhat-project/`;
+const PROJ_ARTIFACTS = `${PROJ}/artifacts/`;
+const PROJ_0xWEB = `${PROJ}/0xweb/`;
+UTest({
+    async $before () {
+        if (Directory.exists(PROJ_ARTIFACTS)) {
+            await Directory.removeAsync(PROJ_ARTIFACTS);
+        }
+        if (Directory.exists(PROJ_0xWEB)) {
+            await Directory.removeAsync(PROJ_0xWEB);
+        }
+    },
+    async 'should compile the project' () {
+
+        let result = await run({
+            command: 'node --openssl-legacy-provider compile.js',
+            cwd: PROJ
+        });
+        let content = await File.readAsync(`${PROJ_0xWEB}/hardhat/Foo/Foo.ts`, { skipHooks: true });
+        has_(content, 'class Foo extends ContractBase');
+    }
+})

package/test/config.js

@@ -0,0 +1,8 @@
+module.exports = {
+    suites: {
+        node : {
+            exec: 'node',
+            tests: 'test/**.spec.ts'
+        }
+    }
+};

package/test/fixtures/hardhat-project/0xweb.json

@@ -0,0 +1,10 @@
+{
+  "contracts": {
+    "hardhat": {
+      "file://D:/eth/0xweb-hardhat/test/fixtures/hardhat-project/artifacts/contracts/Foo.sol/Foo.json": {
+        "name": "Foo",
+        "main": "./0xweb/hardhat/Foo/Foo.ts"
+      }
+    }
+  }
+}

package/test/fixtures/hardhat-project/compile.js

@@ -0,0 +1,6 @@
+const hh = require('hardhat');
+
+(async function() {
+    await hh.run('compile');
+    process.exit();
+}());

package/test/fixtures/hardhat-project/contracts/Foo.sol

@@ -0,0 +1,19 @@
+pragma solidity ^0.8.2;
+
+contract Foo {
+    string public name;
+    event Updated (string newName);
+
+    constructor(string memory _name) {
+        name = _name;
+    }
+
+    function setName(string memory _name) public {
+        name = _name;
+        emit Updated(name);
+    }
+
+    function getName () public view returns (string memory) {
+        return name;
+    }
+}

package/test/fixtures/hardhat-project/hardhat.config.js

@@ -0,0 +1,21 @@
+
+require("@nomiclabs/hardhat-web3");
+require("@nomiclabs/hardhat-waffle");
+require('../../../lib/index');
+
+module.exports = {
+    solidity: {
+        version: "0.8.2",
+        settings: {
+            optimizer: {
+                enabled: true,
+                runs: 200
+            }
+        }
+    },
+    networks: {
+        hardhat: {
+            chainId: 1337
+        }
+    }
+};

package/test/fixtures/integration/compile.js

@@ -0,0 +1,8 @@
+const hh = require('hardhat');
+
+(async function() {
+    await hh.run('compile', {
+        sources: '/foo/bar'
+    });
+    process.exit();
+}());

package/test/fixtures/integration/example.ts

@@ -0,0 +1,25 @@
+import { Config } from '@dequanto/Config';
+import { HardhatProvider } from '@dequanto/hardhat/HardhatProvider';
+import { Foo } from '@0xweb/hardhat/Foo/Foo';
+
+(async function () {
+
+    await Config.fetch()
+
+    const provider = new HardhatProvider();
+    const foo = await provider.resolve<Foo>(Foo, 'Lorem');
+
+    '> Get initial value'
+    let name = await foo.getName();
+    console.log(`First:`, name);
+
+    '> Submit value'
+    let tx = await foo.setName(provider.deployer(), 'ResetLorem');
+    await tx.wait();
+
+    '> Get new value'
+    name = await foo.getName();
+    console.log(`Second:`, name);
+
+    process.exit();
+}());

package/test/fixtures/integration/foo/bar/Foo.sol

@@ -0,0 +1,19 @@
+pragma solidity ^0.8.2;
+
+contract Foo {
+    string public name;
+    event Updated (string newName);
+
+    constructor(string memory _name) {
+        name = _name;
+    }
+
+    function setName(string memory _name) public {
+        name = _name;
+        emit Updated(name);
+    }
+
+    function getName () public view returns (string memory) {
+        return name;
+    }
+}

package/test/integration.spec.ts

@@ -0,0 +1,67 @@
+import { run } from 'shellbee'
+import { File, Directory } from 'atma-io'
+import alot from 'alot';
+
+const PROJ = `./test/fixtures/integration/`;
+const PROJ_ARTIFACTS = `${PROJ}/artifacts/`;
+const PROJ_0xWEB = `${PROJ}/0xweb/`;
+const PROJ_DEQUANTO = `${PROJ}/dequanto/`;
+UTest({
+    $config: {
+        timeout: 1000 * 60 * 15
+    },
+    async $before () {
+        let clean = [
+            PROJ_ARTIFACTS,
+            PROJ_0xWEB,
+            PROJ_DEQUANTO,
+            `${PROJ}/node_modules/`,
+            `${PROJ}/package.json`,
+            `${PROJ}/hardhat.config.js`,
+        ];
+        await alot(clean).forEachAsync(async path => {
+            const Ctor = /\.\w+$/.test(path) ? File : Directory;
+            if (await Ctor.existsAsync(path)) {
+                await Ctor.removeAsync(path);
+            }
+        })
+    },
+    async $after () {
+        await Directory.removeAsync(`${PROJ}/.git/`);
+        await File.removeAsync(`${PROJ}/.gitmodules`);
+    },
+    async 'should initialize and compile the project' () {
+        let { stdout } = await run({
+            command: `0xweb -v`,
+            silent: true
+        });
+        let has0xWeb = /0xweb@\d+\.\d+\.\d+/.test(stdout.join('\n'));
+        if (has0xWeb === false) {
+            await run({
+                command: 'npm i 0xweb -g',
+                cwd: PROJ
+            });
+        }
+        await run({
+            command: '0xweb init --hardhat',
+            cwd: PROJ
+        });
+
+        await File.replaceAsync(`${PROJ}/hardhat.config.js`, '@0xweb/hardhat', '../../../lib/index');
+
+        await run({
+            command: 'node --openssl-legacy-provider compile.js',
+            cwd: PROJ
+        });
+
+        {
+            let { stdout } = await run({
+                command: 'npx atma --openssl-legacy-provider run example.ts',
+                cwd: PROJ
+            });
+
+            has_(stdout.join('\n'), /First: Lorem/g);
+            has_(stdout.join('\n'), /Second: ResetLorem/g);
+        }
+    }
+})

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/typings/globals/assertion/index.d.ts

@@ -0,0 +1,159 @@
+// Generated by typings
+// Source: https://raw.githubusercontent.com/atmajs/assertion/master/types/assertion.d.ts
+declare module "assertion" {
+	export = assert;
+}
+
+declare var assert: assertion.IAssert
+
+declare var eq_: assertion.equal
+declare var notEq_: assertion.notEqual
+declare var lt_: assertion.lessThan
+declare var lte_: assertion.lessThanOrEqual
+declare var gt_: assertion.greaterThan
+declare var gte_: assertion.greaterThanOrEqual
+declare var deepEq_: assertion.deepEqual
+declare var notDeepEq_: assertion.notDeepEqual
+declare var has_: assertion.has
+declare var hasNot_: assertion.hasNot
+declare var is_: assertion.is
+declare var isNot_: assertion.isNot
+
+
+declare namespace assertion {
+	interface IAssert {
+		(expression: boolean, message: string): void
+		equal: equal
+		notEqual: notEqual
+		strictEqual: strictEqual
+		notStrictEqual: notStrictEqual
+		throws: throws
+		notThrows: notThrows
+		ifError: ifError
+		lessThan: lessThan
+		lessThanOrEqual: lessThanOrEqual
+		
+		greaterThan: greaterThan
+		greaterThanOrEqual: greaterThanOrEqual
+		deepEqual: deepEqual
+		notDeepEqual: notDeepEqual
+		has: has
+        hasNot: hasNot        
+        is: is
+
+        on: on
+        
+        /**
+         *  string: Await Name for better logging
+         *  number: expectation count
+         *  object: binded content
+         *  function: wrap any function
+         */
+        await (
+            arg1?: string | number | Function | object,   
+            arg2?: string | number | Function | object,   
+            arg3?: string | number | Function | object,   
+            arg4?: string | number | Function | object,   
+        ): Function
+        
+        
+        /**
+         *  string: Await Name for better logging
+         *  number: expectation count, default is `1`
+         *  object: binded content
+         *  function: wrap any function
+         */
+        avoid (
+			arg1?: string | number | Function | object,   
+            arg2?: string | number | Function | object,   
+            arg3?: string | number | Function | object,   
+            arg4?: string | number | Function | object,   
+		);
+	}
+	interface equal {
+		(a: any, b: any, message?: string)
+	}
+	interface notEqual {
+		(a: any, b: any, message?: string)
+	}
+	interface strictEqual {
+		(a: any, b: any, message?: string)		
+	}
+	interface notStrictEqual {
+		(a: any, b: any, message?: string)			
+	}
+	interface throws {
+		(a: Function, message?: string): Error	
+	}
+	interface notThrows {
+		(a: Function, message?: string): Error	
+	}
+	interface ifError {
+		(a: any, message?: string)			
+	}	
+	interface lessThan {
+		(a: any, b: any, message?: string)
+	}
+	interface lessThanOrEqual {
+		(a: any, b: any, message?: string)
+	}
+	interface greaterThan {
+		(a: any, b: any, message?: string)
+	}
+	interface greaterThanOrEqual {
+		(a: any, b: any, message?: string)
+	}
+	interface deepEqual {
+		(a: any, b: any, message?: string)
+	}
+	interface notDeepEqual {
+		(a: any, b: any, message?: string)
+	}
+	interface has {
+		(a: any, b: any, message?: string)
+    }
+    interface is {
+        (a: any, b: 
+            'String' |
+            'Number' |
+            'Null' |
+            'Undefined' |
+            'Function' |
+            'RegExp' |
+            'Date' |
+            'Object' |
+            'CustomEvent' |
+            null | 
+            any, message?: string)
+    }
+    interface isNot {
+		(a: any, b: 
+            'String' |
+            'Number' |
+            'Null' |
+            'Undefined' |
+            'Function' |
+            'RegExp' |
+            'Date' |
+            'Object' |
+            'CustomEvent' |
+            null | 
+            any, message?: string)
+	}
+	interface hasNot {
+		(a: any, b: any, message?: string)
+	}
+
+
+	/** Notice: when `fail` callback is defined the assertion doesn`t throw any error */
+	interface on {
+		(event: 'start' | 'fail' | 'success', callback: (error?: AssertionError) => void)
+	}
+	
+
+	interface AssertionError extends Error {
+		actual: any
+		expected: any
+		operator: string
+	}
+}

package/typings/globals/assertion/typings.json

@@ -0,0 +1,10 @@
+{
+  "resolution": "main",
+  "tree": {
+    "src": "https://raw.githubusercontent.com/atmajs/assertion/master/typings.json",
+    "raw": "github:atmajs/assertion/typings.json",
+    "main": "types/assertion.d.ts",
+    "global": true,
+    "name": "assertion"
+  }
+}

package/typings/globals/atma-utest/index.d.ts

@@ -0,0 +1,53 @@
+// Generated by typings
+// Source: https://raw.githubusercontent.com/atmajs/utest/master/types/index.d.ts
+declare module "atma-utest" {
+    export = UTest;
+}
+
+declare var UTest: IUtest;
+
+declare interface IUtest {
+    (definition: IUTestDefinition): void
+
+    domtest: IDomTest
+    request (url, method, headers, data, callback)
+    server: {
+        render (template: string, ...args)
+    }
+
+    benchmark (model: IUTestDefinition)
+    benchmarkVersions (model: IUTestDefinition)
+
+}
+
+interface IDomTest {
+    (subject: HTMLElement | JQuery | any, testMarkup: string | any): PromiseLike<any>
+    use (astName: string): IDomTest
+    process (subject: HTMLElement | JQuery | any, testMarkup: string | any): PromiseLike<any>
+}
+
+interface IUTestDefinition {
+    $config?: {
+        timeout?: number
+        errorableCallbacks?: boolean
+        breakOnError?: boolean
+
+        'http.config'?: any
+        'http.eval'?: string
+        'http.include'?: any
+        'http.service'?: any
+        'http.process'?: any
+        'util.process'?: any   
+    }
+    $before?: (done?: Function) => void | PromiseLike<any>
+    $after?: (done?: Function) => void | PromiseLike<any>
+    $teardown?: (done?: Function) => void | PromiseLike<any>
+
+    
+
+    [key: string]: ITestCase | IUTestDefinition | any
+}
+
+interface ITestCase {
+    (done?: Function, ...args: any[]): void | PromiseLike<any> | any
+}

package/typings/globals/atma-utest/typings.json

@@ -0,0 +1,10 @@
+{
+  "resolution": "main",
+  "tree": {
+    "src": "https://raw.githubusercontent.com/atmajs/utest/master/typings.json",
+    "raw": "github:atmajs/utest/typings.json",
+    "main": "types/index.d.ts",
+    "global": true,
+    "name": "atma-utest"
+  }
+}

package/typings/index.d.ts

@@ -0,0 +1,2 @@
+/// <reference path="globals/assertion/index.d.ts" />
+/// <reference path="globals/atma-utest/index.d.ts" />

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');
-    }
-}