lockup 1.1.2

Saber token lockup.
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

//! Utility functions for calculating unlock schedules for a release account.

use crate::Release;
use num_traits::ToPrimitive;

/// Computes the amount of tokens available for withdrawal for a given [Release].
pub fn available_for_withdrawal(release: &Release, current_ts: i64) -> u64 {
    std::cmp::min(outstanding_released(release, current_ts), balance(release))
}

/// The amount of funds currently in the vault.
fn balance(release: &Release) -> u64 {
    release.outstanding
}

/// The amount of outstanding locked tokens released.
fn outstanding_released(release: &Release, current_ts: i64) -> u64 {
    total_released(release, current_ts)
        .checked_sub(withdrawn_amount(release))
        .unwrap()
}

/// Returns the amount withdrawn from this release account.
fn withdrawn_amount(release: &Release) -> u64 {
    release
        .start_balance
        .checked_sub(release.outstanding)
        .unwrap()
}

/// Returns the total released amount up to the given ts, assuming zero
/// withdrawals and zero funds sent to other programs.
fn total_released(release: &Release, current_ts: i64) -> u64 {
    if current_ts < release.start_ts {
        0
    } else if current_ts >= release.end_ts {
        release.start_balance
    } else {
        linear_unlock(release, current_ts).unwrap()
    }
}

/// Computes the linear unlock.
fn linear_unlock(release: &Release, current_ts: i64) -> Option<u64> {
    // Signed division not supported.
    let current_ts = current_ts as u64;
    let start_ts = release.start_ts as u64;
    let end_ts = release.end_ts as u64;

    if current_ts <= start_ts {
        return Some(0);
    }

    if current_ts >= end_ts {
        return Some(release.start_balance);
    }

    (current_ts.checked_sub(start_ts)? as u128)
        .checked_mul(release.start_balance.into())?
        .checked_div(end_ts.checked_sub(start_ts)?.into())?
        .to_u64()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_linear_unlock_not_started() {
        let release = &mut Release::default();
        release.start_ts = 100_000;
        release.end_ts = 200_000;
        release.start_balance = 1_000_000;
        let amt = linear_unlock(release, 90_000).unwrap();
        assert_eq!(amt, 0);
    }

    #[test]
    fn test_linear_unlock_finished() {
        let release = &mut Release::default();
        release.start_ts = 100_000;
        release.end_ts = 200_000;
        release.start_balance = 1_000_000;
        let amt = linear_unlock(release, 290_000).unwrap();
        assert_eq!(amt, 1_000_000);
    }

    #[test]
    fn test_linear_unlock_halfway() {
        let release = &mut Release::default();
        release.start_ts = 100_000;
        release.end_ts = 200_000;
        release.start_balance = 1_000_000;
        let amt = linear_unlock(release, 150_000).unwrap();
        assert_eq!(amt, 500_000);
    }
}