​

VestingToken

​

State Variables

​

ONE

uint256 internal constant ONE = 1 ether;

​

underlyingToken

ERC20Upgradeable public underlyingToken;

​

manager

IFeeManager public manager;

​

_decimals

uint8 internal _decimals;

​

_startingSupply

uint256 internal _startingSupply;

​

_importedClaimedSupply

uint256 internal _importedClaimedSupply;

​

_milestones

Milestone[] internal _milestones;

​

_lastReachedMilestone

uint256 internal _lastReachedMilestone;

​

_metadata

mapping(address => Metadata) internal _metadata;

​

Functions

​

constructor

constructor();

​

initialize

• underlyingTokenAddress cannot be the zero address.
• timestamps must be given in ascending order.
• percentages must be given in ascending order and the last one must always be 1 eth, where 1 eth equals to 100%.
• 2 percentages may have the same value as long as they are followed by a Ramp.Linear Milestone.*

function initialize(
    string calldata name,
    string calldata symbol,
    address underlyingTokenAddress,
    Milestone[] calldata milestonesArray
)
    external
    override
    initializer;

​

decimals

function decimals() public view virtual override returns (uint8);

​

addRecipient

• msg.sender must have approved this contract an amount of underlyingToken greater or equal than amount.

function addRecipient(address recipient, uint256 amount) external nonReentrant;

​

addRecipients

• recipients and amounts must have the same length.
• msg.sender must have approved this contract an amount of underlyingToken greater or equal than the sum of all of the amounts.

function addRecipients(
    address[] calldata recipients,
    uint256[] calldata amounts,
    uint256 totalAmount
)
    external
    nonReentrant;

​

importRecipient

• unlocked must be less than or equal to this contracts unlockedPercentage.
• claimableAmountOfImport must be less than or equal than the amount that would be claimable given the values of amount and percentage.
• msg.sender must have approved this contract an amount of underlyingToken greater or equal than amount.*

function importRecipient(
    address recipient,
    uint256 amount,
    uint256 claimableAmountOfImport,
    uint256 unlocked
)
    external
    nonReentrant;

​

importRecipients

• recipients, amounts, and claimableAmountsOfImport must have the same length.
• unlocked must be less than or equal to this contracts unlockedPercentage.
• each value in claimableAmountsOfImport must be less than or equal than the amount that would be claimable given the values in amounts and percentages.
• msg.sender must have approved this contract an amount of underlyingToken greater or equal than the sum of all of the amounts.*

function importRecipients(
    address[] calldata recipients,
    uint256[] calldata amounts,
    uint256[] calldata claimableAmountsOfImport,
    uint256 totalAmount,
    uint256 unlocked
)
    external
    nonReentrant;

​

exportRecipient

function exportRecipient(address recipient) external view returns (address, uint256, uint256, uint256);

​

exportRecipients

function exportRecipients(address[] calldata recipients)
    external
    view
    returns (address[] calldata, uint256[] memory, uint256[] memory, uint256);

​

updateLastReachedMilestone

function updateLastReachedMilestone(uint256 startIndex) public;

​

unlockedPercentage

function unlockedPercentage() public view returns (uint256);

​

claimedSupply

function claimedSupply() external view returns (uint256);

​

claimableSupply

function claimableSupply() public view returns (uint256);

​

lockedSupply

function lockedSupply() external view returns (uint256);

​

claimedBalanceOf

function claimedBalanceOf(address account) external view returns (uint256);

​

claimableBalanceOf

function claimableBalanceOf(address account) public view returns (uint256);

​

lockedBalanceOf

function lockedBalanceOf(address account) external view returns (uint256);

​

claim

function claim() external payable nonReentrant;

​

burn

function burn(uint256 amount) public payable;

​

transfer

function transfer(address to, uint256 amount) public override returns (bool);

​

transferFrom

function transferFrom(address from, address to, uint256 amount) public override returns (bool);

​

milestones

function milestones() external view returns (Milestone[] memory);

​

metadataOf

function metadataOf(address account) external view returns (Metadata memory metadata);

​

transferFeeData

function transferFeeData() external view returns (address, uint64);

​

claimFeeData

function claimFeeData() external view returns (address, uint64);

​

_updateMetadataAndTransfer

1. claimableAmount = (unlockedPercentage * startingAmount) / ONE - claimedAmount When there’s a transfer of an amount, we transfer both locked and unlocked tokens so the claimableAmountAfterTransfer will look like:
2. claimableAmountAfterTransfer = claimableAmount ± claimableAmountOfTransfer Notice the ± symbol is because the sender’s claimableAmount is reduced while the receiver’s claimableAmount is increased.
3. claimableAmountOfTransfer = claimableAmountOfSender * amountOfTransfer / balanceOfSender We can expand 3) into:
4. claimableAmountOfTransfer = (unlockedPercentage * ((startingAmountOfSender * amountOfTransfer) / balanceOfSender)) / ONE) - ((claimedAmountOfSender * amountOfTransfer) / balanceOfSender) Notice how the structure of the equation is the same as 1) and 2 new variables can be created to calculate claimableAmountOfTransfer a) startingAmountOfTransfer = (startingAmountOfSender * amountOfTransfer) / balanceOfSender b) claimedAmountOfTransfer = (claimedAmountOfSender * amountOfTransfer) / balanceOfSender Replacing claimableAmountOfTransfer in equation 2) and expanding it, we get:
5. claimableAmountAfterTransfer = ((unlockedPercentage * startingAmount) / ONE - claimedAmount) ± ((unlockedPercentage * startingAmountOfTransfer) / ONE - claimedAmountOfTransfer) We can group similar variables like this:
6. claimableAmountAfterTransfer = (unlockedPercentage * (startingAmount - startingAmountOfTransfer)) / ONE - (claimedAmount - claimedAmountOfTransfer) This shows that the new values to calculate claimableAmountAfterTransfer if we want to continue using the equation 1) are: c) startingAmountAfterTransfer = startingAmount ± (startingAmountOfSender * amountOfTransfer) / balanceOfSender d) claimedAmountAfterTransfer = claimedAmount ± (claimedAmountOfSender * amountOfTransfer) / balanceOfSender Since these values depend linearly on the value of amountOfTransfer, and the fee is a fraction of the amount, we can just factor in the transferFeePercentage to get the values for the transfer to the feeCollector. e) startingAmountOfFee = (startingAmountOfTransfer * transferFeePercentage) / ONE; f) claimedAmountOfFee = (claimedAmountOfTransfer * transferFeePercentage) / ONE; If we look at equation 1) and set unlockedPercentage to ONE, then claimableAmount must equal to the balance. Therefore the relation between startingAmount, claimedAmount, and balance should be: g) startingAmount = claimedAmount + balance Since we want to minimize independent rounding in all of the startingAmounts, and claimedAmounts we will calculate the claimedAmount using multiplication and division as shown in b) and f), and the startingAmount can be derived using a simple subtraction. With this we ensure that if there’s a rounding down in the divisions, we won’t be leaving any token locked.*

function _updateMetadataAndTransfer(address from, address to, uint256 amount, bool isTransfer) internal;

​

_setupMilestones

function _setupMilestones(Milestone[] calldata milestonesArray) internal;

​

_tryFetchDecimals

function _tryFetchDecimals() internal view returns (uint8);

​

_getBalanceOfThis

function _getBalanceOfThis() internal view returns (uint256 returnedBalance);

​

_claimedAmount

function _claimedAmount(
    uint256 amount,
    uint256 claimableAmountOfImport,
    uint256 unlocked
)
    internal
    pure
    returns (uint256);

​

_claimableAmount

function _claimableAmount(uint256 startingAmount, uint256 claimedAmount) internal view returns (uint256);

​

_processClaimFee

function _processClaimFee() private;

​

Events

​

Claim

event Claim(address indexed account, uint256 amount);

​

Burn

event Burn(address indexed account, uint256 amount);

​

MilestoneReached

event MilestoneReached(uint256 indexed milestoneIndex);

​

Structs

​

Metadata

struct Metadata {
    uint256 claimedAmountAfterTransfer;
    uint256 claimedBalance;
}