Merge pull request #2 from panditdhamdhere/ERCs

kartojal · web-flow · commit b355c2ab4632 · 2025-01-15T17:57:14.000+01:00
ERC20 and ERC721 contracts added
diff --git a/.gitmodules b/.gitmodules
@@ -4,3 +4,6 @@
 [submodule "lib/deployer-kit"]
 	path = lib/deployer-kit
 	url = https://github.com/kartojal/deployer-kit
+[submodule "lib/openzeppelin-contracts"]
+	path = lib/openzeppelin-contracts
+	url = https://github.com/Openzeppelin/openzeppelin-contracts
diff --git a/.vscode/settings.json b/.vscode/settings.json
@@ -0,0 +1,10 @@
+{
+    "wake.compiler.solc.remappings": [
+        "@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
+        "ds-test/=lib/forge-std/lib/ds-test/src/",
+        "erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
+        "forge-std/=lib/forge-std/src/",
+        "halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/",
+        "openzeppelin-contracts/=lib/openzeppelin-contracts/"
+    ]
+}
diff --git a/foundry.toml b/foundry.toml
@@ -1,7 +1,13 @@
 [profile.default]
-solc_version = "0.8.19"
+solc_version = "0.8.20"
 optimizer = true
 optimizer_runs = 20_000
 
 [profile.ci.fuzz]
 runs = 10_000
+
+remappings = [
+    "@openzeppelin/=lib/openzeppelin-contracts/",
+    "ds-test/=lib/forge-std/lib/ds-test/src/",
+    "forge-std/=lib/forge-std/src/",
+]
diff --git a/lib/openzeppelin-contracts b/lib/openzeppelin-contracts
@@ -0,0 +1 @@
+Subproject commit acd4ff74de833399287ed6b31b4debf6b2b35527
diff --git a/script/Deploy.s.sol b/script/Deploy.s.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import {Script} from "forge-std/Script.sol";
 import {BatteringRam} from "../src/BatteringRam.sol";
diff --git a/script/Spell.s.sol b/script/Spell.s.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import {Script} from "forge-std/Script.sol";
 import {Spell} from "../src/Spell.sol";
diff --git a/script/Trebuchet.s.sol b/script/Trebuchet.s.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import {Script} from "forge-std/Script.sol";
 import {Trebuchet} from "../src/Trebuchet.sol";
diff --git a/script/token/DeployMyNFT.sol b/script/token/DeployMyNFT.sol
@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {Script} from "forge-std/Script.sol";
+import {MyNFT} from "../../src/tokens/MyNFT.sol";
+
+contract DeployMyNFT is Script {
+    function run() external {
+        uint256 deployerPrivateKey = vm.envUint("PRIVATE_KEY");
+        string memory initialBaseURI = "ipfs://baseuri/";
+
+        vm.startBroadcast(deployerPrivateKey);
+
+        MyNFT nft = new MyNFT("MyNFT", "MNFT", initialBaseURI);
+
+        vm.stopBroadcast();
+    }
+}
diff --git a/script/token/DeployMyToken.sol b/script/token/DeployMyToken.sol
@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {Script} from "forge-std/Script.sol";
+import {MyToken} from "../../src/tokens/MyToken.sol";
+
+contract DeployMyToken is Script {
+    function run() public returns (MyToken) {
+        uint256 deployerPrivateKey = vm.envUint("PRIVATE_KEY");
+
+        vm.startBroadcast(deployerPrivateKey);
+        MyToken token = new MyToken(1000000 * 10 ** 18);
+        vm.stopBroadcast();
+
+        return token;
+    }
+}
diff --git a/script/token/DeployVault.s.sol b/script/token/DeployVault.s.sol
@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {Script} from "forge-std/Script.sol";
+import {console} from "forge-std/console.sol";
+import {TokenizedVault} from "../../src/tokens/TokenizedVault.sol";
+import {IERC20} from "../../lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol";
+
+contract DeployVault is Script {
+    function run() external {
+        uint256 deployerPrivateKey = vm.envUint("PRIVATE_KEY");
+        address assetToken = vm.envAddress("ASSET_TOKEN_ADDRESS");
+
+        vm.startBroadcast(deployerPrivateKey);
+
+        TokenizedVault vault = new TokenizedVault(
+            IERC20(assetToken),
+            "Vault Token",
+            "vTKN",
+            100 // 1% initial fee
+        );
+
+        vm.stopBroadcast();
+
+        console.log("Vault deployed at:", address(vault));
+    }
+}
diff --git a/src/BatteringRam.sol b/src/BatteringRam.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 import {Champion} from "./Champion.sol";
 
 contract BatteringRam {
diff --git a/src/Catapult.sol b/src/Catapult.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 contract Catapult {
     uint256 internal _damage;
diff --git a/src/Champion.sol b/src/Champion.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 contract Champion {
     uint256 internal constant _damage = 2;
diff --git a/src/Library.sol b/src/Library.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 library Library {
     function add(uint256 a, uint256 b) external pure returns (uint256) {
diff --git a/src/Spell.sol b/src/Spell.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import {Library} from "./Library.sol";
 
diff --git a/src/Trebuchet.sol b/src/Trebuchet.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 contract Trebuchet {
     uint256 internal _damage;
diff --git a/src/tokens/MyNFT.sol b/src/tokens/MyNFT.sol
@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {ERC721} from "../../lib/openzeppelin-contracts/contracts/token/ERC721/ERC721.sol";
+import {ERC721Enumerable} from "../../lib/openzeppelin-contracts/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
+import {Ownable} from "../../lib/openzeppelin-contracts/contracts/access/Ownable.sol";
+import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
+
+contract MyNFT is ERC721, ERC721Enumerable, Ownable {
+    using Strings for uint256;
+
+    uint256 private _nextTokenId;
+    uint256 public mintPrice = 0.01 ether;
+    string public baseTokenURI;
+
+    constructor(
+        string memory name,
+        string memory symbol,
+        string memory initialBaseURI
+    ) ERC721(name, symbol) Ownable(msg.sender) {
+        baseTokenURI = initialBaseURI;
+    }
+
+    function mint() public payable {
+        require(msg.value >= mintPrice, "Insufficient payment");
+        uint256 tokenId = _nextTokenId++;
+        _safeMint(msg.sender, tokenId);
+    }
+
+    function withdraw() public onlyOwner {
+        uint256 balance = address(this).balance;
+        payable(owner()).transfer(balance);
+    }
+
+    function setMintPrice(uint256 _mintPrice) public onlyOwner {
+        mintPrice = _mintPrice;
+    }
+
+    function setBaseURI(string memory _newBaseURI) public onlyOwner {
+        baseTokenURI = _newBaseURI;
+    }
+
+    function _baseURI() internal view override returns (string memory) {
+        return baseTokenURI;
+    }
+
+    // Override required functions
+    function _update(
+        address to,
+        uint256 tokenId,
+        address auth
+    ) internal override(ERC721, ERC721Enumerable) returns (address) {
+        return super._update(to, tokenId, auth);
+    }
+
+    function _increaseBalance(
+        address account,
+        uint128 value
+    ) internal override(ERC721, ERC721Enumerable) {
+        super._increaseBalance(account, value);
+    }
+
+    function supportsInterface(
+        bytes4 interfaceId
+    ) public view override(ERC721, ERC721Enumerable) returns (bool) {
+        return super.supportsInterface(interfaceId);
+    }
+}
diff --git a/src/tokens/MyToken.sol b/src/tokens/MyToken.sol
@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {ERC20} from "../../lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol";
+
+contract MyToken is ERC20 {
+    constructor(uint256 initialSupply) ERC20("MyToken", "MTK") {
+        _mint(msg.sender, initialSupply);
+    }
+}
diff --git a/src/tokens/TokenizedVault.sol b/src/tokens/TokenizedVault.sol
@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {ERC20} from "../../lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol";
+import {ERC4626} from "../../lib/openzeppelin-contracts/contracts/token/ERC20/extensions/ERC4626.sol";
+import {Ownable} from "../../lib/openzeppelin-contracts/contracts/access/Ownable.sol";
+import {Math} from "../../lib/openzeppelin-contracts/contracts/utils/math/Math.sol";
+import {IERC20} from "../../lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol";
+
+contract TokenizedVault is ERC4626, Ownable {
+    using Math for uint256;
+
+    uint256 public managementFee; // Fee represented in basis points (1/10000)
+    uint256 public constant MAX_FEE = 1000; // Maximum fee of 10% (1000 basis points)
+    uint256 private constant BASIS_POINTS = 10000;
+
+    constructor(
+        IERC20 asset_,
+        string memory name_,
+        string memory symbol_,
+        uint256 initialFee_
+    ) ERC4626(asset_) ERC20(name_, symbol_) Ownable(msg.sender) {
+        require(initialFee_ <= MAX_FEE, "Fee too high");
+        managementFee = initialFee_;
+    }
+
+    function setManagementFee(uint256 newFee) external onlyOwner {
+        require(newFee <= MAX_FEE, "Fee too high");
+        managementFee = newFee;
+    }
+
+    function totalAssets() public view virtual override returns (uint256) {
+        uint256 totalAssetsValue = super.totalAssets();
+        uint256 feeAmount = (totalAssetsValue * managementFee) / BASIS_POINTS;
+        return totalAssetsValue - feeAmount;
+    }
+
+    function _deposit(
+        address caller,
+        address receiver,
+        uint256 assets,
+        uint256 shares
+    ) internal virtual override {
+        super._deposit(caller, receiver, assets, shares);
+
+        // Transfer management fee to owner
+        uint256 feeAmount = (assets * managementFee) / BASIS_POINTS;
+        if (feeAmount > 0) {
+            IERC20(asset()).transfer(owner(), feeAmount);
+        }
+    }
+
+    function _withdraw(
+        address caller,
+        address receiver,
+        address owner_,
+        uint256 assets,
+        uint256 shares
+    ) internal virtual override {
+        super._withdraw(caller, receiver, owner_, assets, shares);
+
+        // Apply fee on withdrawal
+        uint256 feeAmount = (assets * managementFee) / BASIS_POINTS;
+        if (feeAmount > 0) {
+            IERC20(asset()).transfer(owner(), feeAmount);
+        }
+    }
+}
diff --git a/test/Basic.t.sol b/test/Basic.t.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: Unlicense
-pragma solidity ^0.8.13;
+pragma solidity ^0.8.20;
 
 import "forge-std/Test.sol";
 
diff --git a/test/token/MyNFTTest.t.sol b/test/token/MyNFTTest.t.sol
@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {Test} from "forge-std/Test.sol";
+import {MyNFT} from "../../src/tokens/MyNFT.sol";
+
+contract MyNFTTest is Test {
+    MyNFT public nft;
+    address public owner;
+    address public user;
+    string public constant INITIAL_BASE_URI = "ipfs://baseuri/";
+
+    function setUp() public {
+        owner = makeAddr("owner");
+        user = makeAddr("user");
+        vm.prank(owner);
+        nft = new MyNFT("MyNFT", "MNFT", INITIAL_BASE_URI);
+    }
+
+    function testMint() public {
+        vm.deal(user, 1 ether);
+        vm.prank(user);
+        nft.mint{value: 0.01 ether}();
+
+        assertEq(nft.balanceOf(user), 1);
+        assertEq(nft.ownerOf(0), user);
+    }
+
+    function testFailMintWithoutPayment() public {
+        vm.prank(user);
+        nft.mint();
+    }
+
+    function testWithdraw() public {
+        // First mint an NFT to add funds to contract
+        vm.deal(user, 1 ether);
+        vm.prank(user);
+        nft.mint{value: 0.01 ether}();
+
+        // Check owner can withdraw
+        uint256 initialBalance = owner.balance;
+        vm.prank(owner);
+        nft.withdraw();
+        assertEq(owner.balance - initialBalance, 0.01 ether);
+    }
+
+    function testSetMintPrice() public {
+        vm.prank(owner);
+        nft.setMintPrice(0.02 ether);
+        assertEq(nft.mintPrice(), 0.02 ether);
+    }
+
+    function testFailNonOwnerSetMintPrice() public {
+        vm.prank(user);
+        nft.setMintPrice(0.02 ether);
+    }
+
+    function testSetBaseURI() public {
+        string memory newBaseURI = "ipfs://newbaseuri/";
+        vm.prank(owner);
+        nft.setBaseURI(newBaseURI);
+
+        // Mint a token to test the new baseURI
+        vm.deal(user, 1 ether);
+        vm.prank(user);
+        nft.mint{value: 0.01 ether}();
+
+        assertEq(nft.baseTokenURI(), newBaseURI);
+    }
+
+    function testFailNonOwnerSetBaseURI() public {
+        vm.prank(user);
+        nft.setBaseURI("ipfs://newbaseuri/");
+    }
+}
diff --git a/test/token/MyTokenTest.sol b/test/token/MyTokenTest.sol
diff --git a/test/token/TokenizedVault.t.sol b/test/token/TokenizedVault.t.sol
