├── README.md
├── .gitignore
├── hardhat.config.js
├── contracts
    ├── OceanToken.sol
    ├── ERC4626Strategy.sol
    ├── Vault.sol
    └── ERC4626Fees.sol
├── package.json
├── scripts
    └── deploy.js
└── test
    └── Lock.js


/README.md:
--------------------------------------------------------------------------------
1 | # ERC4626 Tokenized Vault tutorial
2 | 
3 | Basic vault implementation using ERC4626 standard for tokenized vaults.
4 | 


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


--------------------------------------------------------------------------------
/hardhat.config.js:
--------------------------------------------------------------------------------
1 | require("@nomicfoundation/hardhat-toolbox");
2 | 
3 | /** @type import('hardhat/config').HardhatUserConfig */
4 | module.exports = {
5 |   solidity: "0.8.20",
6 | };
7 | 


--------------------------------------------------------------------------------
/contracts/OceanToken.sol:
--------------------------------------------------------------------------------
 1 | // SPDX-License-Identifier: MIT
 2 | 
 3 | pragma solidity ^0.8.20;
 4 | 
 5 | import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 6 | 
 7 | contract OceanToken is ERC20 {
 8 |     constructor() ERC20("OceanToken", "OCT") {
 9 |         _mint(msg.sender, 1000000 * (10 ** decimals()));
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "vault_smart_contract_poc",
 3 |   "version": "1.0.0",
 4 |   "description": "",
 5 |   "main": "index.js",
 6 |   "scripts": {
 7 |     "test": "echo \"Error: no test specified\" && exit 1"
 8 |   },
 9 |   "author": "",
10 |   "license": "ISC",
11 |   "devDependencies": {
12 |     "@nomicfoundation/hardhat-toolbox": "^3.0.0",
13 |     "hardhat": "^2.17.3"
14 |   },
15 |   "dependencies": {
16 |     "@openzeppelin/contracts": "^4.9.3"
17 |   }
18 | }
19 | 


--------------------------------------------------------------------------------
/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 | // You can also run a script with `npx hardhat run <script>`. If you do that, Hardhat
 5 | // will compile your contracts, add the Hardhat Runtime Environment's members to the
 6 | // global scope, and execute the script.
 7 | const hre = require("hardhat");
 8 | 
 9 | async function main() {
10 |   const currentTimestampInSeconds = Math.round(Date.now() / 1000);
11 |   const unlockTime = currentTimestampInSeconds + 60;
12 | 
13 |   const lockedAmount = hre.ethers.parseEther("0.001");
14 | 
15 |   const lock = await hre.ethers.deployContract("Lock", [unlockTime], {
16 |     value: lockedAmount,
17 |   });
18 | 
19 |   await lock.waitForDeployment();
20 | 
21 |   console.log(
22 |     `Lock with ${ethers.formatEther(
23 |       lockedAmount
24 |     )}ETH and unlock timestamp ${unlockTime} deployed to ${lock.target}`
25 |   );
26 | }
27 | 
28 | // We recommend this pattern to be able to use async/await everywhere
29 | // and properly handle errors.
30 | main().catch((error) => {
31 |   console.error(error);
32 |   process.exitCode = 1;
33 | });
34 | 


--------------------------------------------------------------------------------
/contracts/ERC4626Strategy.sol:
--------------------------------------------------------------------------------
 1 | // SPDX-License-Identifier: MIT
 2 | 
 3 | pragma solidity ^0.8.20;
 4 | 
 5 | import "@openzeppelin/contracts/token/ERC20/extensions/ERC4626.sol";
 6 | 
 7 | abstract contract ERC4626Strategy is ERC4626 {
 8 |     /** @dev See {IERC4626-deposit}. */
 9 |     function deposit(uint256 assets, address receiver) public virtual override returns (uint256) {
10 |         require(assets <= maxDeposit(receiver), "ERC4626: deposit more than max");
11 | 
12 |         uint256 shares = previewDeposit(assets);
13 |         _deposit(_msgSender(), receiver, assets, shares);
14 |         afterDeposit(assets, shares);
15 | 
16 |         return shares;
17 |     }
18 | 
19 |     /** @dev See {IERC4626-mint}.
20 |      *
21 |      * As opposed to {deposit}, minting is allowed even if the vault is in a state where the price of a share is zero.
22 |      * In this case, the shares will be minted without requiring any assets to be deposited.
23 |      */
24 |     function mint(uint256 shares, address receiver) public virtual override returns (uint256) {
25 |         require(shares <= maxMint(receiver), "ERC4626: mint more than max");
26 | 
27 |         uint256 assets = previewMint(shares);
28 |         _deposit(_msgSender(), receiver, assets, shares);
29 |         afterDeposit(assets, shares);
30 | 
31 |         return assets;
32 |     }
33 | 
34 |     /** @dev See {IERC4626-redeem}. */
35 |     function redeem(uint256 shares, address receiver, address owner) public virtual override returns (uint256) {
36 |         require(shares <= maxRedeem(owner), "ERC4626: redeem more than max");
37 | 
38 |         uint256 assets = previewRedeem(shares);
39 |         beforeWithdraw(assets, shares);
40 |         _withdraw(_msgSender(), receiver, owner, assets, shares);
41 | 
42 |         return assets;
43 |     }
44 | 
45 |     /** @dev See {IERC4626-withdraw}. */
46 |     function withdraw(uint256 assets, address receiver, address owner) public virtual override returns (uint256) {
47 |         require(assets <= maxWithdraw(owner), "ERC4626: withdraw more than max");
48 | 
49 |         uint256 shares = previewWithdraw(assets);
50 |         beforeWithdraw(assets, shares);
51 |         _withdraw(_msgSender(), receiver, owner, assets, shares);
52 | 
53 |         return shares;
54 |     }
55 | 
56 |     /*//////////////////////////////////////////////////////////////
57 |                           INTERNAL HOOKS LOGIC
58 |     //////////////////////////////////////////////////////////////*/
59 | 
60 |     function afterDeposit(uint256 assets, uint256 shares) internal virtual {}
61 |     
62 |     function beforeWithdraw(uint256 assets, uint256 shares) internal virtual {}
63 | }


--------------------------------------------------------------------------------
/contracts/Vault.sol:
--------------------------------------------------------------------------------
 1 | // SPDX-License-Identifier: MIT
 2 | 
 3 | pragma solidity ^0.8.20;
 4 | 
 5 | import "./ERC4626Fees.sol";
 6 | 
 7 | contract Vault is ERC4626Fees  {
 8 |     address payable public vaultOwner;
 9 |     uint256 public entryFeeBasisPoints;
10 | 
11 |     constructor(IERC20 _asset, uint256 _basisPoints) ERC4626(_asset) ERC20("Vault Ocean Token", "vOCT"){
12 |         vaultOwner = payable(msg.sender);
13 |         entryFeeBasisPoints = _basisPoints;
14 |     }
15 | 
16 |     /** @dev See {IERC4626-deposit}. */
17 |     function deposit(uint256 assets, address receiver) public virtual override returns (uint256) {
18 |         require(assets <= maxDeposit(receiver), "ERC4626: deposit more than max");
19 | 
20 |         uint256 shares = previewDeposit(assets);
21 |         _deposit(_msgSender(), receiver, assets, shares);
22 |         afterDeposit(assets, shares);
23 | 
24 |         return shares;
25 |     }
26 | 
27 |     /** @dev See {IERC4626-mint}.
28 |      *
29 |      * As opposed to {deposit}, minting is allowed even if the vault is in a state where the price of a share is zero.
30 |      * In this case, the shares will be minted without requiring any assets to be deposited.
31 |      */
32 |     function mint(uint256 shares, address receiver) public virtual override returns (uint256) {
33 |         require(shares <= maxMint(receiver), "ERC4626: mint more than max");
34 | 
35 |         uint256 assets = previewMint(shares);
36 |         _deposit(_msgSender(), receiver, assets, shares);
37 |         afterDeposit(assets, shares);
38 | 
39 |         return assets;
40 |     }
41 | 
42 |     /** @dev See {IERC4626-redeem}. */
43 |     function redeem(uint256 shares, address receiver, address owner) public virtual override returns (uint256) {
44 |         require(shares <= maxRedeem(owner), "ERC4626: redeem more than max");
45 | 
46 |         uint256 assets = previewRedeem(shares);
47 |         beforeWithdraw(assets, shares);
48 |         _withdraw(_msgSender(), receiver, owner, assets, shares);
49 | 
50 |         return assets;
51 |     }
52 | 
53 |     /** @dev See {IERC4626-withdraw}. */
54 |     function withdraw(uint256 assets, address receiver, address owner) public virtual override returns (uint256) {
55 |         require(assets <= maxWithdraw(owner), "ERC4626: withdraw more than max");
56 | 
57 |         uint256 shares = previewWithdraw(assets);
58 |         beforeWithdraw(assets, shares);
59 |         _withdraw(_msgSender(), receiver, owner, assets, shares);
60 | 
61 |         return shares;
62 |     }
63 | 
64 |     function _entryFeeBasisPoints() internal view override returns (uint256) {
65 |         return entryFeeBasisPoints;
66 |     }
67 | 
68 |     function _entryFeeRecipient() internal view override returns (address) {
69 |         return vaultOwner;
70 |     }
71 | 
72 |     /*//////////////////////////////////////////////////////////////
73 |                           INTERNAL HOOKS LOGIC
74 |     //////////////////////////////////////////////////////////////*/
75 | 
76 |     function afterDeposit(uint256 assets, uint256 shares) internal virtual {}
77 |     
78 |     function beforeWithdraw(uint256 assets, uint256 shares) internal virtual {}
79 | }
80 | 


--------------------------------------------------------------------------------
/contracts/ERC4626Fees.sol:
--------------------------------------------------------------------------------
  1 | // SPDX-License-Identifier: MIT
  2 | 
  3 | pragma solidity ^0.8.0;
  4 | 
  5 | import "@openzeppelin/contracts/token/ERC20/extensions/ERC4626.sol";
  6 | 
  7 | /// @dev ERC4626 vault with entry/exit fees expressed in https://en.wikipedia.org/wiki/Basis_point[basis point (bp)].
  8 | abstract contract ERC4626Fees is ERC4626 {
  9 |     using Math for uint256;
 10 | 
 11 |     uint256 private constant _BASIS_POINT_SCALE = 1e4;
 12 | 
 13 |     // === Overrides ===
 14 | 
 15 |     /// @dev Preview taking an entry fee on deposit. See {IERC4626-previewDeposit}.
 16 |     function previewDeposit(uint256 assets) public view virtual override returns (uint256) {
 17 |         uint256 fee = _feeOnTotal(assets, _entryFeeBasisPoints());
 18 |         return super.previewDeposit(assets - fee);
 19 |     }
 20 | 
 21 |     /// @dev Preview adding an entry fee on mint. See {IERC4626-previewMint}.
 22 |     function previewMint(uint256 shares) public view virtual override returns (uint256) {
 23 |         uint256 assets = super.previewMint(shares);
 24 |         return assets + _feeOnRaw(assets, _entryFeeBasisPoints());
 25 |     }
 26 | 
 27 |     /// @dev Preview adding an exit fee on withdraw. See {IERC4626-previewWithdraw}.
 28 |     function previewWithdraw(uint256 assets) public view virtual override returns (uint256) {
 29 |         uint256 fee = _feeOnRaw(assets, _exitFeeBasisPoints());
 30 |         return super.previewWithdraw(assets + fee);
 31 |     }
 32 | 
 33 |     /// @dev Preview taking an exit fee on redeem. See {IERC4626-previewRedeem}.
 34 |     function previewRedeem(uint256 shares) public view virtual override returns (uint256) {
 35 |         uint256 assets = super.previewRedeem(shares);
 36 |         return assets - _feeOnTotal(assets, _exitFeeBasisPoints());
 37 |     }
 38 | 
 39 |     /// @dev Send entry fee to {_entryFeeRecipient}. See {IERC4626-_deposit}.
 40 |     function _deposit(address caller, address receiver, uint256 assets, uint256 shares) internal virtual override {
 41 |         uint256 fee = _feeOnTotal(assets, _entryFeeBasisPoints());
 42 |         address recipient = _entryFeeRecipient();
 43 | 
 44 |         super._deposit(caller, receiver, assets, shares);
 45 | 
 46 |         if (fee > 0 && recipient != address(this)) {
 47 |             SafeERC20.safeTransfer(IERC20(asset()), recipient, fee);
 48 |         }
 49 |     }
 50 | 
 51 |     /// @dev Send exit fee to {_exitFeeRecipient}. See {IERC4626-_deposit}.
 52 |     function _withdraw(
 53 |         address caller,
 54 |         address receiver,
 55 |         address owner,
 56 |         uint256 assets,
 57 |         uint256 shares
 58 |     ) internal virtual override {
 59 |         uint256 fee = _feeOnRaw(assets, _exitFeeBasisPoints());
 60 |         address recipient = _exitFeeRecipient();
 61 | 
 62 |         super._withdraw(caller, receiver, owner, assets, shares);
 63 | 
 64 |         if (fee > 0 && recipient != address(this)) {
 65 |             SafeERC20.safeTransfer(IERC20(asset()), recipient, fee);
 66 |         }
 67 |     }
 68 | 
 69 |     // === Fee configuration ===
 70 | 
 71 |     function _entryFeeBasisPoints() internal view virtual returns (uint256) {
 72 |         return 0; // replace with e.g. 100 for 1%
 73 |     }
 74 | 
 75 |     function _exitFeeBasisPoints() internal view virtual returns (uint256) {
 76 |         return 0; // replace with e.g. 100 for 1%
 77 |     }
 78 | 
 79 |     function _entryFeeRecipient() internal view virtual returns (address) {
 80 |         return address(0); // replace with e.g. a treasury address
 81 |     }
 82 | 
 83 |     function _exitFeeRecipient() internal view virtual returns (address) {
 84 |         return address(0); // replace with e.g. a treasury address
 85 |     }
 86 | 
 87 |     // === Fee operations ===
 88 | 
 89 |     /// @dev Calculates the fees that should be added to an amount `assets` that does not already include fees.
 90 |     /// Used in {IERC4626-mint} and {IERC4626-withdraw} operations.
 91 |     function _feeOnRaw(uint256 assets, uint256 feeBasisPoints) private pure returns (uint256) {
 92 |         return assets.mulDiv(feeBasisPoints, _BASIS_POINT_SCALE, Math.Rounding.Up);
 93 |     }
 94 | 
 95 |     /// @dev Calculates the fee part of an amount `assets` that already includes fees.
 96 |     /// Used in {IERC4626-deposit} and {IERC4626-redeem} operations.
 97 |     function _feeOnTotal(uint256 assets, uint256 feeBasisPoints) private pure returns (uint256) {
 98 |         return assets.mulDiv(feeBasisPoints, feeBasisPoints + _BASIS_POINT_SCALE, Math.Rounding.Up);
 99 |     }
100 | }
101 | 


--------------------------------------------------------------------------------
/test/Lock.js:
--------------------------------------------------------------------------------
  1 | const {
  2 |   time,
  3 |   loadFixture,
  4 | } = require("@nomicfoundation/hardhat-toolbox/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 snapshot 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.target)).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 | 


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