EMFXD-1689: Merge private1 and private2 (#3) (#4)

* refactor: ♻️ upgrade private 2 to merge with the private 1

* chore: 🐛 update vault to point to vault private 1

Author: michyaraque

contracts/FoxtrotPrivateSale.sol

@@ -3,15 +3,15 @@ pragma solidity 0.8.4;
 
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import "@openzeppelin/contracts/access/Ownable.sol";
+import "contracts/utils/Whitelist.sol";
 
 /**
  * @title Automatic Private sale
  * @author Michael Araque
  * @notice A contract that manages a Public Private Sale, purchase, claiming and vesting time
  */
 
-contract FoxtrotPrivateSale is Ownable {
+contract FoxtrotPrivateSale is Whitelist {
     enum InvestorTrace {
         CLAIMED,
         LOCKED,
@@ -30,40 +30,46 @@ contract FoxtrotPrivateSale is Ownable {
     mapping(address => mapping(InvestorTrace => uint256)) private accounting;
     mapping(ContractDates => uint256) private dates;
 
+    event UpdatePrivateSaleStatus(bool isOpen);
     event ClaimToken(address tokenAddress, uint256 tokenAmount);
     event Invest(address investor, uint256 busdAmount, uint256 tokenAmount);
 
     address public busdContract;
     address public tokenContract;
     address public companyVault;
 
+    bool public isPrivateSaleOpen;
     bool public isClaimEnabled;
     uint256 private tokensSoldCounter;
     uint256 public totalBusdInvested;
 
     uint256 private immutable TGE_PERCENT = 8;
     uint256 private immutable AFTER_TGE_BLOCK_TIME = 90 days;
-    uint256 private immutable FXD_PRICE = 30000000000000000 wei;
-    uint256 private immutable MIN_BUSD_ACCEPTED = 50 ether;
-    uint256 private constant MAX_AMOUNT_TOKEN = 15050000 ether;
+    uint256 private immutable FXD_PRICE = 25000000000000000 wei;
+    uint256 private immutable MIN_BUSD_ACCEPTED = 1 ether;
+    uint256 private constant MAX_AMOUNT_TOKEN = 32_250_000 ether;
 
     constructor(address _companyVault, address _busdContract) {
         companyVault = _companyVault;
         busdContract = _busdContract;
         tokenContract = address(0);
+        Whitelist.isWhitelistEnabled = true;
 
         tokensSoldCounter = MAX_AMOUNT_TOKEN;
 
         dates[ContractDates.SALE_START] = 1665504776;
-        dates[ContractDates.SALE_END] = 1728663176;
         dates[ContractDates.VESTING_PERIOD] = 360 days;
+
+        isPrivateSaleOpen = true;
     }
 
     /**
      * @dev This function allows to invest in the private sale
      * @param amount Amount in BUSD to be invested in wei format
      */
-    function invest(uint256 amount) public {
+    function invest(uint256 amount) public onlyWhitelisted {
+        require(isPrivateSaleOpen, "FXD: Private Sale is closed");
+
         require(
             IERC20(busdContract).balanceOf(msg.sender) >= amount,
             "FXD: Insufficient BUSD"
@@ -74,15 +80,23 @@ contract FoxtrotPrivateSale is Ownable {
         );
         require(
             block.timestamp >= dates[ContractDates.SALE_START],
-            "FXD: Private Sale not started"
-        );
-        require(
-            block.timestamp <= dates[ContractDates.SALE_END],
-            "FXD: Private Sale ended"
+            "FXD: Private Sale not started yet"
         );
 
+        if (Whitelist.isWhitelistEnabled) {
+            require(
+                accounting[msg.sender][InvestorTrace.BUSD_INVESTED] <=
+                    Whitelist.amount[msg.sender] &&
+                    amount <= Whitelist.amount[msg.sender] &&
+                    accounting[msg.sender][InvestorTrace.BUSD_INVESTED] +
+                        amount <=
+                    Whitelist.amount[msg.sender],
+                "FXD: Private Sale purchase limit"
+            );
+        }
+
         if (tokensSoldCounter >= getTokenAmount(MIN_BUSD_ACCEPTED, FXD_PRICE))
-            require(amount >= MIN_BUSD_ACCEPTED, "FXD: Minimum amount 50 BUSD");
+            require(amount >= MIN_BUSD_ACCEPTED, "FXD: Minimum amount 1 BUSD");
 
         uint256 tokensAmount = getTokenAmount(amount, FXD_PRICE);
         require(
@@ -134,7 +148,7 @@ contract FoxtrotPrivateSale is Ownable {
      * @dev ClaimToken Emit event
      * @notice This method is the main method to claim tokens
      */
-    function claim() external {
+    function claim() external onlyWhitelisted {
         require(isClaimEnabled, "FXD: Claim status inactive");
         require(
             accounting[msg.sender][InvestorTrace.LOCKED] > 0,
@@ -328,7 +342,7 @@ contract FoxtrotPrivateSale is Ownable {
      * @param from Address of the investor
      * @return uint256 Returns the total amount of tokens that the investor has invested
      */
-    function historicalBalance(address from) internal view returns (uint256) {
+    function historicalBalance(address from) external view returns (uint256) {
         return (accounting[from][InvestorTrace.LOCKED] +
             accounting[from][InvestorTrace.CLAIMED]);
     }
@@ -347,18 +361,26 @@ contract FoxtrotPrivateSale is Ownable {
     }
 
     /**
-     * @notice This method is a helper function that allows to set the end of the sale manually
+     * @notice This method is a helper function that allows to close the private sale manually
      */
-    function setSaleEnd() external onlyOwner returns (bool) {
-        dates[ContractDates.SALE_END] = block.timestamp;
-        return true;
+    function setSaleEnd() external onlyOwner {
+        isPrivateSaleOpen = false;
+        emit UpdatePrivateSaleStatus(false);
     }
 
     /**
-     * @return uint256 Date of the Private sale end
+     * @notice This method is a helper function that allows to open the private sale manually
      */
-    function getSaleEnd() external view returns (uint256) {
-        return dates[ContractDates.SALE_END];
+    function openPrivateSale() external onlyOwner {
+        isPrivateSaleOpen = true;
+        emit UpdatePrivateSaleStatus(true);
+    }
+
+    /**
+     * @return bool Show is the privatesale is open or closed
+     */
+    function showPrivateSaleStatus() external view returns (bool) {
+        return isPrivateSaleOpen;
     }
 
     /**
@@ -398,7 +420,10 @@ contract FoxtrotPrivateSale is Ownable {
             "FXD: You can't withdraw Foxtrot Tokens"
         );
         IERC20 Token = IERC20(token);
-        require(Token.balanceOf(address(this)) >= amount, "FXD: Insufficient amount");
+        require(
+            Token.balanceOf(address(this)) >= amount,
+            "FXD: Insufficient amount"
+        );
         Token.transfer(receiver, amount);
         return true;
     }
@@ -408,10 +433,6 @@ contract FoxtrotPrivateSale is Ownable {
      *         to the Foxtrot Command (FXD) Contract
      */
     function purgeNonSelledTokens() external onlyOwner {
-        require(
-            block.timestamp >= dates[ContractDates.SALE_END],
-            "FXD: Private sale is still alive"
-        );
         SafeERC20.safeTransfer(
             IERC20(tokenContract),
             tokenContract,

contracts/utils/Whitelist.sol

@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.4;
+
+import "@openzeppelin/contracts/access/Ownable.sol";
+
+/**
+ * @title Whitelist
+ * @dev The Whitelist contract has a whitelist of addresses, and provides basic authorization control functions.
+ * @dev This simplifies the implementation of "user permissions".
+ */
+contract Whitelist is Ownable {
+    bool public isWhitelistEnabled;
+
+    mapping(address => bool) public whitelist;
+    mapping(address => uint256) public amount;
+
+    event WhitelistedAddressAdded(address addr, uint256 amount);
+    event WhitelistedAddressRemoved(address addr);
+    event WhitelistEnabled(address who);
+    event WhitelistDisabled(address who);
+
+    modifier onlyWhitelisted() {
+        if (isWhitelistEnabled) {
+            require(whitelist[msg.sender], "FXD: Not on the whitelist");
+        }
+        _;
+    }
+
+    function addAddressToWhitelist(address addr, uint256 _amount)
+        public
+        onlyOwner
+        returns (bool success)
+    {
+        if (!whitelist[addr]) {
+            whitelist[addr] = true;
+            amount[addr] = _amount;
+            emit WhitelistedAddressAdded(addr, _amount);
+            success = true;
+        }
+    }
+
+    function addAddressesToWhitelist(
+        address[] calldata addrs,
+        uint256[] calldata _amount
+    ) public onlyOwner returns (bool success) {
+        for (uint256 i = 0; i < addrs.length; i++) {
+            if (addAddressToWhitelist(addrs[i], _amount[i])) {
+                success = true;
+            }
+        }
+    }
+
+    function removeAddressFromWhitelist(address addr)
+        public
+        onlyOwner
+        returns (bool success)
+    {
+        if (whitelist[addr]) {
+            whitelist[addr] = false;
+            amount[addr] = 0;
+            emit WhitelistedAddressRemoved(addr);
+            success = true;
+        }
+    }
+
+    function removeAddressesFromWhitelist(address[] calldata addrs)
+        public
+        onlyOwner
+        returns (bool success)
+    {
+        for (uint256 i = 0; i < addrs.length; i++) {
+            if (removeAddressFromWhitelist(addrs[i])) {
+                success = true;
+            }
+        }
+    }
+
+    function disableWhitelist() external onlyOwner {
+        isWhitelistEnabled = false;
+        emit WhitelistDisabled(msg.sender);
+    }
+
+    function enableWhitelist() external onlyOwner {
+        isWhitelistEnabled = true;
+        emit WhitelistEnabled(msg.sender);
+    }
+
+}

scripts/deploy.ts

@@ -25,6 +25,8 @@ async function main() {
   await busdToken.deployed();
   await privateSale.deployed();
 
+  await privateSale.connect(masterAccount).addAddressToWhitelist(masterAccount.address, ethers.utils.parseEther('120000'));
+
   await foxtrotToken
     .connect(masterAccount)
     .secureTransfer(
@@ -41,7 +43,7 @@ async function main() {
   console.log("Token deployed to:", foxtrotToken.address);
 
   console.log(`
-NEXT_PUBLIC_PRIVATE_TWO_CONTRACT=${privateSale.address}
+NEXT_PUBLIC_PRIVATE_CONTRACT=${privateSale.address}
 NEXT_PUBLIC_BUSD_CONTRACT=${busdToken.address}
 NEXT_PUBLIC_FXD_CONTRACT=${foxtrotToken.address}
   `);

scripts/deployPrivateSale.ts

@@ -3,20 +3,20 @@ import hre from "hardhat";
 
 async function main() {
   let masterAccount;
-  let privateSaleVault2 = "0x5Cb9dDb9e859CF87fE515597306483D7198B9471";
+  let privateSaleVault = "0x7d9e52c4d53abcf6efa95ac0883925e326f92730";
   let fxdToken = "0x15df8d414ab0add3e989af15fea7d279e4c2c58a";
   let busdToken = "0xe9e7cea3dedca5984780bafc599bd69add087d56";
 
   [masterAccount] = await ethers.getSigners();
 
   const PrivateSale = await hre.ethers.getContractFactory("FoxtrotPrivateSale");
-  const privateSale = await PrivateSale.deploy(privateSaleVault2, busdToken);
+  const privateSale = await PrivateSale.deploy(privateSaleVault, busdToken);
 
   try {
     await hre.run("verify:verify", {
       address: privateSale.address,
       contract: "contracts/FoxtrotPrivateSale.sol:FoxtrotPrivateSale",
-      constructorArguments: [privateSaleVault2, busdToken],
+      constructorArguments: [privateSaleVault, busdToken],
     });
   } catch (err: any) {
     if (err.message.includes("Reason: Already Verified")) {

tasks/changeClaimStatus.ts

@@ -10,7 +10,7 @@ task("change-claim", "Change claim status")
     }
 
     const [deployer] = await hre.ethers.getSigners();
-    const privateSale = await (
+    const privateSale = (
       await hre.ethers.getContractFactory("FoxtrotPrivateSale")
     ).attach(taskArgs.contract);
     await privateSale.connect(deployer).changeClaimStatus();