// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) 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 `amount` 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 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @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 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 () internal {
_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 make it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
contract LinearVesting is ReentrancyGuard {
using SafeMath for uint256;
/// @notice event emitted when a vesting schedule is created
event ScheduleCreated(address indexed _beneficiary);
/// @notice event emitted when a successful drawn down of vesting tokens is made
event DrawDown(address indexed _beneficiary, uint256 indexed _amount);
/// @notice start of vesting period as a timestamp
uint256 public start;
/// @notice end of vesting period as a timestamp
uint256 public end;
/// @notice cliff duration in seconds
uint256 public cliffDuration;
/// @notice owner address set on construction
address public owner;
/// @notice amount vested for a beneficiary. Note beneficiary address can not be reused
mapping(address => uint256) public vestedAmount;
/// @notice cumulative total of tokens drawn down (and transferred from the deposit account) per beneficiary
mapping(address => uint256) public totalDrawn;
/// @notice last drawn down time (seconds) per beneficiary
mapping(address => uint256) public lastDrawnAt;
/// @notice ERC20 token we are vesting
IERC20 public token;
/**
* @notice Construct a new vesting contract
* @param _token ERC20 token
* @param _start start timestamp
* @param _end end timestamp
* @param _cliffDurationInSecs cliff duration in seconds
* @dev caller on constructor set as owner; this can not be changed
*/
constructor(IERC20 _token, uint256 _start, uint256 _end, uint256 _cliffDurationInSecs) public {
require(address(_token) != address(0), "VestingContract::constructor: Invalid token");
require(_end >= _start, "VestingContract::constructor: Start must be before end");
token = _token;
owner = msg.sender;
start = _start;
end = _end;
cliffDuration = _cliffDurationInSecs;
}
/**
* @notice Create new vesting schedules in a batch
* @notice A transfer is used to bring tokens into the VestingDepositAccount so pre-approval is required
* @param _beneficiaries array of beneficiaries of the vested tokens
* @param _amounts array of amount of tokens (in wei)
* @dev array index of address should be the same as the array index of the amount
*/
function createVestingSchedules(
address[] calldata _beneficiaries,
uint256[] calldata _amounts
) external returns (bool) {
require(msg.sender == owner, "VestingContract::createVestingSchedules: Only Owner");
require(_beneficiaries.length > 0, "VestingContract::createVestingSchedules: Empty Data");
require(
_beneficiaries.length == _amounts.length,
"VestingContract::createVestingSchedules: Array lengths do not match"
);
bool result = true;
for(uint i = 0; i < _beneficiaries.length; i++) {
address beneficiary = _beneficiaries[i];
uint256 amount = _amounts[i];
_createVestingSchedule(beneficiary, amount);
}
return result;
}
/**
* @notice Create a new vesting schedule
* @notice A transfer is used to bring tokens into the VestingDepositAccount so pre-approval is required
* @param _beneficiary beneficiary of the vested tokens
* @param _amount amount of tokens (in wei)
*/
function createVestingSchedule(address _beneficiary, uint256 _amount) external returns (bool) {
require(msg.sender == owner, "VestingContract::createVestingSchedule: Only Owner");
return _createVestingSchedule(_beneficiary, _amount);
}
/**
* @notice Transfers ownership role
* @notice Changes the owner of this contract to a new address
* @dev Only owner
* @param _newOwner beneficiary to vest remaining tokens to
*/
function transferOwnership(address _newOwner) external {
require(msg.sender == owner, "VestingContract::transferOwnership: Only owner");
owner = _newOwner;
}
/**
* @notice Draws down any vested tokens due
* @dev Must be called directly by the beneficiary assigned the tokens in the schedule
*/
function drawDown() nonReentrant external returns (bool) {
return _drawDown(msg.sender);
}
// Accessors
/**
* @notice Vested token balance for a beneficiary
* @dev Must be called directly by the beneficiary assigned the tokens in the schedule
* @return _tokenBalance total balance proxied via the ERC20 token
*/
function tokenBalance() external view returns (uint256) {
return token.balanceOf(address(this));
}
/**
* @notice Vesting schedule and associated data for a beneficiary
* @dev Must be called directly by the beneficiary assigned the tokens in the schedule
* @return _amount
* @return _totalDrawn
* @return _lastDrawnAt
* @return _remainingBalance
*/
function vestingScheduleForBeneficiary(address _beneficiary)
external view
returns (uint256 _amount, uint256 _totalDrawn, uint256 _lastDrawnAt, uint256 _remainingBalance) {
return (
vestedAmount[_beneficiary],
totalDrawn[_beneficiary],
lastDrawnAt[_beneficiary],
vestedAmount[_beneficiary].sub(totalDrawn[_beneficiary])
);
}
/**
* @notice Draw down amount currently available (based on the block timestamp)
* @param _beneficiary beneficiary of the vested tokens
* @return _amount tokens due from vesting schedule
*/
function availableDrawDownAmount(address _beneficiary) external view returns (uint256 _amount) {
return _availableDrawDownAmount(_beneficiary);
}
/**
* @notice Balance remaining in vesting schedule
* @param _beneficiary beneficiary of the vested tokens
* @return _remainingBalance tokens still due (and currently locked) from vesting schedule
*/
function remainingBalance(address _beneficiary) external view returns (uint256) {
return vestedAmount[_beneficiary].sub(totalDrawn[_beneficiary]);
}
// Internal
function _createVestingSchedule(address _beneficiary, uint256 _amount) internal returns (bool) {
require(_beneficiary != address(0), "VestingContract::createVestingSchedule: Beneficiary cannot be empty");
require(_amount > 0, "VestingContract::createVestingSchedule: Amount cannot be empty");
// Ensure one per address
require(vestedAmount[_beneficiary] == 0, "VestingContract::createVestingSchedule: Schedule already in flight");
vestedAmount[_beneficiary] = _amount;
// Vest the tokens into the deposit account and delegate to the beneficiary
require(
token.transferFrom(msg.sender, address(this), _amount),
"VestingContract::createVestingSchedule: Unable to escrow tokens"
);
emit ScheduleCreated(_beneficiary);
return true;
}
function _drawDown(address _beneficiary) internal returns (bool) {
require(vestedAmount[_beneficiary] > 0, "VestingContract::_drawDown: There is no schedule currently in flight");
uint256 amount = _availableDrawDownAmount(_beneficiary);
require(amount > 0, "VestingContract::_drawDown: No allowance left to withdraw");
// Update last drawn to now
lastDrawnAt[_beneficiary] = _getNow();
// Increase total drawn amount
totalDrawn[_beneficiary] = totalDrawn[_beneficiary].add(amount);
// Safety measure - this should never trigger
require(
totalDrawn[_beneficiary] <= vestedAmount[_beneficiary],
"VestingContract::_drawDown: Safety Mechanism - Drawn exceeded Amount Vested"
);
// Issue tokens to beneficiary
require(token.transfer(_beneficiary, amount), "VestingContract::_drawDown: Unable to transfer tokens");
emit DrawDown(_beneficiary, amount);
return true;
}
function _getNow() internal view returns (uint256) {
return block.timestamp;
}
function _availableDrawDownAmount(address _beneficiary) internal view returns (uint256 _amount) {
// Cliff Period
if (_getNow() <= start.add(cliffDuration)) {
// the cliff period has not ended, no tokens to draw down
return 0;
}
// Schedule complete
if (_getNow() > end) {
return vestedAmount[_beneficiary].sub(totalDrawn[_beneficiary]);
}
// Schedule is active
// Work out when the last invocation was
uint256 timeLastDrawnOrStart = lastDrawnAt[_beneficiary] == 0 ? start : lastDrawnAt[_beneficiary];
// Find out how much time has past since last invocation
uint256 timePassedSinceLastInvocation = _getNow().sub(timeLastDrawnOrStart);
// Work out how many due tokens - time passed * rate per second
uint256 drawDownRate = vestedAmount[_beneficiary].div(end.sub(start));
uint256 amount = timePassedSinceLastInvocation.mul(drawDownRate);
return amount;
}
}
{
"compilationTarget": {
"LinearVesting.sol": "LinearVesting"
},
"evmVersion": "istanbul",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs"
},
"optimizer": {
"enabled": true,
"runs": 200
},
"remappings": []
}
[{"inputs":[{"internalType":"contract IERC20","name":"_token","type":"address"},{"internalType":"uint256","name":"_start","type":"uint256"},{"internalType":"uint256","name":"_end","type":"uint256"},{"internalType":"uint256","name":"_cliffDurationInSecs","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_beneficiary","type":"address"},{"indexed":true,"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"DrawDown","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_beneficiary","type":"address"}],"name":"ScheduleCreated","type":"event"},{"inputs":[{"internalType":"address","name":"_beneficiary","type":"address"}],"name":"availableDrawDownAmount","outputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cliffDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_beneficiary","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"createVestingSchedule","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_beneficiaries","type":"address[]"},{"internalType":"uint256[]","name":"_amounts","type":"uint256[]"}],"name":"createVestingSchedules","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"drawDown","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"end","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"lastDrawnAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_beneficiary","type":"address"}],"name":"remainingBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"start","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"totalDrawn","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"vestedAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_beneficiary","type":"address"}],"name":"vestingScheduleForBeneficiary","outputs":[{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"uint256","name":"_totalDrawn","type":"uint256"},{"internalType":"uint256","name":"_lastDrawnAt","type":"uint256"},{"internalType":"uint256","name":"_remainingBalance","type":"uint256"}],"stateMutability":"view","type":"function"}]