hylo-core 0.5.0

Core protocol data types, math, and utilities.
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

use anchor_lang::prelude::*;
use fix::prelude::*;

use crate::error::CoreError::{
  YieldHarvestAllocation, YieldHarvestConfigValidation,
};
use crate::fee_controller::FeeExtract;

/// Captures yield harvest configuration as two basis point values:
#[derive(
  Copy, Clone, PartialEq, InitSpace, AnchorSerialize, AnchorDeserialize,
)]
pub struct YieldHarvestConfig {
  pub allocation: UFixValue64,
  pub fee: UFixValue64,
}

impl YieldHarvestConfig {
  pub fn init(
    &mut self,
    allocation: UFixValue64,
    fee: UFixValue64,
  ) -> Result<()> {
    self.allocation = allocation;
    self.fee = fee;
    Ok(())
  }

  /// Percentage of accrued yield to qualify for harvest
  pub fn allocation(&self) -> Result<UFix64<N4>> {
    self.allocation.try_into()
  }

  /// Percentage of harvest allocation to divert to treasury
  pub fn fee(&self) -> Result<UFix64<N4>> {
    self.fee.try_into()
  }

  /// Multiplies allocation bps by amount of harvestable stablecoin.
  pub fn apply_allocation(&self, stablecoin: UFix64<N6>) -> Result<UFix64<N6>> {
    let allocation = self.allocation()?;
    stablecoin
      .mul_div_floor(allocation, UFix64::one())
      .ok_or(YieldHarvestAllocation.into())
  }

  /// Applies configuration to the given amount of stablecoin to harvest.
  pub fn apply_fee(&self, stablecoin: UFix64<N6>) -> Result<FeeExtract<N6>> {
    let fee = self.fee()?;
    let extract = FeeExtract::new(fee, stablecoin)?;
    Ok(extract)
  }

  /// Yield harvest fee and allocation parse to bps and are less than or equal
  /// to 100%
  pub fn validate(&self) -> Result<Self> {
    let fee: UFix64<N4> = self.fee.try_into()?;
    let allocation: UFix64<N4> = self.allocation.try_into()?;
    let one = UFix64::new(10000);
    let zero = UFix64::zero();
    if fee > zero && fee <= one && allocation > zero && allocation <= one {
      Ok(*self)
    } else {
      Err(YieldHarvestConfigValidation.into())
    }
  }
}

/// Records epoch harvest information for off-chain consumers.
#[derive(Copy, Clone, InitSpace, AnchorSerialize, AnchorDeserialize)]
pub struct HarvestCache {
  pub epoch: u64,
  pub stability_pool_cap: UFixValue64,
  pub stablecoin_to_pool: UFixValue64,
}

impl HarvestCache {
  pub fn init(&mut self, epoch: u64) -> Result<()> {
    self.epoch = epoch;
    self.stability_pool_cap = UFix64::<N6>::zero().into();
    self.stablecoin_to_pool = UFix64::<N6>::zero().into();
    Ok(())
  }

  pub fn update(
    &mut self,
    stability_pool_cap: UFix64<N6>,
    stablecoin_to_pool: UFix64<N6>,
    epoch: u64,
  ) -> Result<()> {
    self.epoch = epoch;
    self.stability_pool_cap = stability_pool_cap.into();
    self.stablecoin_to_pool = stablecoin_to_pool.into();
    Ok(())
  }

  /// Returns true if the cache is stale (harvest needed for current epoch).
  #[must_use]
  pub fn is_stale(&self, current_epoch: u64) -> bool {
    self.epoch < current_epoch
  }
}