use crate::types::*;
use bytemuck::{Pod, Zeroable};
use super::schedule::*;
use super::state::*;
use crate::system::*;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum PoolError {
ScheduleFailed,
PoolInactive,
BalanceExceeded,
EpochInvalid,
StakeInvalid,
StakeActive,
StakeNotActive,
ZeroShares,
ZeroStake,
ZeroCommission,
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct StakingPool<const N: usize> {
pub shares: ShareAmount,
pub stake: Coin<TAPE>,
pub rewards: Coin<TAPE>,
pub commission: Coin<TAPE>,
pub commission_rate: BasisPoints,
pub schedule: PoolSchedule<N>,
}
unsafe impl<const N: usize> Zeroable for StakingPool<N> {}
unsafe impl<const N: usize> Pod for StakingPool<N> {}
impl<const N: usize> StakingPool<N> {
pub fn new(commission_rate: BasisPoints) -> Self {
Self {
shares: ShareAmount::zero(),
stake: Coin::<TAPE>::zero(),
rewards: Coin::<TAPE>::zero(),
commission: Coin::<TAPE>::zero(),
commission_rate,
schedule: PoolSchedule::new(),
}
}
pub fn get_current_rate(&self) -> ExchangeRate {
debug_assert!(self.shares.is_zero() == self.stake.is_zero());
if self.shares.is_zero() {
ExchangeRate::flat()
} else {
ExchangeRate::new(
self.stake.into(),
self.shares.into()
)
}
}
pub fn calculate_stake_at(&self, epoch: EpochNumber) -> Coin<TAPE> {
let exchange_rate = self.get_current_rate();
let incoming = self.schedule.stake_sum(epoch);
let outgoing = self.schedule.cancel_sum(epoch);
let net_additions = incoming.saturating_sub(outgoing);
let outgoing_shares = self.schedule.unstake_sum(epoch);
let outgoing_tokens = exchange_rate
.convert_to_tape_amount(outgoing_shares.into())
.into();
self.stake
.saturating_add(net_additions)
.saturating_sub(outgoing_tokens)
}
pub fn claim_commission(&mut self) -> Result<Coin<TAPE>, PoolError> {
if self.commission.is_zero() {
return Err(PoolError::ZeroCommission);
}
let amount = self.commission;
self.commission = TAPE::zero();
Ok(amount)
}
pub fn advance_epoch(
&mut self,
current_epoch: EpochNumber,
rewards_earned: Coin<TAPE>,
) -> Result<(), PoolError> {
if let Some(commission_rate) = self.schedule.take_commission_change(current_epoch) {
self.commission_rate = commission_rate;
}
let snapshot = self.get_current_rate();
self.process_scheduled_reductions(current_epoch, snapshot)?;
self.process_scheduled_additions(current_epoch, snapshot)?;
if rewards_earned > TAPE::zero() {
if self.stake.is_zero() {
return Err(PoolError::StakeInvalid);
}
let commission_cut = (
rewards_earned.as_u128() * self.commission_rate.as_u128() / BasisPoints::MAX as u128
) as u64;
let rewards_net = rewards_earned.saturating_sub(commission_cut.into());
self.commission = self.commission.saturating_add(commission_cut.into());
self.rewards = self.rewards.saturating_add(rewards_net);
self.stake = self.stake.saturating_add(rewards_net);
}
Ok(())
}
pub fn stake_with_pool(
&mut self,
current_epoch: EpochNumber,
stake_amount: Coin<TAPE>,
) -> Result<StakedTape, PoolError> {
let activation_epoch = current_epoch + EpochNumber(2);
self.stake_with_pool_at(current_epoch, activation_epoch, stake_amount)
}
pub fn stake_with_pool_at(
&mut self,
current_epoch: EpochNumber,
activation_epoch: EpochNumber,
stake_amount: Coin<TAPE>,
) -> Result<StakedTape, PoolError> {
if stake_amount.is_zero() {
return Err(PoolError::ZeroStake);
}
let mut state = StakeState::new();
if activation_epoch == current_epoch {
debug_assert!(
current_epoch == EpochNumber(0),
"immediate activation is only safe at the bootstrap epoch",
);
let rate = self.get_current_rate();
let shares: ShareAmount = rate.convert_to_other_amount(stake_amount.into()).into();
self.stake = self.stake.saturating_add(stake_amount);
self.shares = self.shares.saturating_add(shares);
state.set_staked();
} else {
self.schedule
.stake(activation_epoch, stake_amount)
.map_err(|_| PoolError::ScheduleFailed)?;
}
Ok(StakedTape {
activation_epoch,
amount: stake_amount,
unlock_shares: ShareAmount::zero(),
state,
})
}
pub fn request_cancel(
&mut self,
stake: &mut StakedTape,
current_epoch: EpochNumber,
) -> Result<EpochNumber, PoolError> {
if !stake.is_staked() {
return Err(PoolError::StakeInvalid);
}
if stake.amount.is_zero() {
return Err(PoolError::StakeInvalid);
}
if stake.activation_epoch <= current_epoch {
return Err(PoolError::StakeActive);
}
let withdraw_epoch = stake.activation_epoch;
self.schedule
.cancel(withdraw_epoch, stake.amount)
.map_err(|_| PoolError::ScheduleFailed)?;
stake.set_withdrawing(withdraw_epoch);
Ok(withdraw_epoch)
}
pub fn request_withdraw(
&mut self,
stake: &mut StakedTape,
current_epoch: EpochNumber,
stake_activation_rate: ExchangeRate,
) -> Result<EpochNumber, PoolError> {
if !stake.is_staked() {
return Err(PoolError::StakeInvalid);
}
if stake.amount.is_zero() {
return Err(PoolError::StakeInvalid);
}
if stake.activation_epoch > current_epoch {
return Err(PoolError::StakeNotActive);
}
let withdraw_epoch = current_epoch + EpochNumber(2);
let shares : ShareAmount = stake_activation_rate
.convert_to_other_amount(stake.amount.into())
.into();
if shares.is_zero() {
return Err(PoolError::ZeroShares);
}
self.schedule
.unstake(withdraw_epoch, shares)
.map_err(|_| PoolError::ScheduleFailed)?;
stake.set_withdrawing(withdraw_epoch);
stake.set_unlock_shares(shares);
Ok(withdraw_epoch)
}
pub fn unstake_from_pool(
&mut self,
stake: &mut StakedTape,
current_epoch: EpochNumber,
owed_rewards: Coin<TAPE>,
) -> Result<Coin<TAPE>, PoolError> {
if !stake.is_withdrawing() {
return Err(PoolError::StakeInvalid);
}
let stake_withdraw_epoch = stake
.state
.withdraw_epoch()
.ok_or(PoolError::StakeInvalid)?;
if stake_withdraw_epoch > current_epoch {
return Err(PoolError::EpochInvalid);
}
if stake.amount.is_zero() {
return Err(PoolError::StakeInvalid);
}
if stake_withdraw_epoch <= stake.activation_epoch {
return Ok(TAPE::zero());
}
let pay = if owed_rewards > self.rewards {
self.rewards
} else {
owed_rewards
};
self.rewards = self.rewards
.saturating_sub(pay);
stake.set_withdrawn();
Ok(pay)
}
fn process_scheduled_additions(
&mut self, current_epoch: EpochNumber,
shapshot_rate: ExchangeRate,
) -> Result<(), PoolError> {
let incoming = self.schedule
.take_incoming(current_epoch);
let outgoing = self.schedule
.take_outgoing(current_epoch);
if outgoing > incoming {
return Err(PoolError::BalanceExceeded);
}
let net_added = incoming - outgoing;
if net_added > TAPE::zero() {
let incoming_shares = shapshot_rate
.convert_to_other_amount(net_added.into())
.into();
self.shares = self.shares.saturating_add(incoming_shares);
self.stake = self.stake.saturating_add(net_added);
}
Ok(())
}
fn process_scheduled_reductions(
&mut self,
current_epoch: EpochNumber,
shapshot_rate: ExchangeRate,
) -> Result<(), PoolError> {
let outgoing_shares = self.schedule
.take_outgoing_shares(current_epoch);
if outgoing_shares > self.shares {
return Err(PoolError::BalanceExceeded);
}
let net_removed = shapshot_rate
.convert_to_tape_amount(outgoing_shares.into())
.into();
if self.stake < net_removed {
return Err(PoolError::BalanceExceeded);
}
if outgoing_shares > ShareAmount::zero() {
self.shares = self.shares
.saturating_sub(outgoing_shares);
self.stake = self.stake
.saturating_sub(net_removed);
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
type TestPool = StakingPool<4>;
fn epoch(n: u64) -> EpochNumber { EpochNumber(n) }
fn tape(v: u64) -> Coin<TAPE> { TAPE(v) }
fn shares(v: u64) -> ShareAmount { ShareAmount(v) }
#[test]
fn new_ok() {
let p = TestPool::new(BasisPoints(1000));
assert_eq!(p.stake, TAPE::zero());
assert_eq!(p.shares, shares(0));
assert_eq!(p.commission_rate, BasisPoints(1000));
}
#[test]
fn stake_sched() {
let mut p = TestPool::new(BasisPoints(0));
let s = p.stake_with_pool(epoch(5), tape(700)).unwrap();
assert_eq!(s.activation_epoch, epoch(7));
assert_eq!(p.schedule.stake_sum(epoch(6)), tape(0));
assert_eq!(p.schedule.stake_sum(epoch(7)), tape(700));
}
#[test]
fn rate_empty_flat() {
let p = TestPool::new(BasisPoints(0));
assert_eq!(p.get_current_rate(), ExchangeRate::flat());
}
#[test]
fn cancel_after_active_err() {
let mut p = TestPool::new(BasisPoints(0));
let mut s = p.stake_with_pool(epoch(1), tape(700)).unwrap();
p.advance_epoch(epoch(1), tape(0)).unwrap();
p.advance_epoch(epoch(2), tape(0)).unwrap();
p.advance_epoch(epoch(3), tape(0)).unwrap();
let err = p.request_cancel(&mut s, epoch(3)).unwrap_err();
assert!(matches!(err, PoolError::StakeActive));
}
#[test]
fn withdraw_zero_amount_err() {
let mut p = TestPool::new(BasisPoints(0));
let mut s = StakedTape {
amount: tape(0),
activation_epoch: epoch(2),
unlock_shares: ShareAmount::zero(),
state: StakeState::new(),
};
let err = p.request_withdraw(&mut s, epoch(2), ExchangeRate::flat()).unwrap_err();
assert!(matches!(err, PoolError::StakeInvalid));
}
#[test]
fn advance_commission() {
let mut p = TestPool::new(BasisPoints(1000));
p.schedule.stake(epoch(1), tape(1_000)).unwrap();
p.advance_epoch(epoch(1), tape(0)).unwrap();
assert_eq!(p.stake, tape(1_000));
p.advance_epoch(epoch(2), tape(500)).unwrap();
assert_eq!(p.commission, tape(50));
assert_eq!(p.rewards, tape(450));
assert_eq!(p.stake, tape(1_450));
}
#[test]
fn adv_no_stake_err() {
let mut p = TestPool::new(BasisPoints(0));
let err = p.advance_epoch(epoch(1), tape(10)).unwrap_err();
assert!(matches!(err, PoolError::StakeInvalid));
}
#[test]
fn set_comm_next() {
let mut p = TestPool::new(BasisPoints(1000));
p.schedule.stake(epoch(1), tape(100)).unwrap();
p.advance_epoch(epoch(1), tape(0)).unwrap();
p.schedule.set_commission(epoch(4), BasisPoints(2000)).unwrap();
p.advance_epoch(epoch(3), tape(0)).unwrap();
assert_eq!(p.commission_rate, BasisPoints(1000));
p.advance_epoch(epoch(4), tape(0)).unwrap();
assert_eq!(p.commission_rate, BasisPoints(2000));
}
#[test]
fn process_pending() {
let mut p = TestPool::new(BasisPoints(0));
p.schedule.stake(epoch(1), tape(1000)).unwrap();
p.advance_epoch(epoch(1), tape(0)).unwrap();
let r1 = p.get_current_rate();
assert_eq!(p.stake, tape(1000));
assert_eq!(p.shares, r1.convert_to_other_amount(p.stake.into()).into());
}
#[test]
fn balance_calc() {
let mut p = TestPool::new(BasisPoints(0));
p.schedule.stake(epoch(1), tape(1000)).unwrap();
p.advance_epoch(epoch(1), tape(0)).unwrap();
p.schedule.stake(epoch(5), tape(600)).unwrap();
p.schedule.unstake(epoch(6), shares(200)).unwrap();
assert_eq!(p.calculate_stake_at(epoch(4)), tape(1000));
assert_eq!(p.calculate_stake_at(epoch(5)), tape(1600));
assert_eq!(p.calculate_stake_at(epoch(6)), tape(1400));
}
#[test]
fn exceed_pre_active_err() {
let mut p = TestPool::new(BasisPoints(0));
p.schedule.stake(epoch(3), tape(100)).unwrap();
p.schedule.cancel(epoch(3), tape(200)).unwrap();
let err = p.advance_epoch(epoch(3), tape(0)).unwrap_err();
assert!(matches!(err, PoolError::BalanceExceeded));
}
#[test]
fn exceed_shares_err() {
let mut p = TestPool::new(BasisPoints(0));
p.schedule.stake(epoch(1), tape(1000)).unwrap();
p.advance_epoch(epoch(1), tape(0)).unwrap();
p.schedule.unstake(epoch(2), shares(1500)).unwrap();
let err = p.advance_epoch(epoch(2), tape(0)).unwrap_err();
assert!(matches!(err, PoolError::BalanceExceeded));
}
#[test]
fn withdraw_pre_active() {
let mut p = TestPool::new(BasisPoints(0));
let mut s = p.stake_with_pool(epoch(5), tape(500)).unwrap();
let err = p.request_withdraw(&mut s, epoch(5), ExchangeRate::flat()).unwrap_err();
assert!(matches!(err, PoolError::StakeNotActive));
let we = p.request_cancel(&mut s, epoch(5)).unwrap();
assert_eq!(we, epoch(7)); assert_eq!(p.schedule.cancel_sum(epoch(7)), tape(500));
assert_eq!(p.schedule.unstake_sum(epoch(7)), shares(0));
}
#[test]
fn withdraw_active() {
let mut p = TestPool::new(BasisPoints(0));
let flat = ExchangeRate::flat();
let mut s = p.stake_with_pool(epoch(1), tape(1000)).unwrap();
p.advance_epoch(epoch(1), tape(0)).unwrap();
p.advance_epoch(epoch(2), tape(0)).unwrap();
p.advance_epoch(epoch(3), tape(0)).unwrap();
let activation_rate = flat;
let we = p.request_withdraw(&mut s, epoch(3), activation_rate).unwrap();
assert_eq!(we, epoch(5));
assert_eq!(p.schedule.unstake_sum(epoch(5)), shares(1000));
}
#[test]
fn withdraw_pre_no_rewards() {
let mut p = TestPool::new(BasisPoints(0));
let mut s = p.stake_with_pool(epoch(5), tape(500)).unwrap();
p.request_cancel(&mut s, epoch(5)).unwrap();
p.advance_epoch(epoch(6), tape(0)).unwrap();
p.advance_epoch(epoch(7), tape(0)).unwrap();
let paid = p.unstake_from_pool(&mut s, epoch(8), tape(0)).unwrap();
assert_eq!(paid, tape(0));
}
#[test]
fn rate_change_and_withdraw() {
let mut p = TestPool::new(BasisPoints(0));
p.schedule.stake(epoch(0), tape(100)).unwrap();
let mut s = p.stake_with_pool(epoch(1), tape(100)).unwrap();
p.advance_epoch(epoch(1), tape(0)).unwrap();
let r1 = p.get_current_rate();
assert_eq!(r1, ExchangeRate { tape: 100, other: 100 });
p.advance_epoch(epoch(2), tape(10)).unwrap();
let r2 = p.get_current_rate();
assert_eq!(r2, ExchangeRate { tape: 110, other: 100 });
p.advance_epoch(epoch(3), tape(10)).unwrap();
let r3 = p.get_current_rate();
assert_eq!(r3, ExchangeRate { tape: 220, other: 190 });
let activation_rate = r3; p.request_withdraw(&mut s, epoch(3), activation_rate).unwrap();
p.advance_epoch(epoch(4), tape(30)).unwrap();
let r4 = p.get_current_rate();
assert_eq!(r4, ExchangeRate { tape: 250, other: 190 });
p.advance_epoch(epoch(5), tape(30)).unwrap();
let r5 = p.get_current_rate();
assert_eq!(r5, ExchangeRate { tape: 167, other: 104 });
assert_eq!(p.stake, tape(167));
assert_eq!(p.shares, shares(104));
let user_shares: ShareAmount = r3
.convert_to_other_amount(s.amount.into())
.into();
let tape_at_r4: Coin<TAPE> = r4
.convert_to_tape_amount(user_shares.into())
.into();
let owed = tape_at_r4.saturating_sub(s.amount);
let paid = p.unstake_from_pool(&mut s, epoch(5), owed).unwrap();
assert_eq!(paid, owed);
assert_eq!(p.rewards, tape(67));
}
#[test]
fn rewards_only() {
let mut p = TestPool::new(BasisPoints(0));
p.schedule.stake(epoch(0), tape(100)).unwrap();
p.advance_epoch(epoch(1), tape(0)).unwrap();
assert_eq!(p.stake, tape(100));
assert_eq!(p.shares, shares(100));
p.advance_epoch(epoch(2), tape(50)).unwrap();
assert_eq!(p.stake, tape(150));
assert_eq!(p.shares, shares(100));
assert_eq!(p.rewards, tape(50));
p.advance_epoch(epoch(3), tape(25)).unwrap();
assert_eq!(p.stake, tape(175));
assert_eq!(p.shares, shares(100));
assert_eq!(p.rewards, tape(75));
let r3 = p.get_current_rate();
assert_eq!(r3, ExchangeRate { tape: 175, other: 100 });
}
#[test]
fn pre_active_cancel_no_shares() {
let mut p = TestPool::new(BasisPoints(0));
let mut s = p.stake_with_pool(epoch(1), tape(200)).unwrap();
let we = p.request_cancel(&mut s, epoch(1)).unwrap();
assert_eq!(we, epoch(3));
p.advance_epoch(epoch(1), tape(0)).unwrap();
p.advance_epoch(epoch(2), tape(0)).unwrap();
p.advance_epoch(epoch(3), tape(0)).unwrap();
assert_eq!(p.shares, shares(0));
assert_eq!(p.stake, tape(0));
assert_eq!(p.rewards, tape(0));
let paid = p.unstake_from_pool(&mut s, epoch(3), tape(0)).unwrap();
assert_eq!(paid, tape(0));
}
#[test]
fn two_users_fair_split() {
let mut p = TestPool::new(BasisPoints(0));
p.schedule.stake(epoch(0), tape(100)).unwrap();
let mut a = p.stake_with_pool(epoch(1), tape(100)).unwrap();
p.advance_epoch(epoch(1), tape(0)).unwrap(); p.advance_epoch(epoch(2), tape(60)).unwrap(); p.advance_epoch(epoch(3), tape(40)).unwrap();
let r3 = p.get_current_rate();
let mut b = p.stake_with_pool(epoch(3), tape(100)).unwrap();
p.request_withdraw(&mut a, epoch(3), r3).unwrap();
p.advance_epoch(epoch(4), tape(50)).unwrap();
let r4 = p.get_current_rate();
p.advance_epoch(epoch(5), tape(0)).unwrap();
let r5 = p.get_current_rate();
let a_shares: ShareAmount = r3.convert_to_other_amount(a.amount.into()).into();
let a_tape_at_r4: Coin<TAPE> = r4.convert_to_tape_amount(a_shares.into()).into();
let a_owed = a_tape_at_r4.saturating_sub(a.amount);
let paid_a = p.unstake_from_pool(&mut a, epoch(5), a_owed).unwrap();
assert_eq!(paid_a, a_owed);
let r5_activation = r5;
p.request_withdraw(&mut b, epoch(5), r5_activation).unwrap();
p.advance_epoch(epoch(6), tape(30)).unwrap();
let r6 = p.get_current_rate();
p.advance_epoch(epoch(7), tape(0)).unwrap();
let b_shares: ShareAmount = r5_activation.convert_to_other_amount(b.amount.into()).into();
let b_tape_at_r6: Coin<TAPE> = r6.convert_to_tape_amount(b_shares.into()).into();
let b_owed = b_tape_at_r6.saturating_sub(b.amount);
let paid_b = p.unstake_from_pool(&mut b, epoch(7), b_owed).unwrap();
assert_eq!(paid_b, b_owed);
assert!(paid_a.as_u64() + paid_b.as_u64() <= 180);
}
#[test]
fn withdraw_and_cap() {
let mut p = TestPool::new(BasisPoints(0));
p.schedule.stake(epoch(0), tape(100)).unwrap();
let mut s = p.stake_with_pool(epoch(1), tape(100)).unwrap();
p.advance_epoch(epoch(1), tape(0)).unwrap();
let r1 = p.get_current_rate();
assert_eq!(r1, ExchangeRate { tape: 100, other: 100 });
p.advance_epoch(epoch(2), tape(10)).unwrap();
let r2 = p.get_current_rate();
assert_eq!(r2, ExchangeRate { tape: 110, other: 100 });
p.advance_epoch(epoch(3), tape(10)).unwrap();
let r3 = p.get_current_rate();
assert_eq!(r3, ExchangeRate { tape: 220, other: 190 });
let activation_rate = r3; p.request_withdraw(&mut s, epoch(3), activation_rate).unwrap();
p.advance_epoch(epoch(4), tape(30)).unwrap();
let r4 = p.get_current_rate();
assert_eq!(r4, ExchangeRate { tape: 250, other: 190 });
p.advance_epoch(epoch(5), tape(30)).unwrap();
p.rewards = tape(10);
let shares = activation_rate.convert_to_other_amount(s.amount.into());
let owed = tape(r4.convert_to_tape_amount(shares).saturating_sub(s.amount.into()));
let paid = p.unstake_from_pool(&mut s, epoch(5), owed).unwrap();
assert_eq!(paid, tape(10));
assert_eq!(p.rewards, tape(0));
}
#[test]
fn withdraw_early_err() {
let mut p = TestPool::new(BasisPoints(0));
let mut s = p.stake_with_pool(epoch(1), tape(100)).unwrap();
p.advance_epoch(epoch(1), tape(0)).unwrap();
p.advance_epoch(epoch(2), tape(0)).unwrap();
p.advance_epoch(epoch(3), tape(0)).unwrap();
let activation_rate = p.get_current_rate();
p.request_withdraw(&mut s, epoch(3), activation_rate).unwrap();
p.advance_epoch(epoch(4), tape(0)).unwrap();
let r4 = p.get_current_rate();
let shares = activation_rate.convert_to_other_amount(s.amount.into());
let owed = tape(r4.convert_to_tape_amount(shares).saturating_sub(s.amount.into()));
let err = p.unstake_from_pool(&mut s, epoch(4), owed).unwrap_err();
assert!(matches!(err, PoolError::EpochInvalid));
}
#[test]
fn alice_single() {
let mut p = TestPool::new(BasisPoints(0));
let mut alice = p.stake_with_pool(epoch(0), tape(1000)).unwrap();
p.advance_epoch(epoch(1), tape(0)).unwrap();
p.advance_epoch(epoch(2), tape(0)).unwrap();
let r2 = p.get_current_rate();
assert_eq!(r2, ExchangeRate { tape: 1000, other: 1000 });
p.advance_epoch(epoch(3), tape(1000)).unwrap();
p.request_withdraw(&mut alice, epoch(3), r2).unwrap();
p.advance_epoch(epoch(4), tape(0)).unwrap();
let r4 = p.get_current_rate();
let shares = r2.convert_to_other_amount(alice.amount.into());
let tape_at_r4 = r4.convert_to_tape_amount(shares);
let owed = tape(tape_at_r4.saturating_sub(alice.amount.into()));
p.advance_epoch(epoch(5), tape(0)).unwrap();
let paid = p.unstake_from_pool(&mut alice, epoch(5), owed).unwrap();
assert_eq!(paid, owed);
assert!(paid > TAPE(0));
}
#[test]
fn alice_bob_split() {
let mut p = TestPool::new(BasisPoints(0));
let mut alice = p.stake_with_pool(epoch(0), tape(1000)).unwrap();
let mut bob = p.stake_with_pool(epoch(0), tape(1000)).unwrap();
p.advance_epoch(epoch(1), tape(0)).unwrap();
p.advance_epoch(epoch(2), tape(0)).unwrap(); let r2 = p.get_current_rate();
p.advance_epoch(epoch(3), tape(1000)).unwrap();
let activation_rate = r2;
let wa = p.request_withdraw(&mut alice, epoch(3), activation_rate).unwrap();
let wb = p.request_withdraw(&mut bob, epoch(3), activation_rate).unwrap();
assert_eq!(wa, epoch(5));
assert_eq!(wb, epoch(5));
p.advance_epoch(epoch(4), tape(0)).unwrap();
let r4 = p.get_current_rate();
p.advance_epoch(epoch(5), tape(0)).unwrap();
let shares = activation_rate.convert_to_other_amount(tape(1000).into());
let owed_each = tape(r4.convert_to_tape_amount(shares).saturating_sub(1000));
let ra = p.unstake_from_pool(&mut alice, epoch(5), owed_each).unwrap();
let rb = p.unstake_from_pool(&mut bob, epoch(5), owed_each).unwrap();
assert_ne!(ra, 0.into());
assert_eq!(ra, rb);
}
#[test]
fn commission_round() {
let mut p = TestPool::new(BasisPoints(1000));
let mut alice = p.stake_with_pool(epoch(0), tape(1000)).unwrap();
p.advance_epoch(epoch(1), tape(0)).unwrap(); p.advance_epoch(epoch(2), tape(0)).unwrap(); let r2 = p.get_current_rate();
p.advance_epoch(epoch(3), tape(202)).unwrap();
assert_eq!(p.commission, tape(20));
assert_eq!(p.rewards, tape(182));
let activation_rate = r2;
p.request_withdraw(&mut alice, epoch(3), activation_rate).unwrap();
p.advance_epoch(epoch(4), tape(0)).unwrap();
let r4 = p.get_current_rate();
p.advance_epoch(epoch(5), tape(0)).unwrap();
let shares = activation_rate.convert_to_other_amount(alice.amount.into());
let owed = tape(r4.convert_to_tape_amount(shares).saturating_sub(alice.amount.into()));
let paid = p.unstake_from_pool(&mut alice, epoch(5), owed).unwrap();
assert_eq!(paid, tape(182));
assert_eq!(p.commission, tape(20));
}
#[test]
fn early_blocked() {
let mut p = TestPool::new(BasisPoints(0));
let mut alice = p.stake_with_pool(epoch(1), tape(500)).unwrap();
p.advance_epoch(epoch(2), tape(0)).unwrap();
p.advance_epoch(epoch(3), tape(0)).unwrap();
let r3 = p.get_current_rate();
let activation_rate = r3;
p.request_withdraw(&mut alice, epoch(3), activation_rate).unwrap();
p.advance_epoch(epoch(4), tape(0)).unwrap();
let shares = activation_rate.convert_to_other_amount(alice.amount.into());
let owed = tape(r3.convert_to_tape_amount(shares).saturating_sub(alice.amount.into()));
let err = p.unstake_from_pool(&mut alice, epoch(4), owed).unwrap_err();
assert!(matches!(err, PoolError::EpochInvalid));
}
#[test]
fn maintain_ratio() {
let mut p = TestPool::new(BasisPoints(0));
let mut alice = p.stake_with_pool(epoch(0), tape(1000)).unwrap();
p.advance_epoch(epoch(1), tape(0)).unwrap();
p.advance_epoch(epoch(2), tape(0)).unwrap();
let r2 = p.get_current_rate();
let mut bob = p.stake_with_pool(epoch(1), tape(2000)).unwrap();
p.advance_epoch(epoch(3), tape(1000)).unwrap(); let r3 = p.get_current_rate();
let activation_rate_e2 = r2;
p.request_withdraw(&mut alice, epoch(3), activation_rate_e2).unwrap();
p.advance_epoch(epoch(4), tape(1000)).unwrap();
let r4 = p.get_current_rate();
let activation_rate_e3 = r3;
p.request_withdraw(&mut bob, epoch(4), activation_rate_e3).unwrap();
p.advance_epoch(epoch(5), tape(0)).unwrap();
let r5 = p.get_current_rate();
let alice_shares = activation_rate_e2.convert_to_other_amount(alice.amount.into());
let ra_owed = tape(r4.convert_to_tape_amount(alice_shares).saturating_sub(alice.amount.into()));
let ra = p.unstake_from_pool(&mut alice, epoch(5), ra_owed).unwrap();
p.advance_epoch(epoch(6), tape(0)).unwrap();
let bob_shares = activation_rate_e3.convert_to_other_amount(bob.amount.into());
let rb_owed = tape(r5.convert_to_tape_amount(bob_shares).saturating_sub(bob.amount.into()));
let rb = p.unstake_from_pool(&mut bob, epoch(6), rb_owed).unwrap();
assert!(ra > TAPE(0));
assert!(rb > TAPE(0));
}
#[test]
fn claim_commission_full() {
let mut p = TestPool::new(BasisPoints(1000));
p.commission = TAPE(1_234);
let claimed = p.claim_commission().expect("claim commission");
assert_eq!(claimed, TAPE(1_234));
assert_eq!(p.commission, TAPE(0));
}
#[test]
fn claim_commission_empty_err() {
let mut p = TestPool::new(BasisPoints(1000));
let err = p.claim_commission().unwrap_err();
assert!(matches!(err, PoolError::ZeroCommission));
}
#[test]
fn stake_immediate_activation() {
let mut p = TestPool::new(BasisPoints(0));
let s = p.stake_with_pool_at(epoch(0), epoch(0), tape(1000)).unwrap();
assert_eq!(s.activation_epoch, epoch(0));
assert_eq!(p.stake, tape(1000), "pool.stake should be updated immediately");
assert!(!p.shares.is_zero(), "pool.shares should be updated immediately");
assert_eq!(p.schedule.stake_sum(epoch(0)), tape(0));
}
#[test]
fn stake_delayed_activation() {
let mut p = TestPool::new(BasisPoints(0));
let s = p.stake_with_pool_at(epoch(5), epoch(7), tape(1000)).unwrap();
assert_eq!(s.activation_epoch, epoch(7));
assert_eq!(p.stake, tape(0), "pool.stake should still be zero");
assert!(p.shares.is_zero(), "pool.shares should still be zero");
assert_eq!(p.schedule.stake_sum(epoch(7)), tape(1000));
}
#[test]
fn boundary_dust_regression() {
let mut p = TestPool::new(BasisPoints(0));
p.schedule.stake(epoch(0), tape(1500)).unwrap();
p.advance_epoch(epoch(0), tape(0)).unwrap();
p.advance_epoch(epoch(1), tape(2)).unwrap();
assert_eq!(p.stake, tape(1502));
assert_eq!(p.shares, shares(1500));
p.schedule.unstake(epoch(2), shares(500)).unwrap();
let snapshot = p.get_current_rate();
assert_eq!(snapshot, ExchangeRate { tape: 1502, other: 1500 });
p.advance_epoch(epoch(2), tape(0)).unwrap();
assert_eq!(p.stake, tape(1002));
assert_eq!(p.shares, shares(1000));
let tokens_at_snapshot: Coin<TAPE> =
snapshot.convert_to_tape_amount(500u64).into();
let owed = tokens_at_snapshot.saturating_sub(tape(500));
assert_eq!(owed, tape(0), "withdrawer must settle at snapshot rate");
let post_rate = p.get_current_rate();
let buggy: Coin<TAPE> = post_rate.convert_to_tape_amount(500u64).into();
assert_eq!(buggy.saturating_sub(tape(500)), tape(1));
}
#[test]
fn gap_settles_at_single_span_rate() {
let mut p = TestPool::new(BasisPoints(0));
p.schedule.stake(epoch(0), tape(1000)).unwrap();
p.advance_epoch(epoch(0), tape(0)).unwrap();
p.advance_epoch(epoch(1), tape(50)).unwrap();
assert_eq!(p.stake, tape(1050));
p.schedule.unstake(epoch(3), shares(100)).unwrap();
p.schedule.unstake(epoch(4), shares(200)).unwrap();
let span_rate = p.get_current_rate();
assert_eq!(span_rate, ExchangeRate { tape: 1050, other: 1000 });
p.advance_epoch(epoch(5), tape(7)).unwrap();
assert_eq!(p.stake, tape(1050 - 315 + 7));
assert_eq!(p.shares, shares(700));
let tokens_100: Coin<TAPE> = span_rate.convert_to_tape_amount(100u64).into();
let tokens_200: Coin<TAPE> = span_rate.convert_to_tape_amount(200u64).into();
assert_eq!(tokens_100, tape(105));
assert_eq!(tokens_200, tape(210));
}
#[test]
fn aggregate_withdrawal_dust_stays_in_pool() {
let mut p = TestPool::new(BasisPoints(0));
p.schedule.stake(epoch(0), tape(200)).unwrap();
p.advance_epoch(epoch(0), tape(0)).unwrap();
p.advance_epoch(epoch(1), tape(100)).unwrap();
assert_eq!(p.get_current_rate(), ExchangeRate { tape: 300, other: 200 });
p.schedule.unstake(epoch(2), shares(1)).unwrap();
p.schedule.unstake(epoch(2), shares(1)).unwrap();
let snapshot = p.get_current_rate();
p.advance_epoch(epoch(2), tape(0)).unwrap();
assert_eq!(p.stake, tape(297));
assert_eq!(p.shares, shares(198));
assert_eq!(p.get_current_rate(), ExchangeRate { tape: 297, other: 198 });
let per_user_tokens: Coin<TAPE> =
snapshot.convert_to_tape_amount(1u64).into();
assert_eq!(per_user_tokens, tape(1));
}
#[test]
fn activator_at_boundary_earns_rewards() {
let mut p = TestPool::new(BasisPoints(0));
p.schedule.stake(epoch(0), tape(1000)).unwrap();
p.advance_epoch(epoch(0), tape(0)).unwrap();
p.schedule.stake(epoch(2), tape(100)).unwrap();
p.advance_epoch(epoch(2), tape(100)).unwrap();
assert_eq!(p.stake, tape(1200));
assert_eq!(p.shares, shares(1100));
let bob_value: Coin<TAPE> = p.get_current_rate()
.convert_to_tape_amount(100u64)
.into();
assert_eq!(bob_value, tape(109));
}
}