├── .gitignore
├── README.md
├── package.json
├── hardhat.config.js
├── scripts
    ├── manage-pause.js
    ├── manage-owner.js
    ├── deploy.js
    ├── withdraw.js
    └── buy-coffee.js
├── contracts
    └── BuyMeACoffee.sol
└── test
    └── Lock.js


/.gitignore:
--------------------------------------------------------------------------------
 1 | node_modules
 2 | .env
 3 | coverage
 4 | coverage.json
 5 | typechain
 6 | typechain-types
 7 | 
 8 | #Hardhat files
 9 | cache
10 | artifacts
11 | 
12 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Sample Hardhat Project
 2 | 
 3 | 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.
 4 | 
 5 | Try running some of the following tasks:
 6 | 
 7 | ```shell
 8 | npx hardhat help
 9 | npx hardhat test
10 | GAS_REPORT=true npx hardhat test
11 | npx hardhat node
12 | npx hardhat run scripts/deploy.js
13 | ```
14 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "buymeacoffee-contracts",
 3 |   "version": "1.0.0",
 4 |   "description": "",
 5 |   "main": "index.js",
 6 |   "scripts": {
 7 |     "test": "echo \"Error: no test specified\" && exit 1"
 8 |   },
 9 |   "keywords": [],
10 |   "author": "",
11 |   "license": "ISC",
12 |   "devDependencies": {
13 |     "@nomicfoundation/hardhat-chai-matchers": "^1.0.2",
14 |     "@nomicfoundation/hardhat-toolbox": "^1.0.2",
15 |     "@nomiclabs/hardhat-ethers": "^2.1.0",
16 |     "ethers": "^5.6.9",
17 |     "hardhat": "^2.10.1"
18 |   },
19 |   "dependencies": {
20 |     "@nomiclabs/hardhat-waffle": "^2.0.3",
21 |     "dotenv": "^16.0.1",
22 |     "ethereum-waffle": "^3.4.4"
23 |   }
24 | }
25 | 


--------------------------------------------------------------------------------
/hardhat.config.js:
--------------------------------------------------------------------------------
 1 | //require("@nomicfoundation/hardhat-toolbox");
 2 | require("@nomiclabs/hardhat-ethers");
 3 | require("@nomiclabs/hardhat-waffle");
 4 | //require("@nomicfoundation/hardhat-chai-matchers");
 5 | require("dotenv").config()
 6 | 
 7 | // You need to export an object to set up your config
 8 | // Go to https://hardhat.org/config/ to learn more
 9 | 
10 | const GOERLI_URL = process.env.GOERLI_URL;
11 | const PRIVATE_KEY = process.env.PRIVATE_KEY;
12 | 
13 | 
14 | 
15 | /**
16 |  * @type import('hardhat/config').HardhatUserConfig
17 |  */
18 | module.exports = {
19 |   solidity: "0.8.9",
20 |   networks: {
21 |     goerli: {
22 |       url: [GOERLI_URL] ,
23 |       accounts: [PRIVATE_KEY]
24 |     }
25 |   }
26 |   
27 | };
28 | 
29 | 
30 | 


--------------------------------------------------------------------------------
/scripts/manage-pause.js:
--------------------------------------------------------------------------------
 1 | const hre = require("hardhat");
 2 | 
 3 | async function getContract() {
 4 |   const BuyMeACoffee = await hre.ethers.getContractFactory("BuyMeACoffee");
 5 |   const buyMeACoffee = await BuyMeACoffee.attach(
 6 |     "YOUR_DEPLOYED_CONTRACT_ADDRESS" // TODO: Replace with your deployed contract address
 7 |   );
 8 |   return buyMeACoffee;
 9 | }
10 | 
11 | async function main() {
12 |   const buyMeACoffee = await getContract();
13 | 
14 |   console.log("Current paused status:", await buyMeACoffee.paused());
15 | 
16 |   // To pause the contract:
17 |   // const pauseTx = await buyMeACoffee.pause();
18 |   // await pauseTx.wait();
19 |   // console.log("Contract paused.");
20 | 
21 |   // To unpause the contract:
22 |   // const unpauseTx = await buyMeACoffee.unpause();
23 |   // await unpauseTx.wait();
24 |   // console.log("Contract unpaused.");
25 | 
26 |   console.log("New paused status:", await buyMeACoffee.paused());
27 | }
28 | 
29 | main()
30 |   .then(() => process.exit(0))
31 |   .catch((error) => {
32 |     console.error(error);
33 |     process.exit(1);
34 |   });
35 | 


--------------------------------------------------------------------------------
/scripts/manage-owner.js:
--------------------------------------------------------------------------------
 1 | const hre = require("hardhat");
 2 | 
 3 | async function getContract() {
 4 |   const BuyMeACoffee = await hre.ethers.getContractFactory("BuyMeACoffee");
 5 |   const buyMeACoffee = await BuyMeACoffee.attach(
 6 |     "YOUR_DEPLOYED_CONTRACT_ADDRESS" // TODO: Replace with your deployed contract address
 7 |   );
 8 |   return buyMeACoffee;
 9 | }
10 | 
11 | async function main() {
12 |   const buyMeACoffee = await getContract();
13 |   const [owner] = await hre.ethers.getSigners();
14 | 
15 |   console.log("Current owner:", await buyMeACoffee.owner());
16 | 
17 |   // To transfer ownership to a new address (replace NEW_OWNER_ADDRESS):
18 |   // const newOwnerAddress = "NEW_OWNER_ADDRESS";
19 |   // const transferTx = await buyMeACoffee.connect(owner).updateOwner(newOwnerAddress);
20 |   // await transferTx.wait();
21 |   // console.log(`Ownership transferred to ${newOwnerAddress}`);
22 | 
23 |   console.log("New owner (after potential transfer):", await buyMeACoffee.owner());
24 | }
25 | 
26 | main()
27 |   .then(() => process.exit(0))
28 |   .catch((error) => {
29 |     console.error(error);
30 |     process.exit(1);
31 |   });
32 | 


--------------------------------------------------------------------------------
/scripts/deploy.js:
--------------------------------------------------------------------------------
 1 | // We require the Hardhat Runtime Environment explicitly here. This is optional
 2 | // but useful for running the script in a standalone fashion through `node <script>`.
 3 | //
 4 | // When running the script with `npx hardhat run <script>` you'll find the Hardhat
 5 | // Runtime Environment's members available in the global scope.
 6 | const hre = require("hardhat");
 7 | 
 8 | async function main() {
 9 |   // Hardhat always runs the compile task when running scripts with its command
10 |   // line interface.
11 |   //
12 |   // If this script is run directly using `node` you may want to call compile
13 |   // manually to make sure everything is compiled
14 |   // await hre.run('compile');
15 | 
16 |   // We get the contract to deploy.
17 |   const BuyMeACoffee = await hre.ethers.getContractFactory("BuyMeACoffee");
18 |   const buyMeACoffee = await BuyMeACoffee.deploy();
19 | 
20 |   await buyMeACoffee.deployed();
21 | 
22 |   console.log("BuyMeACoffee deployed to:", buyMeACoffee.address);
23 | 
24 |   const pausedStatus = await buyMeACoffee.paused();
25 |   console.log("Contract initially paused status:", pausedStatus);
26 | }
27 | 
28 | // We recommend this pattern to be able to use async/await everywhere
29 | // and properly handle errors.
30 | main()
31 |   .then(() => process.exit(0))
32 |   .catch((error) => {
33 |     console.error(error);
34 |     process.exit(1);
35 |   });


--------------------------------------------------------------------------------
/scripts/withdraw.js:
--------------------------------------------------------------------------------
 1 | const hre = require("hardhat");
 2 | const abi = require("../artifacts/contracts/BuyMeACoffee.sol/BuyMeACoffee.json");
 3 | 
 4 | async function getBalance(provider, address) {
 5 |   const balanceBigInt = await provider.getBalance(address);
 6 |   return hre.ethers.utils.formatEther(balanceBigInt);
 7 | }
 8 | 
 9 | async function main() {
10 |   // Get the contract that has been deployed to Goerli.
11 |   const contractAddress="0xDBa03676a2fBb6711CB652beF5B7416A53c1421D";
12 |   const contractABI = abi.abi;
13 | 
14 |   // Get the node connection and wallet connection.
15 |   const provider = new hre.ethers.providers.AlchemyProvider("goerli", process.env.GOERLI_API_KEY);
16 | 
17 |   // Ensure that signer is the SAME address as the original contract deployer,
18 |   // or else this script will fail with an error.
19 |   const signer = new hre.ethers.Wallet(process.env.PRIVATE_KEY, provider);
20 | 
21 |   // Instantiate connected contract.
22 |   const buyMeACoffee = new hre.ethers.Contract(contractAddress, contractABI, signer);
23 | 
24 |   const pausedStatus = await buyMeACoffee.paused();
25 |   console.log("Contract paused status:", pausedStatus);
26 | 
27 |   // Check starting balances.
28 |   console.log("current balance of owner: ", await getBalance(provider, signer.address), "ETH");
29 |   const contractBalance = await getBalance(provider, buyMeACoffee.address);
30 |   console.log("current balance of contract: ", await getBalance(provider, buyMeACoffee.address), "ETH");
31 | 
32 |   // Withdraw funds if there are funds to withdraw.
33 |   if (contractBalance !== "0.0") {
34 |     console.log("withdrawing funds..")
35 |     const withdrawTxn = await buyMeACoffee.withdrawTips();
36 |     await withdrawTxn.wait();
37 |   } else {
38 |     console.log("no funds to withdraw!");
39 |   }
40 | 
41 |   // Check ending balance.
42 |   console.log("current balance of owner: ", await getBalance(provider, signer.address), "ETH");
43 | }
44 | 
45 | // We recommend this pattern to be able to use async/await everywhere
46 | // and properly handle errors.
47 | main()
48 |   .then(() => process.exit(0))
49 |   .catch((error) => {
50 |     console.error(error);
51 |     process.exit(1);
52 |   });


--------------------------------------------------------------------------------
/scripts/buy-coffee.js:
--------------------------------------------------------------------------------
 1 | 
 2 | const hre = require("hardhat");
 3 | 
 4 | // Returns the Ether balance of a given address.
 5 | async function getBalance(address) {
 6 |   const balanceBigInt = await hre.waffle.provider.getBalance(address);
 7 |   return hre.ethers.utils.formatEther(balanceBigInt);
 8 | }
 9 | 
10 | // Logs the Ether balances for a list of addresses.
11 | async function printBalances(addresses) {
12 |   let idx = 0;
13 |   for (const address of addresses) {
14 |     console.log(`Address ${idx} balance: `, await getBalance(address));
15 |     idx ++;
16 |   }
17 | }
18 | 
19 | // Logs the memos stored on-chain from coffee purchases.
20 | async function printMemos(memos) {
21 |   for (const memo of memos) {
22 |     const timestamp = memo.timestamp;
23 |     const tipper = memo.name;
24 |     const tipperAddress = memo.from;
25 |     const message = memo.message;
26 |     console.log(`At ${timestamp}, ${tipper} (${tipperAddress}) said: "${message}"`);
27 |   }
28 | }
29 | 
30 | async function main() {
31 |   // Get the example accounts we'll be working with.
32 |   const [owner, tipper, tipper2, tipper3] = await hre.ethers.getSigners();
33 | 
34 |   // We get the contract to deploy.
35 |   const BuyMeACoffee = await hre.ethers.getContractFactory("BuyMeACoffee");
36 |   const buyMeACoffee = await BuyMeACoffee.deploy();
37 | 
38 |   // Deploy the contract.
39 |   await buyMeACoffee.deployed();
40 |   console.log("BuyMeACoffee deployed to:", buyMeACoffee.address);
41 | 
42 |   const pausedStatus = await buyMeACoffee.paused();
43 |   console.log("Contract paused status:", pausedStatus);
44 | 
45 |   // Check balances before the coffee purchase.
46 |   const addresses = [owner.address, tipper.address, buyMeACoffee.address];
47 |   console.log("== start ==");
48 |   await printBalances(addresses);
49 | 
50 |   // Buy the owner a few coffees.
51 |   const tip = {value: hre.ethers.utils.parseEther("1")};
52 |   await buyMeACoffee.connect(tipper).buyCoffee("Carolina", "You're the best!", tip);
53 |   await buyMeACoffee.connect(tipper2).buyCoffee("Vitto", "Amazing teacher", tip);
54 |   await buyMeACoffee.connect(tipper3).buyCoffee("Kay", "I love my Proof of Knowledge", tip);
55 | 
56 |   // Check balances after the coffee purchase.
57 |   console.log("== bought coffee ==");
58 |   await printBalances(addresses);
59 | 
60 |   // Withdraw.
61 |   await buyMeACoffee.connect(owner).withdrawTips();
62 | 
63 |   // Check balances after withdrawal.
64 |   console.log("== withdrawTips ==");
65 |   await printBalances(addresses);
66 | 
67 |   // Check out the memos.
68 |   console.log("== memos ==");
69 |   const memos = await buyMeACoffee.getMemos();
70 |   printMemos(memos);
71 | }
72 | 
73 | // We recommend this pattern to be able to use async/await everywhere
74 | // and properly handle errors.
75 | main()
76 |   .then(() => process.exit(0))
77 |   .catch((error) => {
78 |     console.error(error);
79 |     process.exit(1);
80 |   });


--------------------------------------------------------------------------------
/contracts/BuyMeACoffee.sol:
--------------------------------------------------------------------------------
  1 | // SPDX-License-Identifier: UNLICENSED
  2 | pragma solidity ^0.8.9;
  3 | 
  4 | contract BuyMeACoffee {
  5 |     //Event to emit when a memo is created
  6 | 
  7 |     event NewMemo(
  8 | 
  9 |         address indexed from,
 10 |         uint256 timestamp,
 11 |         string name,
 12 |         string message
 13 | 
 14 | 
 15 |     );
 16 | 
 17 |     event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
 18 | 
 19 | 
 20 |     //Memo Struct
 21 |     struct Memo{
 22 |         address from;
 23 |         uint256 timestamp;
 24 |         string name;
 25 |         string message;
 26 | 
 27 |     }
 28 | 
 29 |     //List of all memos recieved from friends
 30 |     Memo[] memos;
 31 | 
 32 |     //Address of the contract deployer
 33 |     address payable owner;
 34 | 
 35 |     bool private paused;
 36 | 
 37 | 
 38 |     //Deploy logic
 39 | 
 40 |     constructor() {
 41 |         owner = payable(msg.sender);
 42 |         paused = false;
 43 |     }
 44 | 
 45 |     modifier onlyOwner() {
 46 |         require(msg.sender == owner, "Only owner can call this function");
 47 |         _;
 48 |     }
 49 | 
 50 |     modifier whenNotPaused() {
 51 |         require(!paused, "Contract is paused");
 52 |         _;
 53 |     }
 54 | 
 55 |     modifier whenPaused() {
 56 |         require(paused, "Contract is not paused");
 57 |         _;
 58 |     }
 59 | 
 60 |     /*
 61 |     *   @dev Pause the contract. Only owner can call this.
 62 |     */
 63 |     function pause() public onlyOwner whenNotPaused {
 64 |         paused = true;
 65 |     }
 66 | 
 67 |     /*
 68 |     *   @dev Unpause the contract. Only owner can call this.
 69 |     */
 70 |     function unpause() public onlyOwner whenPaused {
 71 |         paused = false;
 72 |     }
 73 | 
 74 |     /*
 75 |     *   @dev Update the owner of the contract.
 76 |     *   @param _newOwner The address of the new owner.
 77 |     */
 78 |     function updateOwner(address payable _newOwner) public onlyOwner {
 79 |         require(_newOwner != address(0), "New owner cannot be the zero address");
 80 |         address oldOwner = owner;
 81 |         owner = _newOwner;
 82 |         emit OwnershipTransferred(oldOwner, _newOwner);
 83 |     }
 84 | 
 85 |     /*
 86 |     *   @dev buy a cofee for contract owner
 87 |     *   @param _name name of the coffee buyer
 88 |     *   @param _message a nice message from the coffee buyer
 89 |     *
 90 |     */
 91 |     function buyCoffee(string memory _name,string memory _message) public payable whenNotPaused{
 92 | 
 93 |         require(msg.value >0 , "Can't buy coffee with 0 eth");
 94 | 
 95 |         //Add the memo to the storage
 96 |         memos.push(Memo(
 97 |             msg.sender,
 98 |             block.timestamp,
 99 |             _name,
100 |             _message
101 |         ));
102 | 
103 |         //Emit a log event when a new memo is created
104 |        emit NewMemo(
105 |             msg.sender,
106 |             block.timestamp,
107 |             _name,
108 |             _message
109 |         );
110 |         
111 |     }
112 | 
113 | 
114 | 
115 |     /*
116 |     *   @dev send the entire balance stored in this contract to the owner
117 |     *   
118 |     */
119 |     function withdrawTips() public onlyOwner whenNotPaused {
120 |         require(owner.send(address(this).balance));
121 |     }
122 | 
123 | 
124 | 
125 |     /*
126 |     *   @dev retrieve all the memos recieved and stored on the blockchain
127 |     *   
128 |     */
129 |     function getMemos() public view returns(Memo[] memory){
130 |         return memos;
131 |     }
132 | }


--------------------------------------------------------------------------------
/test/Lock.js:
--------------------------------------------------------------------------------
  1 | const {
  2 |   time,
  3 |   loadFixture,
  4 | } = require("@nomicfoundation/hardhat-network-helpers");
  5 | const { anyValue } = require("@nomicfoundation/hardhat-chai-matchers/withArgs");
  6 | const { expect } = require("chai");
  7 | 
  8 | describe("Lock", function () {
  9 |   // We define a fixture to reuse the same setup in every test.
 10 |   // We use loadFixture to run this setup once, snapshot that state,
 11 |   // and reset Hardhat Network to that snapshopt in every test.
 12 |   async function deployOneYearLockFixture() {
 13 |     const ONE_YEAR_IN_SECS = 365 * 24 * 60 * 60;
 14 |     const ONE_GWEI = 1_000_000_000;
 15 | 
 16 |     const lockedAmount = ONE_GWEI;
 17 |     const unlockTime = (await time.latest()) + ONE_YEAR_IN_SECS;
 18 | 
 19 |     // Contracts are deployed using the first signer/account by default
 20 |     const [owner, otherAccount] = await ethers.getSigners();
 21 | 
 22 |     const Lock = await ethers.getContractFactory("Lock");
 23 |     const lock = await Lock.deploy(unlockTime, { value: lockedAmount });
 24 | 
 25 |     return { lock, unlockTime, lockedAmount, owner, otherAccount };
 26 |   }
 27 | 
 28 |   describe("Deployment", function () {
 29 |     it("Should set the right unlockTime", async function () {
 30 |       const { lock, unlockTime } = await loadFixture(deployOneYearLockFixture);
 31 | 
 32 |       expect(await lock.unlockTime()).to.equal(unlockTime);
 33 |     });
 34 | 
 35 |     it("Should set the right owner", async function () {
 36 |       const { lock, owner } = await loadFixture(deployOneYearLockFixture);
 37 | 
 38 |       expect(await lock.owner()).to.equal(owner.address);
 39 |     });
 40 | 
 41 |     it("Should receive and store the funds to lock", async function () {
 42 |       const { lock, lockedAmount } = await loadFixture(
 43 |         deployOneYearLockFixture
 44 |       );
 45 | 
 46 |       expect(await ethers.provider.getBalance(lock.address)).to.equal(
 47 |         lockedAmount
 48 |       );
 49 |     });
 50 | 
 51 |     it("Should fail if the unlockTime is not in the future", async function () {
 52 |       // We don't use the fixture here because we want a different deployment
 53 |       const latestTime = await time.latest();
 54 |       const Lock = await ethers.getContractFactory("Lock");
 55 |       await expect(Lock.deploy(latestTime, { value: 1 })).to.be.revertedWith(
 56 |         "Unlock time should be in the future"
 57 |       );
 58 |     });
 59 |   });
 60 | 
 61 |   describe("Withdrawals", function () {
 62 |     describe("Validations", function () {
 63 |       it("Should revert with the right error if called too soon", async function () {
 64 |         const { lock } = await loadFixture(deployOneYearLockFixture);
 65 | 
 66 |         await expect(lock.withdraw()).to.be.revertedWith(
 67 |           "You can't withdraw yet"
 68 |         );
 69 |       });
 70 | 
 71 |       it("Should revert with the right error if called from another account", async function () {
 72 |         const { lock, unlockTime, otherAccount } = await loadFixture(
 73 |           deployOneYearLockFixture
 74 |         );
 75 | 
 76 |         // We can increase the time in Hardhat Network
 77 |         await time.increaseTo(unlockTime);
 78 | 
 79 |         // We use lock.connect() to send a transaction from another account
 80 |         await expect(lock.connect(otherAccount).withdraw()).to.be.revertedWith(
 81 |           "You aren't the owner"
 82 |         );
 83 |       });
 84 | 
 85 |       it("Shouldn't fail if the unlockTime has arrived and the owner calls it", async function () {
 86 |         const { lock, unlockTime } = await loadFixture(
 87 |           deployOneYearLockFixture
 88 |         );
 89 | 
 90 |         // Transactions are sent using the first signer by default
 91 |         await time.increaseTo(unlockTime);
 92 | 
 93 |         await expect(lock.withdraw()).not.to.be.reverted;
 94 |       });
 95 |     });
 96 | 
 97 |     describe("Events", function () {
 98 |       it("Should emit an event on withdrawals", async function () {
 99 |         const { lock, unlockTime, lockedAmount } = await loadFixture(
100 |           deployOneYearLockFixture
101 |         );
102 | 
103 |         await time.increaseTo(unlockTime);
104 | 
105 |         await expect(lock.withdraw())
106 |           .to.emit(lock, "Withdrawal")
107 |           .withArgs(lockedAmount, anyValue); // We accept any value as `when` arg
108 |       });
109 |     });
110 | 
111 |     describe("Transfers", function () {
112 |       it("Should transfer the funds to the owner", async function () {
113 |         const { lock, unlockTime, lockedAmount, owner } = await loadFixture(
114 |           deployOneYearLockFixture
115 |         );
116 | 
117 |         await time.increaseTo(unlockTime);
118 | 
119 |         await expect(lock.withdraw()).to.changeEtherBalances(
120 |           [owner, lock],
121 |           [lockedAmount, -lockedAmount]
122 |         );
123 |       });
124 |     });
125 |   });
126 | });
127 | 


--------------------------------------------------------------------------------