Keep Network

1/// @title TokenGrant
2/// @notice A token grant contract for a specified standard ERC20Burnable token.
3/// Has additional functionality to stake delegate/undelegate token grants.
4/// Tokens are granted to the grantee via unlocking scheme and can be
5/// withdrawn gradually based on the unlocking schedule cliff and unlocking duration.
6/// Optionally grant can be revoked by the token grant manager.
7contract TokenGrant {
8    using SafeMath for uint256;
9    using UnlockingSchedule for uint256;
10    using SafeERC20 for ERC20Burnable;
11    using BytesLib for bytes;
12    using AddressArrayUtils for address[];
13​
14    event TokenGrantCreated(uint256 id);
15    event TokenGrantWithdrawn(uint256 indexed grantId, uint256 amount);
16    event TokenGrantStaked(
17        uint256 indexed grantId,
18        uint256 amount,
19        address operator
20    );
21    event TokenGrantRevoked(uint256 id);
22​
23    event StakingContractAuthorized(
24        address indexed grantManager,
25        address stakingContract
26    );
27​
28    struct Grant {
29        address grantManager; // Token grant manager.
30        address grantee; // Address to which granted tokens are going to be withdrawn.
31        uint256 revokedAt; // Timestamp at which grant was revoked by the grant manager.
32        uint256 revokedAmount; // The number of tokens revoked from the grantee.
33        uint256 revokedWithdrawn; // The number of tokens returned to the grant creator.
34        bool revocable; // Whether grant manager can revoke the grant.
35        uint256 amount; // Amount of tokens to be granted.
36        uint256 duration; // Duration in seconds of the period in which the granted tokens will unlock.
37        uint256 start; // Timestamp at which the linear unlocking schedule will start.
38        uint256 cliff; // Timestamp before which no tokens will be unlocked.
39        uint256 withdrawn; // Amount that was withdrawn to the grantee.
40        uint256 staked; // Amount that was staked by the grantee.
41        GrantStakingPolicy stakingPolicy;
42    }
43​
44    uint256 public numGrants;
45​
46    ERC20Burnable public token;
47​
48    // Staking contracts authorized by the given grant manager.
49    // grant manager -> staking contract -> authorized?
50    mapping(address => mapping(address => bool)) internal stakingContracts;
51​
52    // Token grants.
53    mapping(uint256 => Grant) public grants;
54​
55    // Token grants stakes.
56    mapping(address => TokenGrantStake) public grantStakes;
57​
58    // Mapping of token grant IDs per particular address
59    // involved in a grant as a grantee or as a grant manager.
60    mapping(address => uint256[]) public grantIndices;
61​
62    // Token grants balances. Sum of all granted tokens to a grantee.
63    // This includes granted tokens that are already unlocked and
64    // available to be withdrawn to the grantee
65    mapping(address => uint256) public balances;
66​
67    // Mapping of operator addresses per particular grantee address.
68    mapping(address => address[]) public granteesToOperators;
69​
70    /// @notice Creates a token grant contract for a provided Standard ERC20Burnable token.
71    /// @param _tokenAddress address of a token that will be linked to this contract.
72    constructor(address _tokenAddress) public {
73        require(_tokenAddress != address(0x0), "Token address can't be zero.");
74        token = ERC20Burnable(_tokenAddress);
75    }
76​
77    /// @notice Used by grant manager to authorize staking contract with the given
78    /// address.
79    function authorizeStakingContract(address _stakingContract) public {
80        require(
81            _stakingContract != address(0x0),
82            "Staking contract address can't be zero"
83        );
84        stakingContracts[msg.sender][_stakingContract] = true;
85        emit StakingContractAuthorized(msg.sender, _stakingContract);
86    }
87​
88    /// @notice Gets the amount of granted tokens to the specified address.
89    /// @param _owner The address to query the grants balance of.
90    /// @return An uint256 representing the grants balance owned by the passed address.
91    function balanceOf(address _owner) public view returns (uint256 balance) {
92        return balances[_owner];
93    }
94​
95    /// @notice Gets the stake balance of the specified address.
96    /// @param _address The address to query the balance of.
97    /// @return An uint256 representing the amount staked by the passed address.
98    function stakeBalanceOf(address _address)
99        public
100        view
101        returns (uint256 balance)
102    {
103        for (uint256 i = 0; i < grantIndices[_address].length; i++) {
104            uint256 id = grantIndices[_address][i];
105            balance += grants[id].staked;
106        }
107        return balance;
108    }
109​
110    /// @notice Gets grant by ID. Returns only basic grant data.
111    /// If you need unlocking schedule for the grant you must call `getGrantUnlockingSchedule()`
112    /// This is to avoid Ethereum `Stack too deep` issue described here:
113    /// https://forum.ethereum.org/discussion/2400/error-stack-too-deep-try-removing-local-variables
114    /// @param _id ID of the token grant.
115    /// @return amount The amount of tokens the grant provides.
116    /// @return withdrawn The amount of tokens that have already been withdrawn
117    ///                   from the grant.
118    /// @return staked The amount of tokens that have been staked from the grant.
119    /// @return revoked A boolean indicating whether the grant has been revoked,
120    //                 which is to say that it is no longer unlocking.
121    // @return grantee The grantee of grant.
122    function getGrant(uint256 _id)
123        public
124        view
125        returns (
126            uint256 amount,
127            uint256 withdrawn,
128            uint256 staked,
129            uint256 revokedAmount,
130            uint256 revokedAt,
131            address grantee
132        )
133    {
134        return (
135            grants[_id].amount,
136            grants[_id].withdrawn,
137            grants[_id].staked,
138            grants[_id].revokedAmount,
139            grants[_id].revokedAt,
140            grants[_id].grantee
141        );
142    }
143​
144    /// @notice Gets grant unlocking schedule by grant ID.
145    /// @param _id ID of the token grant.
146    /// @return grantManager The address designated as the manager of the grant,
147    ///                      which is the only address that can revoke this grant.
148    /// @return duration The duration, in seconds, during which the tokens will
149    ///                  unlocking linearly.
150    /// @return start The start time, as a timestamp comparing to `now`.
151    /// @return cliff The timestamp, before which none of the tokens in the grant
152    ///               will be unlocked, and after which a linear amount based on
153    ///               the time elapsed since the start will be unlocked.
154    /// @return policy The address of the grant's staking policy.
155    function getGrantUnlockingSchedule(uint256 _id)
156        public
157        view
158        returns (
159            address grantManager,
160            uint256 duration,
161            uint256 start,
162            uint256 cliff,
163            address policy
164        )
165    {
166        return (
167            grants[_id].grantManager,
168            grants[_id].duration,
169            grants[_id].start,
170            grants[_id].cliff,
171            address(grants[_id].stakingPolicy)
172        );
173    }

Solidity Contracts

JavaScript Tests