├── .prettierrc
├── .solhintignore
├── .npmignore
├── .eslintignore
├── .prettierignore
├── .gitignore
├── .solhint.json
├── tsconfig.json
├── .eslintrc.js
├── package.json
├── scripts
    └── deploy.ts
├── hardhat.config.ts
├── README.md
├── test
    └── index.ts
└── contracts
    ├── CommsaurPFP.sol
    └── Commsaur.sol


/.prettierrc:
--------------------------------------------------------------------------------
1 | {}
2 | 


--------------------------------------------------------------------------------
/.solhintignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | 


--------------------------------------------------------------------------------
/.npmignore:
--------------------------------------------------------------------------------
1 | hardhat.config.ts
2 | scripts
3 | test
4 | 


--------------------------------------------------------------------------------
/.eslintignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | artifacts
3 | cache
4 | coverage
5 | 


--------------------------------------------------------------------------------
/.prettierignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | artifacts
3 | cache
4 | coverage*
5 | gasReporterOutput.json
6 | 


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


--------------------------------------------------------------------------------
/.solhint.json:
--------------------------------------------------------------------------------
1 | {
2 |   "extends": "solhint:recommended",
3 |   "rules": {
4 |     "compiler-version": ["error", "^0.8.0"],
5 |     "func-visibility": ["warn", { "ignoreConstructors": true }]
6 |   }
7 | }
8 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "compilerOptions": {
 3 |     "target": "es2018",
 4 |     "module": "commonjs",
 5 |     "strict": true,
 6 |     "esModuleInterop": true,
 7 |     "outDir": "dist",
 8 |     "declaration": true
 9 |   },
10 |   "include": ["./scripts", "./test", "./typechain"],
11 |   "files": ["./hardhat.config.ts"]
12 | }
13 | 


--------------------------------------------------------------------------------
/.eslintrc.js:
--------------------------------------------------------------------------------
 1 | module.exports = {
 2 |   env: {
 3 |     browser: false,
 4 |     es2021: true,
 5 |     mocha: true,
 6 |     node: true,
 7 |   },
 8 |   plugins: ["@typescript-eslint"],
 9 |   extends: [
10 |     "standard",
11 |     "plugin:prettier/recommended",
12 |     "plugin:node/recommended",
13 |   ],
14 |   parser: "@typescript-eslint/parser",
15 |   parserOptions: {
16 |     ecmaVersion: 12,
17 |   },
18 |   rules: {
19 |     "node/no-unsupported-features/es-syntax": [
20 |       "error",
21 |       { ignores: ["modules"] },
22 |     ],
23 |   },
24 | };
25 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "hardhat-project",
 3 |   "devDependencies": {
 4 |     "@nomiclabs/hardhat-ethers": "^2.0.5",
 5 |     "@nomiclabs/hardhat-etherscan": "^3.0.3",
 6 |     "@nomiclabs/hardhat-waffle": "^2.0.3",
 7 |     "@typechain/ethers-v5": "^7.2.0",
 8 |     "@typechain/hardhat": "^2.3.1",
 9 |     "@types/chai": "^4.3.1",
10 |     "@types/mocha": "^9.1.1",
11 |     "@types/node": "^12.20.50",
12 |     "@typescript-eslint/eslint-plugin": "^4.33.0",
13 |     "@typescript-eslint/parser": "^4.33.0",
14 |     "chai": "^4.3.6",
15 |     "dotenv": "^10.0.0",
16 |     "eslint": "^7.32.0",
17 |     "eslint-config-prettier": "^8.5.0",
18 |     "eslint-config-standard": "^16.0.3",
19 |     "eslint-plugin-import": "^2.26.0",
20 |     "eslint-plugin-node": "^11.1.0",
21 |     "eslint-plugin-prettier": "^3.4.1",
22 |     "eslint-plugin-promise": "^5.2.0",
23 |     "ethereum-waffle": "^3.4.4",
24 |     "ethers": "^5.6.5",
25 |     "hardhat": "^2.9.3",
26 |     "hardhat-gas-reporter": "^1.0.8",
27 |     "prettier": "^2.6.2",
28 |     "prettier-plugin-solidity": "^1.0.0-beta.13",
29 |     "solhint": "^3.3.7",
30 |     "solidity-coverage": "^0.7.21",
31 |     "ts-node": "^10.7.0",
32 |     "typechain": "^5.2.0",
33 |     "typescript": "^4.6.4"
34 |   },
35 |   "dependencies": {
36 |     "@openzeppelin/contracts": "^4.6.0",
37 |     "erc721a": "^2.2.0"
38 |   }
39 | }
40 | 


--------------------------------------------------------------------------------
/scripts/deploy.ts:
--------------------------------------------------------------------------------
 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 | import { ethers } from "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 |   const Commsaur = await ethers.getContractFactory("Commsaur");
17 |   const saur = await Commsaur.deploy();
18 | 
19 |   // We get the contract to deploy
20 |   const CommsaurPFP = await ethers.getContractFactory("CommsaurPFP");
21 |   // const live = "0xBAcB34Bcf94442dbA033e9cf7216888B8170F0cE";
22 | 
23 |   const pfp = await CommsaurPFP.deploy(saur.address);
24 | 
25 |   console.log("Commsaur deployed to:", saur.address);
26 |   console.log("CommsaurPFP deployed to:", pfp.address);
27 | }
28 | 
29 | // We recommend this pattern to be able to use async/await everywhere
30 | // and properly handle errors.
31 | main().catch((error) => {
32 |   console.error(error);
33 |   process.exitCode = 1;
34 | });
35 | 


--------------------------------------------------------------------------------
/hardhat.config.ts:
--------------------------------------------------------------------------------
 1 | import * as dotenv from "dotenv";
 2 | 
 3 | import { HardhatUserConfig, task } from "hardhat/config";
 4 | import "@nomiclabs/hardhat-etherscan";
 5 | import "@nomiclabs/hardhat-waffle";
 6 | import "@typechain/hardhat";
 7 | import "hardhat-gas-reporter";
 8 | import "solidity-coverage";
 9 | 
10 | dotenv.config();
11 | 
12 | // This is a sample Hardhat task. To learn how to create your own go to
13 | // https://hardhat.org/guides/create-task.html
14 | task("accounts", "Prints the list of accounts", async (taskArgs, hre) => {
15 |   const accounts = await hre.ethers.getSigners();
16 | 
17 |   for (const account of accounts) {
18 |     console.log(account.address);
19 |   }
20 | });
21 | 
22 | // You need to export an object to set up your config
23 | // Go to https://hardhat.org/config/ to learn more
24 | 
25 | const config: HardhatUserConfig = {
26 |   solidity: "0.8.4",
27 |   networks: {
28 |     rinkeby: {
29 |       url: "https://eth-rinkeby.alchemyapi.io/v2/9R_yWpWjLB7vKcGfCR_I2HU-X5Fuahol",
30 |       accounts: [
31 |         "a0ab8ba404b983bcaec6ad5694754c7ba760e6ee071e56a9b547161b60691111",
32 |       ],
33 |     },
34 |     mainnet: {
35 |       url: "https://eth-mainnet.alchemyapi.io/v2/nzLJjKrtgPGbidugKn5S6G8o9RFnsxnv",
36 |       accounts:
37 |         process.env.PRIVATE_KEY !== undefined ? [process.env.PRIVATE_KEY] : [],
38 |     },
39 |   },
40 |   gasReporter: {
41 |     enabled: process.env.REPORT_GAS !== undefined,
42 |     currency: "USD",
43 |   },
44 |   etherscan: {
45 |     apiKey: process.env.ETHERSCAN_API_KEY,
46 |   },
47 | };
48 | 
49 | export default config;
50 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Advanced Sample Hardhat Project
 2 | 
 3 | This project demonstrates an advanced Hardhat use case, integrating other tools commonly used alongside Hardhat in the ecosystem.
 4 | 
 5 | The project comes with a sample contract, a test for that contract, a sample script that deploys that contract, and an example of a task implementation, which simply lists the available accounts. It also comes with a variety of other tools, preconfigured to work with the project code.
 6 | 
 7 | Try running some of the following tasks:
 8 | 
 9 | ```shell
10 | npx hardhat accounts
11 | npx hardhat compile
12 | npx hardhat clean
13 | npx hardhat test
14 | npx hardhat node
15 | npx hardhat help
16 | REPORT_GAS=true npx hardhat test
17 | npx hardhat coverage
18 | npx hardhat run scripts/deploy.ts
19 | TS_NODE_FILES=true npx ts-node scripts/deploy.ts
20 | npx eslint '**/*.{js,ts}'
21 | npx eslint '**/*.{js,ts}' --fix
22 | npx prettier '**/*.{json,sol,md}' --check
23 | npx prettier '**/*.{json,sol,md}' --write
24 | npx solhint 'contracts/**/*.sol'
25 | npx solhint 'contracts/**/*.sol' --fix
26 | ```
27 | 
28 | # Etherscan verification
29 | 
30 | To try out Etherscan verification, you first need to deploy a contract to an Ethereum network that's supported by Etherscan, such as Ropsten.
31 | 
32 | In this project, copy the .env.example file to a file named .env, and then edit it to fill in the details. Enter your Etherscan API key, your Ropsten node URL (eg from Alchemy), and the private key of the account which will send the deployment transaction. With a valid .env file in place, first deploy your contract:
33 | 
34 | ```shell
35 | hardhat run --network ropsten scripts/deploy.ts
36 | ```
37 | 
38 | Then, copy the deployment address and paste it in to replace `DEPLOYED_CONTRACT_ADDRESS` in this command:
39 | 
40 | ```shell
41 | npx hardhat verify --network ropsten DEPLOYED_CONTRACT_ADDRESS "Hello, Hardhat!"
42 | ```
43 | 
44 | # Performance optimizations
45 | 
46 | For faster runs of your tests and scripts, consider skipping ts-node's type checking by setting the environment variable `TS_NODE_TRANSPILE_ONLY` to `1` in hardhat's environment. For more details see [the documentation](https://hardhat.org/guides/typescript.html#performance-optimizations).
47 | 


--------------------------------------------------------------------------------
/test/index.ts:
--------------------------------------------------------------------------------
 1 | import { expect } from "chai";
 2 | import { ethers } from "hardhat";
 3 | // eslint-disable-next-line node/no-missing-import
 4 | import { Commsaur, CommsaurPFP } from "../typechain";
 5 | 
 6 | describe("Commsaur Contracts", function () {
 7 |   let commsaur: Commsaur;
 8 |   let pfp: CommsaurPFP;
 9 | 
10 |   before(async function () {
11 |     const Commsaur = await ethers.getContractFactory("Commsaur");
12 |     commsaur = await Commsaur.deploy();
13 | 
14 |     const CommsaurPFP = await ethers.getContractFactory("CommsaurPFP");
15 |     pfp = await CommsaurPFP.deploy(commsaur.address);
16 | 
17 |     console.log(
18 |       "Deployed Commsaur at ",
19 |       commsaur.address,
20 |       "and CommsaurPFP at",
21 |       pfp.address
22 |     );
23 |   });
24 | 
25 |   describe("Commsaur", function () {
26 |     it("should enable minting", async function () {
27 |       await expect(commsaur.setMintStatus(3)).to.not.be.reverted;
28 |     });
29 | 
30 |     it("should mint 5", async function () {
31 |       const [, addr1] = await ethers.getSigners();
32 | 
33 |       await expect(
34 |         commsaur
35 |           .connect(addr1)
36 |           .mintCommsaurs(5, { value: "165000000000000000" })
37 |       ).to.emit(commsaur, "Transfer");
38 |     });
39 | 
40 |     it("should approve spending", async function () {
41 |       const [, addr1] = await ethers.getSigners();
42 | 
43 |       const tx = await commsaur
44 |         .connect(addr1)
45 |         .setApprovalForAll(pfp.address, true);
46 |       await tx.wait();
47 | 
48 |       const approved = await commsaur.isApprovedForAll(
49 |         addr1.address,
50 |         pfp.address
51 |       );
52 |       expect(approved).to.be.eq(true);
53 |     });
54 |   });
55 | 
56 |   describe("Commsaur PFP", function () {
57 |     it("should try to wrap an nft and fail", async function () {
58 |       const [, addr1] = await ethers.getSigners();
59 |       await expect(
60 |         commsaur
61 |           .connect(addr1)
62 |           ["safeTransferFrom(address,address,uint256)"](
63 |             addr1.address,
64 |             pfp.address,
65 |             "1"
66 |           )
67 |       ).to.be.reverted;
68 |     });
69 | 
70 |     it("should enable wrapping", async function () {
71 |       await expect(pfp.setWrappingEnabled(true)).to.not.be.reverted;
72 |     });
73 | 
74 |     it("should try to wrap an nft and succeed", async function () {
75 |       const [, addr1] = await ethers.getSigners();
76 |       await expect(
77 |         commsaur.connect(addr1).transferFrom(addr1.address, pfp.address, 1)
78 |       ).to.not.be.reverted;
79 |     });
80 | 
81 |     it("should try to wrap multiple nfts and succeed", async function () {
82 |       const [, addr1] = await ethers.getSigners();
83 |       await expect(pfp.connect(addr1).wrapHerd(["0", "2", "3"])).to.not.be
84 |         .reverted;
85 |     });
86 |   });
87 | });
88 | 


--------------------------------------------------------------------------------
/contracts/CommsaurPFP.sol:
--------------------------------------------------------------------------------
  1 | // SPDX-License-Identifier: MIT
  2 | pragma solidity ^0.8.4;
  3 | 
  4 | import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
  5 | import "@openzeppelin/contracts/interfaces/IERC721.sol";
  6 | import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
  7 | import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
  8 | import "@openzeppelin/contracts/access/Ownable.sol";
  9 | 
 10 | //   .--.      .--.    ___ .-. .-.    ___ .-. .-.       .--.      .---.   ___  ___   ___ .-.
 11 | //  /    \    /    \  (   )   '   \  (   )   '   \    /  _  \    / .-, \ (   )(   ) (   )   \
 12 | // |  .-. ;  |  .-. ;  |  .-.  .-. ;  |  .-.  .-. ;  . .' `. ;  (__) ; |  | |  | |   | ' .-. ;
 13 | // |  |(___) | |  | |  | |  | |  | |  | |  | |  | |  | '   | |    .'`  |  | |  | |   |  / (___)
 14 | // |  |      | |  | |  | |  | |  | |  | |  | |  | |  _\_`.(___)  / .'| |  | |  | |   | |
 15 | // |  | ___  | |  | |  | |  | |  | |  | |  | |  | | (   ). '.   | /  | |  | |  | |   | |
 16 | // |  '(   ) | '  | |  | |  | |  | |  | |  | |  | |  | |  `\ |  ; |  ; |  | |  ; '   | |
 17 | // '  `-' |  '  `-' /  | |  | |  | |  | |  | |  | |  ; '._,' '  ' `-'  |  ' `-'  /   | |
 18 | //  `.__,'    `.__.'  (___)(___)(___)(___)(___)(___)  '.___.'   `.__.'_.   '.__.'   (___)
 19 | // @author erosemberg
 20 | 
 21 | contract CommsaurPFP is
 22 |     ERC721Enumerable,
 23 |     IERC721Receiver,
 24 |     ReentrancyGuard,
 25 |     Ownable
 26 | {
 27 |     IERC721 public immutable commsaurContract;
 28 | 
 29 |     string private baseURI;
 30 | 
 31 |     struct WrappingState {
 32 |         bool wrappingEnabled;
 33 |         bool unwrappingEnabled;
 34 |     }
 35 | 
 36 |     WrappingState public wrappingState;
 37 | 
 38 |     constructor(address _commsaurAddress) ERC721("Commsaur PFP", "PFPCOMMSAUR") {
 39 |         commsaurContract = IERC721(_commsaurAddress);
 40 |         wrappingState = WrappingState({
 41 |             wrappingEnabled: false,
 42 |             unwrappingEnabled: false
 43 |         });
 44 |     }
 45 | 
 46 |     function setWrappingEnabled(bool _enabled) external onlyOwner {
 47 |         wrappingState.wrappingEnabled = _enabled;
 48 |     }
 49 | 
 50 |     function setUnwrappingEnabled(bool _enabled) external onlyOwner {
 51 |         wrappingState.unwrappingEnabled = _enabled;
 52 |     }
 53 | 
 54 |     function onERC721Received(
 55 |         address,
 56 |         address from,
 57 |         uint256 tokenId,
 58 |         bytes memory
 59 |     ) public virtual override nonReentrant returns (bytes4) {
 60 |         if (msg.sender == address(commsaurContract)) {
 61 |             // solhint-disable-next-line reason-string
 62 |             require(
 63 |                 wrappingState.wrappingEnabled,
 64 |                 "Commsaur: Wrapping is not currently enabled!"
 65 |             );
 66 |             if (!_exists(tokenId)) {
 67 |                 _safeMint(from, tokenId);
 68 |             } else {
 69 |                 // @note this will require token approval
 70 |                 _safeTransfer(address(this), from, tokenId, "");
 71 |             }
 72 |         } else if (msg.sender == address(this)) {
 73 |             // solhint-disable-next-line reason-string
 74 |             require(
 75 |                 wrappingState.unwrappingEnabled,
 76 |                 "Commsaur: Unwrapping is not currently enabled!"
 77 |             );
 78 |             commsaurContract.safeTransferFrom(address(this), from, tokenId);
 79 |         } else {
 80 |             // solhint-disable-next-line reason-string
 81 |             revert("Commsaur: Only Commsaurs are allowed into this dinoverse!");
 82 |         }
 83 | 
 84 |         return this.onERC721Received.selector;
 85 |     }
 86 | 
 87 |     function wrapHerd(uint256[] calldata tokenIds) external {
 88 |         for (uint256 i = 0; i < tokenIds.length; i++) {
 89 |             commsaurContract.safeTransferFrom(
 90 |                 msg.sender,
 91 |                 address(this),
 92 |                 tokenIds[i]
 93 |             );
 94 |         }
 95 |     }
 96 | 
 97 |     function unwrapHerd(uint256[] calldata tokenIds) external {
 98 |         for (uint256 i = 0; i < tokenIds.length; i++) {
 99 |             safeTransferFrom(msg.sender, address(this), tokenIds[i]);
100 |         }
101 |     }
102 | 
103 |     function rescue(address to, uint256 tokenId) external onlyOwner {
104 |         if (!_exists(tokenId) || ownerOf(tokenId) == address(this)) {
105 |             commsaurContract.safeTransferFrom(address(this), to, tokenId);
106 |         } else if (ownerOf(tokenId) == address(commsaurContract)) {
107 |             _safeTransfer(address(commsaurContract), to, tokenId, "");
108 |         } else {
109 |             // solhint-disable-next-line reason-string
110 |             revert("Commsaur: That Commsaur seems to be in the right place?");
111 |         }
112 |     }
113 | 
114 |     function _baseURI() internal view override returns (string memory) {
115 |         return baseURI;
116 |     }
117 | 
118 |     function setBaseURI(string memory uri) external onlyOwner {
119 |         baseURI = uri;
120 |     }
121 | }
122 | 


--------------------------------------------------------------------------------
/contracts/Commsaur.sol:
--------------------------------------------------------------------------------
  1 | // SPDX-License-Identifier: MIT
  2 | pragma solidity ^0.8.4;
  3 | 
  4 | import "erc721a/contracts/ERC721A.sol";
  5 | import "@openzeppelin/contracts/access/Ownable.sol";
  6 | 
  7 | //   .--.      .--.    ___ .-. .-.    ___ .-. .-.       .--.      .---.   ___  ___   ___ .-.
  8 | //  /    \    /    \  (   )   '   \  (   )   '   \    /  _  \    / .-, \ (   )(   ) (   )   \
  9 | // |  .-. ;  |  .-. ;  |  .-.  .-. ;  |  .-.  .-. ;  . .' `. ;  (__) ; |  | |  | |   | ' .-. ;
 10 | // |  |(___) | |  | |  | |  | |  | |  | |  | |  | |  | '   | |    .'`  |  | |  | |   |  / (___)
 11 | // |  |      | |  | |  | |  | |  | |  | |  | |  | |  _\_`.(___)  / .'| |  | |  | |   | |
 12 | // |  | ___  | |  | |  | |  | |  | |  | |  | |  | | (   ). '.   | /  | |  | |  | |   | |
 13 | // |  '(   ) | '  | |  | |  | |  | |  | |  | |  | |  | |  `\ |  ; |  ; |  | |  ; '   | |
 14 | // '  `-' |  '  `-' /  | |  | |  | |  | |  | |  | |  ; '._,' '  ' `-'  |  ' `-'  /   | |
 15 | //  `.__,'    `.__.'  (___)(___)(___)(___)(___)(___)  '.___.'   `.__.'_.   '.__.'   (___)
 16 | contract Commsaur is ERC721A, Ownable {
 17 |     uint256 public MINT_PRICE = 0.033 ether;
 18 |     uint16 public constant MAX_SUPPLY = 3333;
 19 | 
 20 |     address public withdrawalAddress =
 21 |         0x224f096cDFdb2Cd3f4796dE5F6019412B92E32dE; // gnosis safe
 22 | 
 23 |     string private baseURI;
 24 | 
 25 |     enum MintStatus {
 26 |         CLOSED,
 27 |         RESERVED,
 28 |         ALLOW_LIST,
 29 |         PUBLIC
 30 |     }
 31 |     bool public mintReserved = false;
 32 |     MintStatus public mintStatus;
 33 |     mapping(address => bool) allowList;
 34 | 
 35 |     constructor() ERC721A("Commsaur", "COMMSAUR") {}
 36 | 
 37 |     // @notice Will mint x amount of Commsaurs only if the mint status allows it
 38 |     // @dev since we're using erc721a, the safe mint takes a quantity amount
 39 |     function mintCommsaurs(uint256 commsaursToMint) external payable {
 40 |         require(tx.origin == msg.sender, "CS: Caller must be a real user");
 41 |         require(
 42 |             mintStatus == MintStatus.PUBLIC,
 43 |             "CS: Minting is currently closed!"
 44 |         );
 45 |         require(
 46 |             totalSupply() + commsaursToMint < MAX_SUPPLY,
 47 |             "CS: Minting would exceed max supply"
 48 |         );
 49 |         require(commsaursToMint > 0, "CS: Must mint at least one Commsaur");
 50 |         require(
 51 |             commsaursToMint <= 5,
 52 |             "CS: You can only mint a max of 5 Commsaurs per tx"
 53 |         );
 54 |         require(
 55 |             msg.value == MINT_PRICE * commsaursToMint,
 56 |             "CS: Ether value sent is not correct"
 57 |         );
 58 | 
 59 |         _safeMint(msg.sender, commsaursToMint);
 60 |         refundEthOverflow(commsaursToMint * MINT_PRICE);
 61 |     }
 62 | 
 63 |     // @notice Allows minting during allow list
 64 |     function mintAllowList() external payable {
 65 |         require(tx.origin == msg.sender, "CS: Caller must be a real user");
 66 |         require(
 67 |             mintStatus == MintStatus.ALLOW_LIST,
 68 |             "CS: Allow-list claiming is closed"
 69 |         );
 70 |         require(
 71 |             allowList[msg.sender],
 72 |             "CS: Address not elegible for Commsaur allow-list"
 73 |         );
 74 | 
 75 |         allowList[msg.sender] = false;
 76 |         _safeMint(msg.sender, 1);
 77 |         refundEthOverflow(MINT_PRICE);
 78 |     }
 79 | 
 80 |     function setMintStatus(uint256 status) external onlyOwner {
 81 |         require(
 82 |             status <= uint256(MintStatus.PUBLIC),
 83 |             "CS: Unknown mint status"
 84 |         );
 85 |         mintStatus = MintStatus(status);
 86 |     }
 87 | 
 88 |     function _baseURI() internal view override returns (string memory) {
 89 |         return baseURI;
 90 |     }
 91 | 
 92 |     function setBaseURI(string memory uri) external onlyOwner {
 93 |         baseURI = uri;
 94 |     }
 95 | 
 96 |     function setWithdrawalAddress(address _addr) external onlyOwner {
 97 |         withdrawalAddress = _addr;
 98 |     }
 99 | 
100 |     function setAllowList(address[] memory addresses) external onlyOwner {
101 |         for (uint256 i = 0; i < addresses.length; i++) {
102 |             allowList[addresses[i]] = true;
103 |         }
104 |     }
105 | 
106 |     function reserveTokens() external onlyOwner {
107 |         require(
108 |             mintStatus == MintStatus.RESERVED,
109 |             "CS: Reserved minting was closed"
110 |         );
111 |         require(!mintReserved, "CS: Reserved minting has already happened");
112 | 
113 |         _safeMint(msg.sender, 150);
114 |         mintReserved = true;
115 |     }
116 | 
117 |     // @notice in case contract mint calls send too much eth, we'll refund the difference
118 |     function refundEthOverflow(uint256 amount) private {
119 |         require(msg.value >= amount, "CS: Not enough ETH sent.");
120 |         if (msg.value > amount) {
121 |             payable(msg.sender).transfer(msg.value - amount);
122 |         }
123 |     }
124 | 
125 |     function withdraw() external onlyOwner {
126 |         Address.sendValue(payable(withdrawalAddress), address(this).balance);
127 |     }
128 | 
129 |     // @notice ERC721A allows us to see more detailed information about a mint, this will be useful further down the line :eyes:
130 |     function getOwnershipData(uint256 tokenId)
131 |         external
132 |         view
133 |         returns (TokenOwnership memory)
134 |     {
135 |         return ownershipOf(tokenId);
136 |     }
137 | }
138 | 


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