vestinglib 0.1.4

A library used to compute the vesting math needed for a Solana program
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use crate::types::{VestingState, VestingTerms};
use crate::VestingError;
use crate::{Vesting, VestingTimeline};

/// The parameters needed to initialize the vesting
/// Library is inspired by https://github.com/abdelhamidbakhta/token-vesting-contracts/blob/main/contracts/TokenVesting.sol
pub struct VestingInitParams {
    /// The vesting UNIX start time in seconds
    pub start_unix: u64,
    /// The duration of the cliff in seconds
    pub cliff_seconds: u64,
    /// The duration of overall grant (must be >= cliff)
    pub duration_seconds: u64,
    /// The duration of a slice period for the vesting in seconds
    pub seconds_per_slice: u64,
    /// The total number of tokens issued for the duration of the grant
    pub grant_token_amount: u64,
    /// The number of tokens already issued to the user (<= grant_token_amount)
    pub already_issued_token_amount: u64,
    /// Marks if the grant was revoked by an admin
    pub revoked: bool,
}

const THIRTY_DAYS: u64 = 2592000;

pub trait CanInitialize {
    /// Initializes a new instance from a configuration object
    fn from_init_params(params: &VestingInitParams) -> Result<Self, VestingError>
    where
        Self: Sized;
}

impl CanInitialize for VestingTimeline {
    fn from_init_params(params: &VestingInitParams) -> Result<Self, VestingError>
    where
        Self: Sized,
    {
        let VestingInitParams {
            cliff_seconds,
            duration_seconds,
            seconds_per_slice,
            start_unix,
            ..
        } = *params;
        if duration_seconds < cliff_seconds {
            return Err(VestingError::ConfigurationError(
                "Grant duration is less than the cliff",
            ));
        }
        if seconds_per_slice <= 0 || seconds_per_slice > THIRTY_DAYS {
            return Err(VestingError::ConfigurationError(
                "Slice must be > 0 and <= 30 days",
            ));
        }
        if seconds_per_slice > duration_seconds {
            return Err(VestingError::ConfigurationError(
                "Slice must < than grant length",
            ));
        }
        Ok(Self {
            cliff_seconds,
            start_unix,
            duration_seconds,
            seconds_per_slice,
        })
    }
}

impl CanInitialize for VestingTerms {
    fn from_init_params(params: &VestingInitParams) -> Result<Self, VestingError>
    where
        Self: Sized,
    {
        let timeline = VestingTimeline::from_init_params(params)?;
        Ok(Self {
            timeline,
            amount: params.grant_token_amount,
        })
    }
}

impl CanInitialize for VestingState {
    fn from_init_params(params: &VestingInitParams) -> Result<Self, VestingError>
    where
        Self: Sized,
    {
        let VestingInitParams {
            revoked,
            already_issued_token_amount,
            grant_token_amount,
            ..
        } = *params;
        if already_issued_token_amount > grant_token_amount {
            return Err(VestingError::ConfigurationError(
                "Tokens issued are greater than the total grant",
            ));
        }
        Ok(VestingState {
            revoked,
            amount_already_issued: already_issued_token_amount,
        })
    }
}

impl CanInitialize for Vesting {
    fn from_init_params(params: &VestingInitParams) -> Result<Self, VestingError>
    where
        Self: Sized,
    {
        let state = VestingState::from_init_params(params)?;
        let terms = VestingTerms::from_init_params(params)?;
        Ok(Self { state, terms })
    }
}