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
use ethers::types::U256;
use eyre::Result;
use fixedpointmath::{fixed, FixedPoint};
use crate::State;
impl State {
/// Calculates the curve fee paid when opening longs with a given base amount.
///
/// The open long curve fee, `$\Phi_{c,ol}(\Delta x)$`, is paid in bonds and
/// is given by:
///
/// ```math
/// \Phi_{c,ol}(\Delta x) = \phi_c
/// \cdot \left( \tfrac{1}{p} - 1 \right) \cdot \Delta x
/// ```
pub fn open_long_curve_fee(&self, base_amount: FixedPoint<U256>) -> Result<FixedPoint<U256>> {
// NOTE: Round up to overestimate the curve fee.
Ok(self
.curve_fee()
.mul_up(fixed!(1e18).div_up(self.calculate_spot_price()?) - fixed!(1e18))
.mul_up(base_amount))
}
/// Calculates the governance fee paid when opening longs with a given base
/// amount.
///
/// The open long governance fee, `$\Phi_{g,ol}(\Delta x)$`, is paid in base
/// and is given by:
///
/// ```math
/// \Phi_{g,ol}(\Delta x) = \phi_g \cdot p \cdot \Phi_{c,ol}(\Delta x)
/// ```
pub fn open_long_governance_fee(
&self,
base_amount: FixedPoint<U256>,
maybe_curve_fee: Option<FixedPoint<U256>>,
) -> Result<FixedPoint<U256>> {
let curve_fee = match maybe_curve_fee {
Some(maybe_curve_fee) => maybe_curve_fee,
None => self.open_long_curve_fee(base_amount)?,
};
// NOTE: Round down to underestimate the governance curve fee.
Ok(curve_fee
.mul_down(self.governance_lp_fee())
.mul_down(self.calculate_spot_price()?))
}
/// Calculates the curve fee paid when closing longs for a given bond
/// amount.
///
/// The the close long curve fee, `$\Phi_{c,cl}(\Delta y)$`, is paid in
/// shares and is given by:
///
/// ```math
/// \Phi_{c,cl}(\Delta y) =
/// \frac{\phi_c \cdot (1 - p) \cdot \Delta y \cdot t}{c}
/// ```
///
/// where `$t$` is the normalized time remaining until bond maturity.
pub fn close_long_curve_fee(
&self,
bond_amount: FixedPoint<U256>,
maturity_time: U256,
current_time: U256,
) -> Result<FixedPoint<U256>> {
let normalized_time_remaining =
self.calculate_normalized_time_remaining(maturity_time, current_time);
// NOTE: Round up to overestimate the curve fee.
Ok(self
.curve_fee()
.mul_up(fixed!(1e18) - self.calculate_spot_price()?)
.mul_up(bond_amount)
.mul_div_up(normalized_time_remaining, self.vault_share_price()))
}
/// Calculates the flat fee paid when closing longs for a given bond amount.
///
/// The close long flat fee, `$\Phi_{f,cl}(\Delta y)$`, is paid in shares
/// and is given by:
///
/// ```math
/// \Phi_{f,cl}(\Delta y) = \frac{\Delta y \cdot (1 - t) \cdot \phi_f)}{c}
/// ```
///
/// where `$t$` is the normalized time remaining until bond maturity.
pub fn close_long_flat_fee(
&self,
bond_amount: FixedPoint<U256>,
maturity_time: U256,
current_time: U256,
) -> FixedPoint<U256> {
let normalized_time_remaining =
self.calculate_normalized_time_remaining(maturity_time, current_time);
// NOTE: Round up to overestimate the flat fee.
bond_amount
.mul_div_up(
fixed!(1e18) - normalized_time_remaining,
self.vault_share_price(),
)
.mul_up(self.flat_fee())
}
}