|
1 | 1 | use crate::{ |
2 | | - config::{self, BLOCKS_IN_YEAR, DIVISION_SAFETY_CONST, MAX_PERCENT}, |
3 | | - contexts::base::StorageCache, |
4 | | - events, proxy_contracts, storage, |
| 2 | + config::{self, BLOCKS_IN_YEAR, DIVISION_SAFETY_CONST, MAX_PERCENT}, |
| 3 | + contexts::base::StorageCache, |
| 4 | + events, proxy_contracts, storage, |
5 | 5 | }; |
6 | 6 |
|
7 | 7 | multiversx_sc::imports!(); |
8 | 8 | multiversx_sc::derive_imports!(); |
9 | 9 |
|
10 | 10 | #[multiversx_sc::module] |
11 | 11 | pub trait RewardsModule: |
12 | | - storage::StorageModule + config::ConfigModule + events::EventsModule |
| 12 | + storage::StorageModule + config::ConfigModule + events::EventsModule |
13 | 13 | { |
14 | | - #[endpoint(generateAggregatedRewards)] |
15 | | - fn generate_rewards(&self) { |
16 | | - let mut storage_cache = StorageCache::new(self); |
17 | | - self.generate_aggregated_rewards(&mut storage_cache); |
18 | | - } |
19 | | - fn generate_aggregated_rewards(&self, storage_cache: &mut StorageCache<Self>) { |
20 | | - let last_reward_nonce = self.last_reward_block_nonce().get(); |
21 | | - let extra_rewards_unbounded = self.calculate_rewards_since_last_allocation(storage_cache); |
22 | | - let max_apr = self.max_apr().get(); |
23 | | - |
24 | | - let extra_rewards: BigUint; |
25 | | - if max_apr > BigUint::zero() { |
26 | | - let extra_rewards_apr_bounded_per_block = |
27 | | - self.get_amount_apr_bounded(&storage_cache.rewards_reserve); |
28 | | - |
29 | | - let current_block_nonce = self.blockchain().get_block_nonce(); |
30 | | - |
31 | | - let block_nonce_diff = current_block_nonce - last_reward_nonce; |
32 | | - |
33 | | - let extra_rewards_apr_bounded = extra_rewards_apr_bounded_per_block * block_nonce_diff; |
34 | | - |
35 | | - extra_rewards = core::cmp::min(extra_rewards_unbounded, extra_rewards_apr_bounded); |
36 | | - } else { |
37 | | - extra_rewards = extra_rewards_unbounded; |
38 | | - } |
39 | | - |
40 | | - if extra_rewards > BigUint::zero() && extra_rewards <= storage_cache.rewards_reserve { |
41 | | - let total_staked_amount = self |
42 | | - .tx() |
43 | | - .to(self.bond_contract_address().get()) |
44 | | - .typed(proxy_contracts::life_bonding_sc_proxy::LifeBondingContractProxy) |
45 | | - .total_bond_amount() |
46 | | - .returns(ReturnsResult) |
47 | | - .sync_call(); |
48 | | - |
49 | | - let increment = &extra_rewards * DIVISION_SAFETY_CONST / &total_staked_amount; |
50 | | - |
51 | | - storage_cache.rewards_per_share += &increment; |
52 | | - storage_cache.accumulated_rewards += &extra_rewards; |
53 | | - storage_cache.rewards_reserve -= &extra_rewards; |
54 | | - } |
55 | | - } |
56 | | - |
57 | | - // not used (useful to enforce a max APR) |
58 | | - fn get_amount_apr_bounded(&self, amount: &BigUint) -> BigUint { |
59 | | - let max_apr = self.max_apr().get(); |
60 | | - amount * &max_apr / MAX_PERCENT / BLOCKS_IN_YEAR |
61 | | - } |
62 | | - |
63 | | - fn calculate_rewards_since_last_allocation( |
64 | | - &self, |
65 | | - storage_cache: &mut StorageCache<Self>, |
66 | | - ) -> BigUint { |
67 | | - let current_block_nonce = self.blockchain().get_block_nonce(); |
68 | | - |
69 | | - if !self.can_produce_rewards() { |
70 | | - return BigUint::zero(); |
71 | | - } |
72 | | - |
73 | | - if current_block_nonce <= storage_cache.last_reward_block_nonce { |
74 | | - return BigUint::zero(); |
75 | | - } |
76 | | - |
77 | | - let block_nonce_diff = current_block_nonce - storage_cache.last_reward_block_nonce; |
78 | | - |
79 | | - storage_cache.last_reward_block_nonce = current_block_nonce; |
80 | | - |
81 | | - &storage_cache.rewards_per_block * block_nonce_diff |
82 | | - } |
83 | | - |
84 | | - fn calculate_caller_share_in_rewards( |
85 | | - self, |
86 | | - caller: &ManagedAddress, |
87 | | - total_staked_amount: BigUint, |
88 | | - user_stake_amount: BigUint, |
89 | | - storage_cache: &mut StorageCache<Self>, |
90 | | - ) -> BigUint { |
91 | | - if total_staked_amount > BigUint::zero() |
92 | | - && storage_cache.accumulated_rewards > BigUint::zero() |
93 | | - { |
94 | | - let user_last_rewards_per_share = self.address_last_reward_per_share(caller).get(); |
95 | | - |
96 | | - let user_rewards = user_stake_amount |
97 | | - * (&storage_cache.rewards_per_share - &user_last_rewards_per_share) |
98 | | - / DIVISION_SAFETY_CONST; |
99 | | - |
100 | | - self.address_last_reward_per_share(caller) |
101 | | - .set(storage_cache.rewards_per_share.clone()); |
102 | | - |
103 | | - self.address_stack_rewards(caller) |
104 | | - .update(|value| *value += &user_rewards); |
105 | | - |
106 | | - user_rewards |
107 | | - } else { |
108 | | - BigUint::zero() |
109 | | - } |
110 | | - } |
| 14 | + #[endpoint(generateAggregatedRewards)] |
| 15 | + fn generate_rewards(&self) { |
| 16 | + let mut storage_cache = StorageCache::new(self); |
| 17 | + self.generate_aggregated_rewards(&mut storage_cache); |
| 18 | + } |
| 19 | + fn generate_aggregated_rewards(&self, storage_cache: &mut StorageCache<Self>) { |
| 20 | + if self.can_produce_rewards() { |
| 21 | + let last_reward_nonce = self.last_reward_block_nonce().get(); |
| 22 | + let extra_rewards_unbounded = |
| 23 | + self.calculate_rewards_since_last_allocation(storage_cache); |
| 24 | + let max_apr = self.max_apr().get(); |
| 25 | + |
| 26 | + let extra_rewards: BigUint; |
| 27 | + let total_staked_amount = self |
| 28 | + .tx() |
| 29 | + .to(self.bond_contract_address().get()) |
| 30 | + .typed(proxy_contracts::life_bonding_sc_proxy::LifeBondingContractProxy) |
| 31 | + .total_bond_amount() |
| 32 | + .returns(ReturnsResult) |
| 33 | + .sync_call(); |
| 34 | + if max_apr > BigUint::zero() { |
| 35 | + let extra_rewards_apr_bounded_per_block = |
| 36 | + self.get_amount_apr_bounded(&total_staked_amount); // max APR based on the total staked amount |
| 37 | + |
| 38 | + let current_block_nonce = self.blockchain().get_block_nonce(); |
| 39 | + |
| 40 | + let block_nonce_diff = current_block_nonce - last_reward_nonce; |
| 41 | + |
| 42 | + let extra_rewards_apr_bounded = |
| 43 | + extra_rewards_apr_bounded_per_block * block_nonce_diff; |
| 44 | + |
| 45 | + extra_rewards = core::cmp::min(extra_rewards_unbounded, extra_rewards_apr_bounded); |
| 46 | + } else { |
| 47 | + extra_rewards = extra_rewards_unbounded; |
| 48 | + } |
| 49 | + |
| 50 | + if extra_rewards > BigUint::zero() && extra_rewards <= storage_cache.rewards_reserve { |
| 51 | + let increment = &extra_rewards * DIVISION_SAFETY_CONST / &total_staked_amount; |
| 52 | + |
| 53 | + storage_cache.rewards_per_share += &increment; |
| 54 | + storage_cache.accumulated_rewards += &extra_rewards; |
| 55 | + storage_cache.rewards_reserve -= &extra_rewards; |
| 56 | + } |
| 57 | + } |
| 58 | + } |
| 59 | + |
| 60 | + // not used (useful to enforce a max APR) |
| 61 | + fn get_amount_apr_bounded(&self, amount: &BigUint) -> BigUint { |
| 62 | + let max_apr = self.max_apr().get(); |
| 63 | + amount * &max_apr / MAX_PERCENT / BLOCKS_IN_YEAR |
| 64 | + } |
| 65 | + |
| 66 | + fn calculate_rewards_since_last_allocation( |
| 67 | + &self, |
| 68 | + storage_cache: &mut StorageCache<Self>, |
| 69 | + ) -> BigUint { |
| 70 | + let current_block_nonce = self.blockchain().get_block_nonce(); |
| 71 | + |
| 72 | + if current_block_nonce <= storage_cache.last_reward_block_nonce { |
| 73 | + return BigUint::zero(); |
| 74 | + } |
| 75 | + |
| 76 | + let block_nonce_diff = current_block_nonce - storage_cache.last_reward_block_nonce; |
| 77 | + |
| 78 | + storage_cache.last_reward_block_nonce = current_block_nonce; |
| 79 | + |
| 80 | + &storage_cache.rewards_per_block * block_nonce_diff |
| 81 | + } |
| 82 | + |
| 83 | + fn calculate_caller_share_in_rewards( |
| 84 | + self, |
| 85 | + caller: &ManagedAddress, |
| 86 | + total_staked_amount: BigUint, |
| 87 | + user_stake_amount: BigUint, |
| 88 | + storage_cache: &mut StorageCache<Self>, |
| 89 | + ) -> BigUint { |
| 90 | + if total_staked_amount > BigUint::zero() |
| 91 | + && storage_cache.accumulated_rewards > BigUint::zero() |
| 92 | + { |
| 93 | + let user_last_rewards_per_share = self.address_last_reward_per_share(caller).get(); |
| 94 | + |
| 95 | + let user_rewards = user_stake_amount |
| 96 | + * (&storage_cache.rewards_per_share - &user_last_rewards_per_share) |
| 97 | + / DIVISION_SAFETY_CONST; |
| 98 | + |
| 99 | + self.address_last_reward_per_share(caller) |
| 100 | + .set(storage_cache.rewards_per_share.clone()); |
| 101 | + |
| 102 | + self.address_stack_rewards(caller) |
| 103 | + .update(|value| *value += &user_rewards); |
| 104 | + |
| 105 | + user_rewards |
| 106 | + } else { |
| 107 | + BigUint::zero() |
| 108 | + } |
| 109 | + } |
111 | 110 | } |
0 commit comments