creation_sourcecode: // SPDX-License-Identifier: Unlicensed
  
  pragma solidity 0.8.24;
  
  
  /**
   * @dev Contract module that helps prevent reentrant calls to a function.
   *
   * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
   * available, which can be applied to functions to make sure there are no nested
   * (reentrant) calls to them.
   *
   * Note that because there is a single `nonReentrant` guard, functions marked as
   * `nonReentrant` may not call one another. This can be worked around by making
   * those functions `private`, and then adding `external` `nonReentrant` entry
   * points to them.
   *
   * TIP: If you would like to learn more about reentrancy and alternative ways
   * to protect against it, check out our blog post
   * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
   */
  abstract contract ReentrancyGuard {
      // Booleans are more expensive than uint256 or any type that takes up a full
      // word because each write operation emits an extra SLOAD to first read the
      // slot's contents, replace the bits taken up by the boolean, and then write
      // back. This is the compiler's defense against contract upgrades and
      // pointer aliasing, and it cannot be disabled.
  
      // The values being non-zero value makes deployment a bit more expensive,
      // but in exchange the refund on every call to nonReentrant will be lower in
      // amount. Since refunds are capped to a percentage of the total
      // transaction's gas, it is best to keep them low in cases like this one, to
      // increase the likelihood of the full refund coming into effect.
      uint256 private constant _NOT_ENTERED = 1;
      uint256 private constant _ENTERED = 2;
  
      uint256 private _status;
  
      constructor() {
          _status = _NOT_ENTERED;
      }
  
      /**
       * @dev Prevents a contract from calling itself, directly or indirectly.
       * Calling a `nonReentrant` function from another `nonReentrant`
       * function is not supported. It is possible to prevent this from happening
       * by making the `nonReentrant` function external, and making it call a
       * `private` function that does the actual work.
       */
      modifier nonReentrant() {
          _nonReentrantBefore();
          _;
          _nonReentrantAfter();
      }
  
      function _nonReentrantBefore() private {
          // On the first call to nonReentrant, _status will be _NOT_ENTERED
          require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
  
          // Any calls to nonReentrant after this point will fail
          _status = _ENTERED;
      }
  
      function _nonReentrantAfter() private {
          // By storing the original value once again, a refund is triggered (see
          // https://eips.ethereum.org/EIPS/eip-2200)
          _status = _NOT_ENTERED;
      }
  
      /**
       * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
       * `nonReentrant` function in the call stack.
       */
      function _reentrancyGuardEntered() internal view returns (bool) {
          return _status == _ENTERED;
      }
  }
  
  
  /**
   * @dev Provides information about the current execution context, including the
   * sender of the transaction and its data. While these are generally available
   * via msg.sender and msg.data, they should not be accessed in such a direct
   * manner, since when dealing with meta-transactions the account sending and
   * paying for execution may not be the actual sender (as far as an application
   * is concerned).
   *
   * This contract is only required for intermediate, library-like contracts.
   */
  abstract contract Context {
      function _msgSender() internal view virtual returns (address) {
          return msg.sender;
      }
  
      function _msgData() internal view virtual returns (bytes calldata) {
          return msg.data;
      }
  
      function _contextSuffixLength() internal view virtual returns (uint256) {
          return 0;
      }
  }
  
  
  /**
   * @dev Contract module which provides a basic access control mechanism, where
   * there is an account (an owner) that can be granted exclusive access to
   * specific functions.
   *
   * The initial owner is set to the address provided by the deployer. This can
   * later be changed with {transferOwnership}.
   *
   * This module is used through inheritance. It will make available the modifier
   * `onlyOwner`, which can be applied to your functions to restrict their use to
   * the owner.
   */
  abstract contract Ownable is Context {
      address private _owner;
  
      /**
       * @dev The caller account is not authorized to perform an operation.
       */
      error OwnableUnauthorizedAccount(address account);
  
      /**
       * @dev The owner is not a valid owner account. (eg. `address(0)`)
       */
      error OwnableInvalidOwner(address owner);
  
      event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
  
      /**
       * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
       */
      constructor(address initialOwner) {
          if (initialOwner == address(0)) {
              revert OwnableInvalidOwner(address(0));
          }
          _transferOwnership(initialOwner);
      }
  
      /**
       * @dev Throws if called by any account other than the owner.
       */
      modifier onlyOwner() {
          _checkOwner();
          _;
      }
  
      /**
       * @dev Returns the address of the current owner.
       */
      function owner() public view virtual returns (address) {
          return _owner;
      }
  
      /**
       * @dev Throws if the sender is not the owner.
       */
      function _checkOwner() internal view virtual {
          if (owner() != _msgSender()) {
              revert OwnableUnauthorizedAccount(_msgSender());
          }
      }
  
      /**
       * @dev Leaves the contract without owner. It will not be possible to call
       * `onlyOwner` functions. Can only be called by the current owner.
       *
       * NOTE: Renouncing ownership will leave the contract without an owner,
       * thereby disabling any functionality that is only available to the owner.
       */
      function renounceOwnership() public virtual onlyOwner {
          _transferOwnership(address(0));
      }
  
      /**
       * @dev Transfers ownership of the contract to a new account (`newOwner`).
       * Can only be called by the current owner.
       */
      function transferOwnership(address newOwner) public virtual onlyOwner {
          if (newOwner == address(0)) {
              revert OwnableInvalidOwner(address(0));
          }
          _transferOwnership(newOwner);
      }
  
      /**
       * @dev Transfers ownership of the contract to a new account (`newOwner`).
       * Internal function without access restriction.
       */
      function _transferOwnership(address newOwner) internal virtual {
          address oldOwner = _owner;
          _owner = newOwner;
          emit OwnershipTransferred(oldOwner, newOwner);
      }
  }
  
  
  /**
   * @dev Interface of the ERC20 standard as defined in the EIP.
   */
  interface IERC20 {
      /**
       * @dev Emitted when `value` tokens are moved from one account (`from`) to
       * another (`to`).
       *
       * Note that `value` may be zero.
       */
      event Transfer(address indexed from, address indexed to, uint256 value);
  
      /**
       * @dev Emitted when the allowance of a `spender` for an `owner` is set by
       * a call to {approve}. `value` is the new allowance.
       */
      event Approval(address indexed owner, address indexed spender, uint256 value);
  
      /**
       * @dev Returns the value of tokens in existence.
       */
      function totalSupply() external view returns (uint256);
  
      /**
       * @dev Returns the value of tokens owned by `account`.
       */
      function balanceOf(address account) external view returns (uint256);
  
      /**
       * @dev Moves a `value` amount of tokens from the caller's account to `to`.
       *
       * Returns a boolean value indicating whether the operation succeeded.
       *
       * Emits a {Transfer} event.
       */
      function transfer(address to, uint256 value) external returns (bool);
  
      /**
       * @dev Returns the remaining number of tokens that `spender` will be
       * allowed to spend on behalf of `owner` through {transferFrom}. This is
       * zero by default.
       *
       * This value changes when {approve} or {transferFrom} are called.
       */
      function allowance(address owner, address spender) external view returns (uint256);
  
      /**
       * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
       * caller's tokens.
       *
       * Returns a boolean value indicating whether the operation succeeded.
       *
       * IMPORTANT: Beware that changing an allowance with this method brings the risk
       * that someone may use both the old and the new allowance by unfortunate
       * transaction ordering. One possible solution to mitigate this race
       * condition is to first reduce the spender's allowance to 0 and set the
       * desired value afterwards:
       * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
       *
       * Emits an {Approval} event.
       */
      function approve(address spender, uint256 value) external returns (bool);
  
      /**
       * @dev Moves a `value` amount of tokens from `from` to `to` using the
       * allowance mechanism. `value` is then deducted from the caller's
       * allowance.
       *
       * Returns a boolean value indicating whether the operation succeeded.
       *
       * Emits a {Transfer} event.
       */
      function transferFrom(address from, address to, uint256 value) external returns (bool);
  }
  
  
  /**
   * @title VestingContract
   * @dev This contract handles the vesting of ERC20 tokens for investors based on a configurable schedule.
   * Vesting intervals can be set during initialization and only by the owner to ensure controlled deployment.
   */
  contract zkGUNVesting is Ownable, ReentrancyGuard {
      IERC20 public token; // Interface to the ERC20 token contract
      uint256 public vestingStartTime; // Timestamp when the vesting starts, set during initialization
  
      struct Investor {
          uint256 totalAllocated; // Total tokens allocated to the investor
          uint256 withdrawn;      // Total tokens already withdrawn by the investor
      }
  
      mapping(address => Investor) public investors; // Mapping from investor address to their vesting details
  
      // Events to log significant contract activities
      event VestingInitialized(uint256 vestingStartTime);
      event TokensAllocated(address indexed investor, uint256 amount);
      event TokensUpdated(address indexed investor, uint256 newAmount);
      event TokensWithdrawn(address indexed investor, uint256 amount);
      event EmergencyWithdrawal(uint256 amountWithdrawn);
  
      /**
      
       * @param initialOwner Address of the initial owner, usually the deployer.
       */
      constructor(address initialOwner) Ownable(initialOwner) {
      }
  
      /**
       * @dev Initializes the vesting process by setting the start time to now.
       */
      function initializeVesting() external onlyOwner {
          require(vestingStartTime == 0, "Vesting already initialized");
          vestingStartTime = block.timestamp;
          emit VestingInitialized(vestingStartTime);
      }
  
      /**
       * @dev Sets the token allocation for multiple investors at once.
       * @param addresses Array of investor addresses.
       * @param amounts Array of token amounts corresponding to each investor.
       */
      function setAllocation(address[] calldata addresses, uint256[] calldata amounts) external onlyOwner {
          require(addresses.length == amounts.length, "Mismatched inputs");
          for (uint i = 0; i < addresses.length; i++) {
              investors[addresses[i]] = Investor(amounts[i], 0);
              emit TokensAllocated(addresses[i], amounts[i]);
          }
      }
      function setTokenAddressToVest(address tokenAdd) external onlyOwner {
          require(tokenAdd != address(0), "Vesting Token Address cannot be zero address");
          token = IERC20(tokenAdd);
      }
  
      /**
       * @dev Allows the owner to update the token allocation for a specific investor.
       * @param investor Address of the investor.
       * @param newAmount New total allocation for the investor.
       */
      function updateAllocation(address investor, uint256 newAmount) external onlyOwner {
          require(newAmount >= investors[investor].withdrawn, "New amount cannot be less than already withdrawn");
          investors[investor].totalAllocated = newAmount;
          emit TokensUpdated(investor, newAmount);
      }
  
      /**
      * @dev Withdraws available tokens based on the vesting schedule.
      * First withdrawal: 50% at launch.
      * Next 5  withdrawals: 10% each Week after Launch.
      */
      function withdrawTokens() external nonReentrant {
          require(vestingStartTime != 0 && block.timestamp >= vestingStartTime, "Vesting period hasn't started yet");
          Investor storage investor = investors[msg.sender];
  
          uint256 timeSinceStart = block.timestamp - vestingStartTime;
          uint256 weeksSinceStart = timeSinceStart / 1 weeks;
  
          uint256 totalAllowedToWithdraw;
  
          if (weeksSinceStart == 0) {
              // 50% can be withdrawn immediately at launch
              totalAllowedToWithdraw = investor.totalAllocated * 50 / 100;
          } else {
          // Additional 10% for each subsequent week
          totalAllowedToWithdraw = investor.totalAllocated * (50 + (weeksSinceStart * 10)) / 100;
          }
  
  	if (totalAllowedToWithdraw > investor.totalAllocated) {
          totalAllowedToWithdraw = investor.totalAllocated;
      	}
  
  
          uint256 availableToWithdraw = totalAllowedToWithdraw - investor.withdrawn;
          require(availableToWithdraw > 0, "No tokens available for withdrawal");
  
          investor.withdrawn += availableToWithdraw;
          require(token.transfer(msg.sender, availableToWithdraw), "Token transfer failed");
          emit TokensWithdrawn(msg.sender, availableToWithdraw);
  }
      /**
       * @dev Allows the owner to withdraw all tokens from the contract in case of emergencies.
       */
      function emergencyWithdraw(uint256 amount) external onlyOwner {
          uint256 balance = token.balanceOf(address(this));
          require(amount <= balance, "Insufficient balance");
          require(token.transfer(owner(), amount), "Emergency withdrawal failed");
          emit EmergencyWithdrawal(amount);
  }
  
      // withdraw ETH if stuck or someone sends to the address
      function withdrawStuckETH() external onlyOwner {
          bool success;
          (success,) = address(msg.sender).call{value: address(this).balance}("");
      }
      /**
       * @dev Provides a read-only function that returns the total allocated and withdrawn tokens for an investor.
       * @param investor Address of the investor to check.
       * @return totalAllocated Total tokens allocated to the investor.
       * @return withdrawn Total tokens withdrawn by the investor so far.
       */
      function checkAllocation(address investor) external view returns (uint256 totalAllocated, uint256 withdrawn) {
          return (investors[investor].totalAllocated, investors[investor].withdrawn);
      }
  }