Update Crowdsale.sol

contracts/crowdsale/Crowdsale.sol

@@ -1,7 +1,9 @@
-pragma solidity ^0.4.23;
+// SPDX-License-Identifier: MIT License 
 
-import "../token/ERC20/ERC20.sol";
-import "../math/SafeMath.sol";
+pragma solidity ^0.8.9;
+
+import "https://github.com/vclcash123/openzeppelin-solidity/blob/patch-2/contracts/token/ERC20/SafeMath.sol";
+import "https://github.com/vclcash123/openzeppelin-solidity/blob/patch-2/contracts/token/ERC20/IERC20.sol";
 
 
 /**
@@ -19,18 +21,29 @@ import "../math/SafeMath.sol";
 contract Crowdsale {
   using SafeMath for uint256;
 
-  // The token being sold
-  ERC20 public token;
+  // How many token units a buyer gets per wei.
+  // The rate is the conversion between wei and the smallest and indivisible token unit.
+  // So, if you are using a rate of 1 with a DetailedERC20 token with 3 decimals called TOK
+  // 1 wei will give you 1 unit, or 0.001 TOK.
+  uint256 public rate;
 
-  // Address where funds are collected
-  address public wallet;
+ // Address where funds are collected
+  address payable wallet;
 
-  // How many token units a buyer gets per wei
-  uint256 public rate;
+  // The token being sold
+  address public token;
 
   // Amount of wei raised
   uint256 public weiRaised;
 
+    // Public Supply
+    uint256 public publicSupply;
+
+  // start and end timestamps where investments are allowed (both inclusive)
+   uint256 public startTime;
+   uint256 public endTime;
+
+
   /**
    * Event for token purchase logging
    * @param purchaser who paid for the tokens
@@ -46,58 +59,66 @@ contract Crowdsale {
   );
 
   /**
-   * @param _rate Number of token units a buyer gets per wei
-   * @param _wallet Address where collected funds will be forwarded to
-   * @param _token Address of the token being sold
+   * param _rate Number of token units a buyer gets per wei
+   * param _wallet Address where collected funds will be forwarded to
+   * param _token Address of the token being sold
    */
-  constructor(uint256 _rate, address _wallet, ERC20 _token) public {
+
+constructor (uint256 _startTime, uint256 _endTime, uint256 _rate, address payable _wallet, address _token) {
+    require(_startTime >= block.timestamp);
+    require(_endTime >= _startTime);
     require(_rate > 0);
     require(_wallet != address(0));
-    require(_token != address(0));
-
+    require(address(token) != address(0));
+    startTime = _startTime;
+    endTime = _endTime;
     rate = _rate;
     wallet = _wallet;
     token = _token;
+
   }
 
+
+
   // -----------------------------------------
   // Crowdsale external interface
   // -----------------------------------------
 
   /**
    * @dev fallback function ***DO NOT OVERRIDE***
    */
-  function () external payable {
+     fallback ()  external payable {
+    buyTokens(msg.sender);
+  }
+
+    receive ()  external payable {
     buyTokens(msg.sender);
   }
 
+
   /**
    * @dev low level token purchase ***DO NOT OVERRIDE***
    * @param _beneficiary Address performing the token purchase
    */
-  function buyTokens(address _beneficiary) public payable {
-
+ function buyTokens(address _beneficiary) public payable {
+    require(_beneficiary != address(0));
     uint256 weiAmount = msg.value;
-    _preValidatePurchase(_beneficiary, weiAmount);
+  //  _preValidatePurchase(_beneficiary, weiAmount);
 
     // calculate token amount to be created
     uint256 tokens = _getTokenAmount(weiAmount);
 
     // update state
     weiRaised = weiRaised.add(weiAmount);
 
-    _processPurchase(_beneficiary, tokens);
-    emit TokenPurchase(
-      msg.sender,
-      _beneficiary,
-      weiAmount,
-      tokens
-    );
+   // _processPurchase(_beneficiary, token);
+    emit TokenPurchase(msg.sender, _beneficiary, weiAmount, tokens);
 
     _updatePurchasingState(_beneficiary, weiAmount);
 
     _forwardFunds();
-    _postValidatePurchase(_beneficiary, weiAmount);
+
+
   }
 
   // -----------------------------------------
@@ -108,7 +129,7 @@ contract Crowdsale {
    * @dev Validation of an incoming purchase. Use require statements to revert state when conditions are not met. Use super to concatenate validations.
    * @param _beneficiary Address performing the token purchase
    * @param _weiAmount Value in wei involved in the purchase
-   */
+
   function _preValidatePurchase(
     address _beneficiary,
     uint256 _weiAmount
@@ -118,40 +139,32 @@ contract Crowdsale {
     require(_beneficiary != address(0));
     require(_weiAmount != 0);
   }
-
-  /**
-   * @dev Validation of an executed purchase. Observe state and use revert statements to undo rollback when valid conditions are not met.
-   * @param _beneficiary Address performing the token purchase
-   * @param _weiAmount Value in wei involved in the purchase
-   */
-  function _postValidatePurchase(
-    address _beneficiary,
-    uint256 _weiAmount
-  )
-    internal
-  {
-    // optional override
-  }
+
+*/
 
   /**
    * @dev Source of tokens. Override this method to modify the way in which the crowdsale ultimately gets and sends its tokens.
    * @param _beneficiary Address performing the token purchase
    * @param _tokenAmount Number of tokens to be emitted
-   */
+
+
   function _deliverTokens(
     address _beneficiary,
     uint256 _tokenAmount
   )
     internal
   {
-    token.transfer(_beneficiary, _tokenAmount);
+  token.transfer(_beneficiary, _tokenAmount);
   }
 
+   */
+
+
   /**
    * @dev Executed when a purchase has been validated and is ready to be executed. Not necessarily emits/sends tokens.
    * @param _beneficiary Address receiving the tokens
    * @param _tokenAmount Number of tokens to be purchased
-   */
+
   function _processPurchase(
     address _beneficiary,
     uint256 _tokenAmount
@@ -161,6 +174,9 @@ contract Crowdsale {
     _deliverTokens(_beneficiary, _tokenAmount);
   }
 
+ */
+
+
   /**
    * @dev Override for extensions that require an internal state to check for validity (current user contributions, etc.)
    * @param _beneficiary Address receiving the tokens

contracts/crowdsale/distribution/FinalizableCrowdsale.sol

@@ -1,22 +1,20 @@
-pragma solidity ^0.4.23;
+// SPDX-License-Identifier: MIT
 
-import "../../math/SafeMath.sol";
-import "../../ownership/Ownable.sol";
-import "../validation/TimedCrowdsale.sol";
+pragma solidity ^0.8.7;
 
+import "https://github.com/vclcash123/openzeppelin-solidity/blob/patch-2/contracts/crowdsale/validation/TimedCrowdsale.sol";
+import "https://github.com/vclcash123/openzeppelin-solidity/blob/patch-2/contracts/ownership/Ownable.sol";
+import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/math/SafeMath.sol";
 
 /**
- * @title FinalizableCrowdsale
- * @dev Extension of Crowdsale where an owner can do extra work
- * after finishing.
+ * title FinalizableCrowdsale
+ * dev Extension of Crowdsale where an owner can do extra work after finishing.
  */
 contract FinalizableCrowdsale is TimedCrowdsale, Ownable {
-  using SafeMath for uint256;
-
   bool public isFinalized = false;
-
   event Finalized();
-
+  using SafeMath for uint256;
+
   /**
    * @dev Must be called after crowdsale ends, to do some extra finalization
    * work. Calls the contract's finalization function.

contracts/crowdsale/emission/AllowanceCrowdsale.sol

@@ -1,8 +1,10 @@
-pragma solidity ^0.4.23;
+// SPDX-License-Identifier: MIT
 
-import "../Crowdsale.sol";
-import "../../token/ERC20/ERC20.sol";
-import "../../math/SafeMath.sol";
+pragma solidity ^0.8.4;
+
+import "https://github.com/vclcash123/openzeppelin-solidity/blob/patch-2/contracts/crowdsale/Crowdsale.sol";
+import "https://github.com/vclcash123/openzeppelin-solidity/blob/patch-2/contracts/token/ERC20/ERC20.sol";
+import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/math/SafeMath.sol";
 
 
 /**

contracts/crowdsale/emission/MintedCrowdsale.sol

@@ -1,7 +1,9 @@
-pragma solidity ^0.4.23;
+// SPDX-License-Identifier: MIT License Modern Variant
 
-import "../Crowdsale.sol";
-import "../../token/ERC20/MintableToken.sol";
+pragma solidity ^0.8.7;
+
+import "https://github.com/vclcash123/openzeppelin-solidity/blob/patch-2/contracts/crowdsale/Crowdsale.sol";
+import "https://github.com/vclcash123/openzeppelin-solidity/blob/patch-2/contracts/token/ERC20/MintableToken.sol";
 
 
 /**

contracts/crowdsale/price/IncreasingPriceCrowdsale.sol

@@ -1,7 +1,9 @@
-pragma solidity ^0.4.23;
+// SPDX-License-Identifier: MIT
 
-import "../validation/TimedCrowdsale.sol";
-import "../../math/SafeMath.sol";
+pragma solidity ^0.8.4;
+
+import "https://github.com/vclcash123/openzeppelin-solidity/blob/patch-2/contracts/crowdsale/validation/TimedCrowdsale.sol";
+import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/math/SafeMath.sol";
 
 
 /**

contracts/crowdsale/validation/CappedCrowdsale.sol

@@ -1,48 +1,56 @@
-pragma solidity ^0.4.23;
+// SPDX-License-Identifier: MIT License Modern Variant
 
-import "../../math/SafeMath.sol";
-import "../Crowdsale.sol";
+pragma solidity ^0.8.7;
 
+import "https://github.com/vclcash123/openzeppelin-solidity/blob/patch-2/contracts/token/ERC20/ERC20.sol";
 
 /**
  * @title CappedCrowdsale
  * @dev Crowdsale with a limit for total contributions.
  */
-contract CappedCrowdsale is Crowdsale {
-  using SafeMath for uint256;
-
-  uint256 public cap;
-
-  /**
-   * @dev Constructor, takes maximum amount of wei accepted in the crowdsale.
-   * @param _cap Max amount of wei to be contributed
-   */
-  constructor(uint256 _cap) public {
-    require(_cap > 0);
-    cap = _cap;
-  }
-
-  /**
-   * @dev Checks whether the cap has been reached.
-   * @return Whether the cap was reached
-   */
-  function capReached() public view returns (bool) {
-    return weiRaised >= cap;
-  }
-
-  /**
-   * @dev Extend parent behavior requiring purchase to respect the funding cap.
-   * @param _beneficiary Token purchaser
-   * @param _weiAmount Amount of wei contributed
-   */
-  function _preValidatePurchase(
-    address _beneficiary,
-    uint256 _weiAmount
-  )
-    internal
-  {
-    super._preValidatePurchase(_beneficiary, _weiAmount);
-    require(weiRaised.add(_weiAmount) <= cap);
-  }
 
+abstract contract ERC20Capped is ERC20 {
+
+    uint256 public _cap=300000000000000000000; // 300 ETH = 300*10^18 wei = 300000000000000000000 wei;
+
+	//minimum investor Contribution -  1
+	//maximum investor Contribution - 300 wei is similar maxium daily 300 ETH crowdsale
+	uint256 public investorMinCap = 1000000000000000000; // 1 ETH = 10^18 wei = 1000000000000000000 wei
+	uint256 public investorHardCap = 300000000000000000000; // 300 ETH = 300*10^18 wei = 300000000000000000000 wei
+
+	 // start and end timestamps where investments are allowed (both inclusive)
+   uint256 public startTime;
+   uint256 public endTime;
+
+	mapping(address => uint256) public contributions;
+
+    /**
+     * @dev Sets the value of the `cap`. This value is immutable, it can only be
+     * set once during construction.
+     */
+    constructor(uint256 cap_, uint256 _openingTime, uint256 _closingTime) {
+        require(cap_ > 0, "ERC20Capped: cap is 300000000000000000000");
+       require(_openingTime >= block.timestamp);
+        require(_closingTime >= _openingTime);
+        _cap = cap_;
+    }
+
+    /**
+     * @dev Returns the cap on the token's total supply.
+     */
+    function cap() public view virtual returns (uint256) {
+        return _cap;
+    }
+
+    /**
+     * @dev See {ERC20-_mint}.
+     */
+    function _mint(address account, uint256 amount) internal virtual override {
+        require(ERC20.totalSupply() + amount <= cap(), "ERC20Capped: cap exceeded");
+        super._mint(account, amount);
+    }
+
+
+
 }
+

contracts/crowdsale/validation/IndividuallyCappedCrowdsale.sol

@@ -1,8 +1,10 @@
-pragma solidity ^0.4.23;
+// SPDX-License-Identifier: MIT License Modern Variant
 
-import "../../math/SafeMath.sol";
-import "../Crowdsale.sol";
-import "../../ownership/Ownable.sol";
+pragma solidity ^0.8.7;
+
+import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/math/SafeMath.sol";
+import "https://github.com/vclcash123/openzeppelin-solidity/blob/patch-2/contracts/crowdsale/Crowdsale.sol";
+import "https://github.com/vclcash123/openzeppelin-solidity/blob/patch-2/contracts/ownership/Ownable.sol";
 
 
 /**