Refactor v2

.env.example

@@ -1,3 +1,26 @@
-ETHERSCAN_API_KEY=ABC123ABC123ABC123ABC123ABC123ABC1
-ROPSTEN_URL=https://eth-ropsten.alchemyapi.io/v2/<YOUR ALCHEMY KEY>
-PRIVATE_KEY=0xabc123abc123abc123abc123abc123abc123abc123abc123abc123abc123abc1
+LOCALNET_PRIVATE_KEY=1f84c95ac16e6a50f08d44c7bde7aff8742212fda6e4321fde48bf83bef266dc
+LOCALGETH_PRIVATE_KEY=ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80
+HARDHAT_PRIVATE_KEY=ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80
+HARDHAT_URL=http://localhost:8545
+LOCALNET_URL=http://localhost:9500
+DEVNET_URL=https://api.s0.ps.hmny.io/
+TESTNET_URL=https://api.s0.b.hmny.io
+MAINNET_URL=https://api.harmony.one
+LOCALGETH_URL=http://localhost:8645
+ROPSTEN_URL =https://ropsten.infura.io/v3/32c32c32c32c32c32c32c32c32c32c32
+SEPOLIA_URL=https://rpc.sepolia.dev
+ETHEREUM_URL=https://mainnet.infura.io/v3/32c32c32c32c32c32c32c32c32c32c32
+ETHERSCAN_API_KEY=R8N14TD8CJ5NJ1BAGBJ23E718K9CWHUHEM
+PRIVATE_KEY=1f84c95ac16e6a50f08d44c7bde7aff8742212fda6e4321fde48bf83bef266dc
+HMY_URL=http://localhost:9500
+ETH_URL=http://localhost:8645
+GAS_LIMIT=6000000
+GAS_PRICE=20000000000
+ERC20=0x876dEfe099Ff0C2E13b0c7B4b9101859e52c07c6
+HMY_TOKEN_LOCKER=0x017f8C7d1Cb04dE974B8aC1a6B8d3d74bC74E7E1
+ETH_TOKEN_LOCKER=0x017f8C7d1Cb04dE974B8aC1a6B8d3d74bC74E7E1
+VERBOSE=true
+HLC_INITIAL_BLOCK=1
+RELAYERS=["0x0B585F8DaEfBC68a311FbD4cB20d9174aD174016"]
+THRESHOLD=1
+ELC_INIITAL_BLOCK=55

.gitignore

@@ -4,18 +4,21 @@
 */.env
 .env
 */node_modules
+.nvmrc
 /old_contracts
 /back
 build
 cache
+
+# Ignore dag and data ffiles
+data
 */.dag
 */dag*
 */*/.dag/*
 */*/dag/
-.openzeppelin
+#.openzeppelin
 
 node_modules
-build/contracts
 yarn-error.log
 coverage
 coverage.json
@@ -32,10 +35,17 @@ dist/**/*
 # Ignore solidity documentation until code has been documented
 docs/solidity
 
-data/abi
+# Ignore solidity files used for analysis
+docs/slither
+
+# Ignore generated easy to read abi definitions
+docs/abi
 
 # Ignore generated typescript definitions
 typechain
 
 # webstorm
-.idea
+.idea
+
+# Local Network data
+localgeth/data

README.md

@@ -40,6 +40,6 @@ Horizon - a trustless harmony to ethereum bridge
 <img src="docs/assets/hmy2eth.png" alt="drawing" width="600"/>
 
 ## Additional Reading
-1. [Developer Guide ](./docs/DEVELOPER.md)
+1. [Developer Guide ](./docs/README.md)
 2. [Solidity Approach](./docs/SOLIDITY.md)
 3. [Solidity generated documentation](./docs/solidity/)

config.js

@@ -0,0 +1,32 @@
+require('dotenv').config()
+
+module.exports = {
+    localnetPrivateKey: process.env.LOCALNET_PRIVATE_KEY,
+    localgethPrivateKey: process.env.LOCALGETH_PRIVATE_KEY,
+    hardhatPrivateKey: process.env.HARDHAT_PRIVATE_KEY,
+    hardhatURL: process.env.HARDHAT_URL,
+    localnetURL: process.env.LOCALNET_URL,
+    devnetURL: process.env.DEVNET_URL,
+    testnetURL: process.env.TESTNET_URL,
+    mainnetURL: process.env.MAINNET_URL,
+    localgethURL: process.env.LOCALGETH_URL,
+    ropstenURL: process.env.ROPSTEN_URL,
+    sepoliaURL: process.env.SEPOLIA_URL,
+    ethereumURL: process.env.ETHEREUM_URL,
+    etherscanAPI: process.env.ETHERSCAN_API_KEY,
+    privateKey: process.env.PRIVATE_KEY,
+    hmyURL: process.env.HMY_URL,
+    ethURL: process.env.ETH_URL,
+    gasLimit: process.env.GAS_LIMIT,
+    gasPrice: process.env.GAS_PRICE,
+    erc20: process.env.ERC20,
+    hmyTokenLocker: process.env.HMY_TOKEN_LOCKER,
+    ethTokenLocker: process.env.ETH_TOKEN_LOCKER,
+    verbose: process.env.VERBOSE === 'true' || process.env.VERBOSE === '1',
+    reportGas: false,
+    hlcInitialBlock: process.env.HLC_INITIAL_BLOCK,
+    // use JSON.parse to parse the array of relayers
+    relayers: JSON.parse(process.env.RELAYERS),
+    threshold: process.env.THRESHOLD,
+    elcInitialBlock: process.env.ELC_INIITAL_BLOCK
+}

contracts/FaucetToken.sol

@@ -1,23 +1,55 @@
 // SPDX-License-Identifier: UNLICENSED
 
-pragma solidity ^0.8.0;
-pragma experimental ABIEncoderV2;
+pragma solidity ^0.8.4;
 
 import "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20BurnableUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+
+contract FaucetToken is
+    Initializable,
+    ERC20Upgradeable,
+    ERC20BurnableUpgradeable,
+    PausableUpgradeable,
+    OwnableUpgradeable
+{
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor() {
+        _disableInitializers();
+    }
 
-contract FaucetToken is ERC20Upgradeable {
     function initialize(
         string memory name,
-        string memory symbol
-        // uint8 decimals
-    ) external initializer {
+        string memory symbol,
+        uint256 supply
+    ) public initializer {
         __ERC20_init(name, symbol);
-        // _setupDecimals(decimals);
+        __ERC20Burnable_init();
+        __Pausable_init();
+        __Ownable_init();
+        mint(owner(), supply);
+    }
+
+    function pause() public onlyOwner {
+        _pause();
     }
 
-    function mint() public returns (bool) {
+    function unpause() public onlyOwner {
+        _unpause();
+    }
+
+    function mint(address to, uint256 amount) public onlyOwner {
         uint256 UNIT = 10**uint256(decimals());
-        _mint(msg.sender, 10000 * UNIT);
-        return true;
+        _mint(to, amount * UNIT);
+    }
+
+    function _beforeTokenTransfer(
+        address from,
+        address to,
+        uint256 amount
+    ) internal override whenNotPaused {
+        super._beforeTokenTransfer(from, to, amount);
     }
 }

contracts/TokenRegistry.sol

@@ -45,20 +45,18 @@ contract TokenRegistry {
         return (TxTokens.length, RxTokens.length);
     }
 
-    function issueTokenMapReq(ERC20Upgradeable thisSideToken)
-        external
-    {
+    function issueTokenMapReq(ERC20Upgradeable thisSideToken) external {
         require(
             TxMapped[address(thisSideToken)] == address(0),
             "token is already mapped"
         );
-        ERC20Upgradeable tokenDetail = thisSideToken;
-        emit TokenMapReq(
-            address(thisSideToken),
-            tokenDetail.decimals(),
-            tokenDetail.name(),
-            tokenDetail.symbol()
-        );
+        // ERC20Upgradeable tokenDetail = thisSideToken;
+        // emit TokenMapReq(
+        //     address(thisSideToken),
+        //     tokenDetail.decimals(),
+        //     tokenDetail.name(),
+        //     tokenDetail.symbol()
+        // );
     }
 
     function onTokenMapReqEvent(bytes32[] memory topics, bytes memory data)
@@ -77,20 +75,14 @@ contract TokenRegistry {
         );
         bytes32 salt = bytes32(uint256(uint160(tokenReq)));
         BridgedToken mintAddress = new BridgedToken{salt: salt}();
-        mintAddress.initialize(
-            name,
-            symbol,
-            decimals
-        );
+        mintAddress.initialize(name, symbol, decimals);
         RxMappedInv[address(mintAddress)] = tokenReq;
         RxMapped[tokenReq] = mintAddress;
         RxTokens.push(mintAddress);
         emit TokenMapAck(tokenReq, address(mintAddress));
     }
 
-    function onTokenMapAckEvent(bytes32[] memory topics)
-        internal
-    {
+    function onTokenMapAckEvent(bytes32[] memory topics) internal {
         address tokenReq = address(uint160(uint256(topics[1])));
         address tokenAck = address(uint160(uint256(topics[2])));
         require(

contracts/ethash/MerkelRoot.sol

@@ -4,17 +4,26 @@ pragma solidity ^0.8.0;
 pragma experimental ABIEncoderV2;
 
 contract MerkelRoots {
-    uint64 constant epochStart = 411;
-    uint64 constant epochEnd = 411;
-    bytes constant ROOTS = "\xf8\x7d\x60\x5d\xd4\xbd\xaf\xc3\x9b\x13\xb4\x5b\x6a\xbf\x6b\x92\x11\x96\xb0\xf3\xb5\xd7\xc5\x1b\x31\x82\x06\x64\x10\x4a\x69\x7d";
+    // Ropsten DAG and epoch information
+    // uint64 constant epochStart = 411;
+    // uint64 constant epochEnd = 411;
+    // bytes constant ROOTS = "\xf8\x7d\x60\x5d\xd4\xbd\xaf\xc3\x9b\x13\xb4\x5b\x6a\xbf\x6b\x92\x11\x96\xb0\xf3\xb5\xd7\xc5\x1b\x31\x82\x06\x64\x10\x4a\x69\x7d";
 
-   function getRootHash(uint64 epoch) internal pure returns(bytes32 hash) {
-       bytes memory roots = ROOTS;
-       require(epoch >= epochStart && epoch <= epochEnd, "epoch out of range!");
-       uint256 index = epoch - epochStart + 1; // skip length
-       assembly{
-           hash := mload(add(roots, mul(index, 0x20)))
-       }
-   }
-}
+    // LocalGeth DAG and epoch information
+    uint64 constant epochStart = 0;
+    uint64 constant epochEnd = 0;
+    bytes constant ROOTS =
+        "\x2c\x2f\xcc\x07\x35\xc1\x71\xe5\x7f\x5f\xa4\x9f\x0d\x3b\x30\xf7\x77\xfa\x2e\xea\x35\x31\xf4\x18\x79\x7a\xf1\x4b\x1a\x98\xd9\xb8";
 
+    function getRootHash(uint64 epoch) internal pure returns (bytes32 hash) {
+        bytes memory roots = ROOTS;
+        require(
+            epoch >= epochStart && epoch <= epochEnd,
+            "epoch out of range!"
+        );
+        uint256 index = epoch - epochStart + 1; // skip length
+        assembly {
+            hash := mload(add(roots, mul(index, 0x20)))
+        }
+    }
+}

contracts/ethash/ethash.sol

@@ -41,7 +41,9 @@ contract Ethash is MerkelRoots {
     // the full 32-bit input, in contrast with the FNV-1 spec which multiplies the
     // prime with one byte (octet) in turn.
     function fnv(uint32 a, uint32 b) internal pure returns (uint32) {
-        return (a * 0x01000193) ^ b;
+        unchecked {
+            return (a * 0x01000193) ^ b;
+        }
     }
 
     // fnvHash mixes in data into mix using the ethash fnv method.

contracts/lib/RLPReader.sol

@@ -224,11 +224,15 @@ library RLPReader {
         return result;
     }
 
-    function toRlpBytesHash(RLPItem memory item) internal pure returns (bytes32 _hash) {
+    function toRlpBytesHash(RLPItem memory item)
+        internal
+        pure
+        returns (bytes32 _hash)
+    {
         require(item.len > 0);
         uint256 len = item.len;
         uint256 ptr = item.memPtr;
-        assembly{
+        assembly {
             _hash := keccak256(ptr, len)
         }
     }
@@ -333,11 +337,16 @@ library RLPReader {
         }
 
         // left over bytes. Mask is used to remove unwanted bytes from the word
-        uint256 mask = 256**(WORD_SIZE - len) - 1;
-        assembly {
-            let srcpart := and(mload(src), not(mask)) // zero out src
-            let destpart := and(mload(dest), mask) // retrieve the bytes
-            mstore(dest, or(destpart, srcpart))
+        if (len > 0) {
+            if (len >= WORD_SIZE) {
+                len = WORD_SIZE - 1;
+            }
+            uint256 mask = 256**(WORD_SIZE - len) - 1;
+            assembly {
+                let srcpart := and(mload(src), not(mask)) // zero out src
+                let destpart := and(mload(dest), mask) // retrieve the bytes
+                mstore(dest, or(destpart, srcpart))
+            }
         }
     }
 
@@ -360,14 +369,18 @@ library RLPReader {
     /*
      * @param get the RLP item by index. save gas.
      */
-    function safeGetItemByIndex(RLPItem memory item, uint idx) internal pure returns (RLPItem memory) {
+    function safeGetItemByIndex(RLPItem memory item, uint256 idx)
+        internal
+        pure
+        returns (RLPItem memory)
+    {
         require(isList(item), "RLPDecoder iterator is not a list");
 
-        uint endPtr = item.memPtr + item.len;
+        uint256 endPtr = item.memPtr + item.len;
 
-        uint memPtr = item.memPtr + _payloadOffset(item.memPtr);
-        uint dataLen;
-        for (uint i = 0; i < idx; i++) {
+        uint256 memPtr = item.memPtr + _payloadOffset(item.memPtr);
+        uint256 dataLen;
+        for (uint256 i = 0; i < idx; i++) {
             dataLen = _itemLength(memPtr);
             memPtr = memPtr + dataLen;
         }

deploy/000_fund_deployer.ts

@@ -0,0 +1,47 @@
+import { HardhatRuntimeEnvironment } from 'hardhat/types'
+import { DeployFunction } from 'hardhat-deploy/types'
+import { ethers } from 'hardhat'
+
+const config = require('../config.js')
+
+// Fund deployer acounts for local networks localgeth and localnet
+const deployFunction: DeployFunction = async function (
+    hre: HardhatRuntimeEnvironment
+) {
+    const { getNamedAccounts, getChainId } = hre
+    const { deployer } = await getNamedAccounts()
+    const chainId = await getChainId()
+
+    console.log(`chainId: ${chainId}`)
+    let funder
+    switch (chainId) {
+    // localgeth
+    case '8788':{
+        funder = new ethers.Wallet(config.localgethPrivateKey, ethers.provider)
+        break
+    }
+    // localnet
+    case '1666700000': {
+        funder = new ethers.Wallet(config.localnetPrivateKey, ethers.provider)
+        break
+    }
+    // hardhatNode
+    case '31337': {
+        funder = new ethers.Wallet(config.hardhatPrivateKey, ethers.provider)
+        break
+    }
+    }
+    if (funder !== undefined) {
+        const tx = await funder.sendTransaction({
+            to: deployer,
+            value: ethers.utils.parseEther('100')
+        })
+        await ethers.provider.waitForTransaction(tx.hash)
+    }
+    const balance = await ethers.provider.getBalance(deployer)
+    console.log(`deployer: ${deployer}, balance: ${ethers.utils.formatEther(balance)}`)
+}
+
+deployFunction.dependencies = []
+deployFunction.tags = ['Funding', 'Ethereum', 'Harmony']
+export default deployFunction