init project

Author: mingming.tang

README.md

@@ -0,0 +1,13 @@
+# Sample Hardhat Project
+
+This project demonstrates a basic Hardhat use case. It comes with a sample contract, a test for that contract, and a script that deploys that contract.
+
+Try running some of the following tasks:
+
+```shell
+npx hardhat help
+npx hardhat test
+REPORT_GAS=true npx hardhat test
+npx hardhat node
+npx hardhat run scripts/deploy.js
+```

contracts/BulkSender.sol

@@ -0,0 +1,14 @@
+
+// SPDX-License-Identifier: SimPL-3.0
+pragma solidity ^0.8.17;
+contract BulkSender{
+
+    function batchTransfer(address payable[] memory toList) payable public returns(uint256) {
+        uint256 singleAmount = msg.value / toList.length;
+        for (uint8 i=0; i<toList.length; i++) {
+            address payable to = toList[i];
+            to.transfer(singleAmount);
+        }
+        return singleAmount;
+    }
+}

contracts/FallbackFunction.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+contract FallbackFunction {
+
+    uint private callCount;
+
+    constructor() {
+        callCount = 0;
+    }
+
+    function getCallCount() public view returns(uint) {
+        return callCount;
+    }
+
+    fallback() external {
+        callCount += 1;
+    }
+}

contracts/Lock.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.9;
+
+// Uncomment this line to use console.log
+// import "hardhat/console.sol";
+
+contract Lock {
+    uint public unlockTime;
+    address payable public owner;
+
+    event Withdrawal(uint amount, uint when);
+
+    constructor(uint _unlockTime) payable {
+        require(
+            block.timestamp < _unlockTime,
+            "Unlock time should be in the future"
+        );
+
+        unlockTime = _unlockTime;
+        owner = payable(msg.sender);
+    }
+
+    function withdraw() public {
+        // Uncomment this line, and the import of "hardhat/console.sol", to print a log in your terminal
+        // console.log("Unlock time is %o and block timestamp is %o", unlockTime, block.timestamp);
+
+        require(block.timestamp >= unlockTime, "You can't withdraw yet");
+        require(msg.sender == owner, "You aren't the owner");
+
+        emit Withdrawal(address(this).balance, block.timestamp);
+
+        owner.transfer(address(this).balance);
+    }
+}

contracts/Test_1.sol

@@ -0,0 +1,13 @@
+pragma solidity ^0.8.9;
+
+contract Person {
+    string name;
+
+    function getName() public view returns (string memory) {
+        return name;
+    }
+
+    function setName(string memory name_) public {
+        name = name_;
+    }
+}

hardhat.config.js

@@ -0,0 +1,13 @@
+require("@nomicfoundation/hardhat-toolbox");
+
+/** @type import('hardhat/config').HardhatUserConfig */
+module.exports = {
+  solidity: "0.8.17",
+  networks: {
+    goerli: {
+        chainId: 5,
+        url: "https://goerli.infura.io/v3/19f952ce3ba04e09a4e844c2bc4a7dbf",
+        accounts: ["c1afce82cb3c8ace7e980bd74cfedd49f01c603413db0598ecacde802e9a8737"],
+    }
+  }
+};

oracle_1.sol

@@ -0,0 +1,32 @@
+pragma solidity ^0.8.7;
+
+
+contract OraclePrice {
+    uint32 public price;
+    mapping(address => uint32) private balances;
+    mapping(address => uint32) private lastFeed;
+
+    uint public lastUpdateBlockNumber;
+
+
+    function balanceOf(address account) public view returns (uint32) {
+        return balances[account];
+    }
+
+    function getPrice() public view returns (uint32) {
+        return price;
+    }
+
+    function feed(uint32 feedPrice) public {
+        lastFeed[msg.sender] = feedPrice;
+    }
+
+    function update() public returns (bool) {
+        if (lastUpdateBlockNumber !=0 && lastUpdateBlockNumber+1 == block.number) {
+            return false;
+        }
+        
+        
+    }
+
+}

package.json

@@ -0,0 +1,23 @@
+{
+  "devDependencies": {
+    "@ethersproject/abi": "^5.4.7",
+    "@ethersproject/providers": "^5.4.7",
+    "@nomicfoundation/hardhat-chai-matchers": "^1.0.0",
+    "@nomicfoundation/hardhat-network-helpers": "^1.0.0",
+    "@nomicfoundation/hardhat-toolbox": "^2.0.0",
+    "@nomiclabs/hardhat-ethers": "^2.0.0",
+    "@nomiclabs/hardhat-etherscan": "^3.0.0",
+    "@typechain/ethers-v5": "^10.1.0",
+    "@typechain/hardhat": "^6.1.2",
+    "chai": "^4.2.0",
+    "ethers": "^5.4.7",
+    "hardhat": "^2.12.4",
+    "hardhat-gas-reporter": "^1.0.8",
+    "solidity-coverage": "^0.8.0",
+    "typechain": "^8.1.0"
+  },
+  "dependencies": {
+    "@openzeppelin/contracts": "^4.8.1",
+    "@zondax/filecoin-solidity": "^0.5.0-beta.1"
+  }
+}

scripts/deploy.js

@@ -0,0 +1,31 @@
+// We require the Hardhat Runtime Environment explicitly here. This is optional
+// but useful for running the script in a standalone fashion through `node <script>`.
+//
+// You can also run a script with `npx hardhat run <script>`. If you do that, Hardhat
+// will compile your contracts, add the Hardhat Runtime Environment's members to the
+// global scope, and execute the script.
+const hre = require("hardhat");
+
+async function main() {
+  const currentTimestampInSeconds = Math.round(Date.now() / 1000);
+  const ONE_YEAR_IN_SECS = 365 * 24 * 60 * 60;
+  const unlockTime = currentTimestampInSeconds + ONE_YEAR_IN_SECS;
+
+  const lockedAmount = hre.ethers.utils.parseEther("1");
+
+  const Lock = await hre.ethers.getContractFactory("Lock");
+  const lock = await Lock.deploy(unlockTime, { value: lockedAmount });
+
+  await lock.deployed();
+
+  console.log(
+    `Lock with 1 ETH and unlock timestamp ${unlockTime} deployed to ${lock.address}`
+  );
+}
+
+// We recommend this pattern to be able to use async/await everywhere
+// and properly handle errors.
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

scripts/deploy_bulk_sneder.js

@@ -0,0 +1,31 @@
+// We require the Hardhat Runtime Environment explicitly here. This is optional
+// but useful for running the script in a standalone fashion through `node <script>`.
+//
+// You can also run a script with `npx hardhat run <script>`. If you do that, Hardhat
+// will compile your contracts, add the Hardhat Runtime Environment's members to the
+// global scope, and execute the script.
+const hre = require("hardhat");
+
+async function main() {
+  const currentTimestampInSeconds = Math.round(Date.now() / 1000);
+  const ONE_YEAR_IN_SECS = 365 * 24 * 60 * 60;
+  const unlockTime = currentTimestampInSeconds + ONE_YEAR_IN_SECS;
+
+  const lockedAmount = hre.ethers.utils.parseEther("1");
+
+  const Lock = await hre.ethers.getContractFactory("BulkSender");
+  const lock = await Lock.deploy();
+
+  await lock.deployed();
+
+  console.log(
+    `Lock with 1 ETH and unlock timestamp ${unlockTime} deployed to ${lock.address}`
+  );
+}
+
+// We recommend this pattern to be able to use async/await everywhere
+// and properly handle errors.
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

scripts/deploy_fallback_function.js

@@ -0,0 +1,31 @@
+// We require the Hardhat Runtime Environment explicitly here. This is optional
+// but useful for running the script in a standalone fashion through `node <script>`.
+//
+// You can also run a script with `npx hardhat run <script>`. If you do that, Hardhat
+// will compile your contracts, add the Hardhat Runtime Environment's members to the
+// global scope, and execute the script.
+const hre = require("hardhat");
+
+async function main() {
+  const currentTimestampInSeconds = Math.round(Date.now() / 1000);
+  const ONE_YEAR_IN_SECS = 365 * 24 * 60 * 60;
+  const unlockTime = currentTimestampInSeconds + ONE_YEAR_IN_SECS;
+
+  const lockedAmount = hre.ethers.utils.parseEther("1");
+
+  const Lock = await hre.ethers.getContractFactory("FallbackFunction");
+  const lock = await Lock.deploy();
+
+  await lock.deployed();
+
+  console.log(
+    `Lock with 1 ETH and unlock timestamp ${unlockTime} deployed to ${lock.address}`
+  );
+}
+
+// We recommend this pattern to be able to use async/await everywhere
+// and properly handle errors.
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

scripts/deploy_test_1.js

@@ -0,0 +1,31 @@
+// We require the Hardhat Runtime Environment explicitly here. This is optional
+// but useful for running the script in a standalone fashion through `node <script>`.
+//
+// You can also run a script with `npx hardhat run <script>`. If you do that, Hardhat
+// will compile your contracts, add the Hardhat Runtime Environment's members to the
+// global scope, and execute the script.
+const hre = require("hardhat");
+
+async function main() {
+  const currentTimestampInSeconds = Math.round(Date.now() / 1000);
+  const ONE_YEAR_IN_SECS = 365 * 24 * 60 * 60;
+  const unlockTime = currentTimestampInSeconds + ONE_YEAR_IN_SECS;
+
+  const lockedAmount = hre.ethers.utils.parseEther("1");
+
+  const Lock = await hre.ethers.getContractFactory("Person");
+  const lock = await Lock.deploy();
+
+  await lock.deployed();
+
+  console.log(
+    `Lock with 1 ETH and unlock timestamp ${unlockTime} deployed to ${lock.address}`
+  );
+}
+
+// We recommend this pattern to be able to use async/await everywhere
+// and properly handle errors.
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});