From 8054e39f4d3ae6adb1f7045edcd7c04d99f7a884 Mon Sep 17 00:00:00 2001 From: Martin Krung Date: Fri, 10 Jan 2025 13:28:06 +0100 Subject: [PATCH] chore: renaming and code clean up --- contracts/FixedRewards.vy | 20 ++--- contracts/RewardManager.vy | 24 +++--- contracts/{RecoveryGauge.vy => TestGauge.vy} | 4 +- example.env | 2 +- scripts/deploy_manager.py | 8 +- tests/FixedRewards/conftest.py | 11 ++- tests/FixedRewards/test_fixed_rewards.py | 77 ++++++++++---------- tests/RewardManager/conftest.py | 8 +- tests/RewardManager/test_deposit_reward.py | 32 ++++---- tests/RewardManager/test_recovery_gauge.py | 22 +++--- 10 files changed, 102 insertions(+), 106 deletions(-) rename contracts/{RecoveryGauge.vy => TestGauge.vy} (95%) diff --git a/contracts/FixedRewards.vy b/contracts/FixedRewards.vy index 65b3c66..11fc6c8 100644 --- a/contracts/FixedRewards.vy +++ b/contracts/FixedRewards.vy @@ -7,12 +7,12 @@ """ interface RewardManager: - def send_reward_token(_reward_receiver: address, _amount: uint256): nonpayable + def send_reward_token(_receiving_gauge: address, _amount: uint256): nonpayable # State Variables managers: public(DynArray[address, 3]) # Changed from owner to managers reward_manager_address: public(address) -reward_receiver_address: public(address) +receiving_gauge_address: public(address) min_epoch_duration: public(uint256) is_setup_complete: public(bool) @@ -30,7 +30,7 @@ VERSION: constant(String[8]) = "0.9.0" event SetupCompleted: reward_manager_address: address - reward_receiver_address: address + receiving_gauge_address: address min_epoch_duration: uint256 timestamp: uint256 @@ -54,34 +54,31 @@ def __init__(_managers: DynArray[address, 3]): self.min_epoch_duration = WEEK @external -def setup(_reward_manager_address: address, _reward_receiver_address: address, _min_epoch_duration: uint256) -> bool: +def setup(_reward_manager_address: address, _receiving_gauge_address: address, _min_epoch_duration: uint256): """ @notice Set the reward manager and receiver addresses (can only be set once) @param _reward_manager_address Address of the RewardManager contract - @param _reward_receiver_address Address of the RewardReceiver contract + @param _receiving_gauge_address Address of the RewardReceiver contract @param _min_epoch_duration Minimum epoch duration in seconds - @return bool Setup success """ assert msg.sender in self.managers, "only managers can call this function" assert not self.is_setup_complete, "Setup already completed" assert 3 * WEEK / 7 <= _min_epoch_duration and _min_epoch_duration <= WEEK * 4 * 12, 'epoch duration must be between 3 days and a year' self.reward_manager_address = _reward_manager_address - self.reward_receiver_address = _reward_receiver_address + self.receiving_gauge_address = _receiving_gauge_address self.min_epoch_duration = _min_epoch_duration self.is_setup_complete = True - log SetupCompleted(_reward_manager_address, _reward_receiver_address, _min_epoch_duration, block.timestamp) + log SetupCompleted(_reward_manager_address, _receiving_gauge_address, _min_epoch_duration, block.timestamp) - return True @external def set_reward_epochs(_reward_epochs: DynArray[uint256, 52]): """ @notice Set the reward epochs in reverse order: last value is the first to be distributed, first value is the last to be distributed @param _reward_epochs List of reward amounts ordered from first to last epoch - @return bool Setting success """ assert msg.sender in self.managers, "only managers can call this function" assert not self.is_reward_epochs_set, "Reward epochs can only be set once" @@ -97,7 +94,6 @@ def set_reward_epochs(_reward_epochs: DynArray[uint256, 52]): def distribute_reward(): """ @notice Distribute rewards for the current epoch if conditions are met - @return bool Distribution success """ assert msg.sender in self.managers, "only managers can call this function" assert self.is_setup_complete, "Setup not completed" @@ -119,7 +115,7 @@ def distribute_reward(): self.last_reward_distribution_time = block.timestamp # Call reward manager to send reward - RewardManager(self.reward_manager_address).send_reward_token(self.reward_receiver_address, current_reward_amount) + RewardManager(self.reward_manager_address).send_reward_token(self.receiving_gauge_address, current_reward_amount) log RewardDistributed( current_reward_amount, diff --git a/contracts/RewardManager.vy b/contracts/RewardManager.vy index c75891e..e9c670d 100644 --- a/contracts/RewardManager.vy +++ b/contracts/RewardManager.vy @@ -19,42 +19,42 @@ VERSION: constant(String[8]) = "0.9.0" managers: public(DynArray[address, 30]) reward_token: public(address) -reward_receivers: public(DynArray[address, 20]) +receiving_gauges: public(DynArray[address, 20]) recovery_address: public(address) @external -def __init__(_managers: DynArray[address, 30], _reward_token: address, _reward_receivers: DynArray[address, 20], _recovery_address: address): +def __init__(_managers: DynArray[address, 30], _reward_token: address, _receiving_gauges: DynArray[address, 20], _recovery_address: address): """ @notice Contract constructor @param _managers set managers who can send reward token to gauges @param _reward_token set reward token address - @param _reward_receivers allowed gauges to receiver reward + @param _receiving_gauges allowed gauges to receiver reward @param _recovery_address set recovery address """ self.managers = _managers self.reward_token = _reward_token - self.reward_receivers = _reward_receivers + self.receiving_gauges = _receiving_gauges self.recovery_address = _recovery_address @external -def send_reward_token(_reward_receiver: address, _amount: uint256, _epoch: uint256 = WEEK): +def send_reward_token(_receiving_gauge: address, _amount: uint256, _epoch: uint256 = WEEK): """ @notice send reward token from contract to gauge - @param _reward_receiver gauges to receiver reward + @param _receiving_gauge gauges to receiver reward @param _amount The amount of reward token being sent @param _epoch The duration the rewards are distributed across in seconds. Between 3 days and a year, week by default """ assert msg.sender in self.managers, 'only reward managers can call this function' - assert _reward_receiver in self.reward_receivers, 'only reward receiver which are allowed' + assert _receiving_gauge in self.receiving_gauges, 'only reward receiver which are allowed' assert 3 * WEEK / 7 <= _epoch and _epoch <= WEEK * 4 * 12, 'epoch duration must be between 3 days and a year' - assert ERC20(self.reward_token).approve(_reward_receiver, _amount, default_return_value=True) + assert ERC20(self.reward_token).approve(_receiving_gauge, _amount, default_return_value=True) # legacy gauges have no epoch parameter # new deposit_reward_token has epoch parameter default to WEEK if _epoch == WEEK: - LegacyGauge(_reward_receiver).deposit_reward_token(self.reward_token, _amount) + LegacyGauge(_receiving_gauge).deposit_reward_token(self.reward_token, _amount) else: - Gauge(_reward_receiver).deposit_reward_token(self.reward_token, _amount, _epoch) + Gauge(_receiving_gauge).deposit_reward_token(self.reward_token, _amount, _epoch) @external @@ -79,9 +79,9 @@ def get_all_managers() -> DynArray[address, 30]: @external @view -def get_all_reward_receivers() -> DynArray[address, 20]: +def get_all_receiving_gauges() -> DynArray[address, 20]: """ @notice Get all reward receivers @return DynArray[address, 20] list containing all reward receivers """ - return self.reward_receivers \ No newline at end of file + return self.receiving_gauges \ No newline at end of file diff --git a/contracts/RecoveryGauge.vy b/contracts/TestGauge.vy similarity index 95% rename from contracts/RecoveryGauge.vy rename to contracts/TestGauge.vy index 2873792..3fa138e 100644 --- a/contracts/RecoveryGauge.vy +++ b/contracts/TestGauge.vy @@ -1,9 +1,9 @@ # @version 0.3.10 """ -@title RecoveryGauge +@title TestGauge @author martinkrung for curve.fi @license MIT -@notice test gauge for testing and to recover token +@notice test gauge for testing """ from vyper.interfaces import ERC20 diff --git a/example.env b/example.env index 2711524..c6e8af9 100644 --- a/example.env +++ b/example.env @@ -31,7 +31,7 @@ export GAUGE_CRVUSD_USDC="0x00000.." export GAUGE_ALLOWLIST="$GAUGE_CRVUSD_USDT,GAUGE_CRVUSD_USDC" # comma seperated addresses, no "," at the end, up to 20 -export EXISTING_RECOVERY_GAUGE="0x00000.." +export EXISTING_TEST_GAUGE="0x00000.." # alchemy diff --git a/scripts/deploy_manager.py b/scripts/deploy_manager.py index 7add9cd..9a2e537 100644 --- a/scripts/deploy_manager.py +++ b/scripts/deploy_manager.py @@ -8,7 +8,7 @@ REWARD_MANAGERS = os.getenv('REWARD_MANAGERS') REWARD_TOKEN = os.getenv('REWARD_TOKEN') RECOVERY_ADDRESS = os.getenv('RECOVERY_ADDRESS') -# EXISTING_RECOVERY_GAUGE = os.getenv('EXISTING_RECOVERY_GAUGE') +# EXISTING_TEST_GAUGE = os.getenv('EXISTING_TEST_GAUGE') REWARD_TOKEN_TESTNET = os.getenv('REWARD_TOKEN_TESTNET') GAUGE_ALLOWLIST = os.getenv('GAUGE_ALLOWLIST') @@ -35,10 +35,10 @@ def info(ecosystem, provider, account, network): @account_option() def deploy(network, provider, account): """ - if EXISTING_RECOVERY_GAUGE is None: - recovery_gauge = account.deploy(project.RecoveryGauge, REWARD_TOKEN, RECOVERY_ADDRESS, max_priority_fee="1000 wei", max_fee="0.1 gwei", gas_limit="100000") + if EXISTING_TEST_GAUGE is None: + test_gauge = account.deploy(project.TestGauge, REWARD_TOKEN, RECOVERY_ADDRESS, max_priority_fee="1000 wei", max_fee="0.1 gwei", gas_limit="100000") else: - recovery_gauge = EXISTING_RECOVERY_GAUGE + test_gauge = EXISTING_TEST_GAUGE gauges.append(recovery_gauge) """ diff --git a/tests/FixedRewards/conftest.py b/tests/FixedRewards/conftest.py index c9c08a9..60fd563 100644 --- a/tests/FixedRewards/conftest.py +++ b/tests/FixedRewards/conftest.py @@ -21,12 +21,11 @@ def lost_token(project, alice, charlie): print(balance) return lost_token - @pytest.fixture(scope="module") -def recovery_gauge(project, alice, charlie, diana, reward_token): +def test_gauge(project, alice, charlie, diana, reward_token): # bob manager address # diana is recovery address - gauge = alice.deploy(project.RecoveryGauge, reward_token, diana) + gauge = alice.deploy(project.TestGauge, reward_token, diana) return gauge @pytest.fixture(scope="module") @@ -36,15 +35,15 @@ def fixed_rewards(project, alice, bob, charlie): return contract @pytest.fixture(scope="module") -def reward_manager(project, alice, bob, charlie, diana, reward_token, recovery_gauge, fixed_rewards): +def reward_manager(project, alice, bob, charlie, diana, reward_token, test_gauge, fixed_rewards): # bob manager address # diana is recovery address print(fixed_rewards) - reward_manager_contract = alice.deploy(project.RewardManager, [bob, charlie, fixed_rewards], reward_token, [recovery_gauge], diana) + reward_manager_contract = alice.deploy(project.RewardManager, [bob, charlie, fixed_rewards], reward_token, [test_gauge], diana) reward_token.approve(reward_manager_contract, 10 ** 19, sender=bob) print(reward_manager_contract) # Setup the reward manager and receiver - #fixed_rewards.setup(reward_manager.address, recovery_gauge.address, sender=alice) + #fixed_rewards.setup(reward_manager.address, test_gauge.address, sender=alice) amount = 10 ** 19 reward_token.transfer(reward_manager_contract, amount, sender=bob) diff --git a/tests/FixedRewards/test_fixed_rewards.py b/tests/FixedRewards/test_fixed_rewards.py index 649868e..6708835 100644 --- a/tests/FixedRewards/test_fixed_rewards.py +++ b/tests/FixedRewards/test_fixed_rewards.py @@ -13,26 +13,27 @@ def test_managers(bob, charlie, fixed_rewards): assert fixed_rewards.managers(0) == bob assert fixed_rewards.managers(1) == charlie -def test_set_reward_manager(bob, reward_manager, recovery_gauge, fixed_rewards): +def test_set_reward_manager(bob, reward_manager, test_gauge, fixed_rewards): # Setup the reward manager and receiver using manager account with default epoch duration (3 days) min_epoch_duration = 3 * DAY - fixed_rewards.setup(reward_manager.address, recovery_gauge.address, min_epoch_duration, sender=bob) + fixed_rewards.setup(reward_manager.address, test_gauge.address, min_epoch_duration, sender=bob) assert fixed_rewards.reward_manager_address() == reward_manager.address - assert fixed_rewards.reward_receiver_address() == recovery_gauge.address + print(fixed_rewards.reward_manager_address()) + assert fixed_rewards.receiving_gauge_address() == test_gauge.address assert fixed_rewards.min_epoch_duration() == min_epoch_duration -def test_set_reward_manager_revert_not_manager(alice, reward_manager, recovery_gauge, fixed_rewards): +def test_set_reward_manager_revert_not_manager(alice, reward_manager, test_gauge, fixed_rewards): min_epoch_duration = 3 * DAY with ape.reverts("only managers can call this function"): - fixed_rewards.setup(reward_manager.address, recovery_gauge.address, min_epoch_duration, sender=alice) + fixed_rewards.setup(reward_manager.address, test_gauge.address, min_epoch_duration, sender=alice) -def test_set_reward_manager_revert_already_set(bob, reward_manager, recovery_gauge, fixed_rewards): +def test_set_reward_manager_revert_already_set(bob, reward_manager, test_gauge, fixed_rewards): min_epoch_duration = 3 * DAY - fixed_rewards.setup(reward_manager.address, recovery_gauge.address, min_epoch_duration, sender=bob) + fixed_rewards.setup(reward_manager.address, test_gauge.address, min_epoch_duration, sender=bob) with ape.reverts("Setup already completed"): - fixed_rewards.setup(reward_manager.address, recovery_gauge.address, min_epoch_duration, sender=bob) + fixed_rewards.setup(reward_manager.address, test_gauge.address, min_epoch_duration, sender=bob) def test_set_reward_epochs(charlie, fixed_rewards): new_epochs = [1 * 10**18, 2 * 10**18, 3 * 10**18] @@ -63,7 +64,7 @@ def test_set_reward_epochs_revert_invalid_length(charlie, fixed_rewards): #with ape.reverts("Must set between 1 and 52 epochs"): # fixed_rewards.set_reward_epochs(new_epochs, sender=charlie) -def test_distribution_after_set_epochs(alice, bob, charlie, reward_manager, fixed_rewards, reward_token, recovery_gauge, chain): +def test_distribution_after_set_epochs(alice, bob, charlie, reward_manager, fixed_rewards, reward_token, test_gauge, chain): new_epochs = [1 * 10**18, 2 * 10**18, 3 * 10**18] min_epoch_duration = 4 * DAY @@ -71,13 +72,13 @@ def test_distribution_after_set_epochs(alice, bob, charlie, reward_manager, fixe fixed_rewards.set_reward_epochs(new_epochs, sender=charlie) # Setup the reward manager and receiver addresses with 3 day epoch duration - fixed_rewards.setup(reward_manager.address, recovery_gauge.address, min_epoch_duration, sender=charlie) + fixed_rewards.setup(reward_manager.address, test_gauge.address, min_epoch_duration, sender=charlie) # First distribution - should be 3 tokens fixed_rewards.distribute_reward(sender=bob) assert fixed_rewards.get_number_of_remaining_epochs() == 2 - assert reward_token.balanceOf(recovery_gauge) == 3 * 10**18 + assert reward_token.balanceOf(test_gauge) == 3 * 10**18 # Move time forward one week chain.pending_timestamp = chain.pending_timestamp + min_epoch_duration @@ -86,7 +87,7 @@ def test_distribution_after_set_epochs(alice, bob, charlie, reward_manager, fixe # Second distribution - should be 2 tokens fixed_rewards.distribute_reward(sender=bob) assert fixed_rewards.get_number_of_remaining_epochs() == 1 - assert reward_token.balanceOf(recovery_gauge) == 5 * 10**18 + assert reward_token.balanceOf(test_gauge) == 5 * 10**18 # Move time forward one week chain.pending_timestamp = chain.pending_timestamp + min_epoch_duration @@ -95,25 +96,25 @@ def test_distribution_after_set_epochs(alice, bob, charlie, reward_manager, fixe # Third distribution - should be 1 token fixed_rewards.distribute_reward(sender=bob) assert fixed_rewards.get_number_of_remaining_epochs() == 0 - assert reward_token.balanceOf(recovery_gauge) == 6 * 10**18 + assert reward_token.balanceOf(test_gauge) == 6 * 10**18 -def test_set_reward_manager_revert_not_owner(alice, reward_manager, recovery_gauge, fixed_rewards): +def test_set_reward_manager_revert_not_owner(alice, reward_manager, test_gauge, fixed_rewards): with ape.reverts("only managers can call this function"): - fixed_rewards.setup(reward_manager.address, recovery_gauge.address, 3 * DAY, sender=alice) + fixed_rewards.setup(reward_manager.address, test_gauge.address, 3 * DAY, sender=alice) -def test_distribution_order(alice, bob, charlie, reward_manager, fixed_rewards, reward_token, recovery_gauge, chain): +def test_distribution_order(alice, bob, charlie, reward_manager, fixed_rewards, reward_token, test_gauge, chain): # Setup the reward manager and receiver new_epochs = [2 * 10**18, 1 * 10**18, 5 * 10**18] min_epoch_duration = 3 * DAY fixed_rewards.set_reward_epochs(new_epochs, sender=charlie) - fixed_rewards.setup(reward_manager.address, recovery_gauge.address, min_epoch_duration, sender=charlie) + fixed_rewards.setup(reward_manager.address, test_gauge.address, min_epoch_duration, sender=charlie) # First distribution - should be 5 tokens fixed_rewards.distribute_reward(sender=bob) assert fixed_rewards.get_number_of_remaining_epochs() == 2 - assert reward_token.balanceOf(recovery_gauge) == 5 * 10**18 + assert reward_token.balanceOf(test_gauge) == 5 * 10**18 # Move time forward one week chain.pending_timestamp = chain.pending_timestamp + min_epoch_duration @@ -122,7 +123,7 @@ def test_distribution_order(alice, bob, charlie, reward_manager, fixed_rewards, # Second distribution - should be 1 tokens fixed_rewards.distribute_reward(sender=bob) assert fixed_rewards.get_number_of_remaining_epochs() == 1 - assert reward_token.balanceOf(recovery_gauge) == 6 * 10**18 + assert reward_token.balanceOf(test_gauge) == 6 * 10**18 # Move time forward one week chain.pending_timestamp = chain.pending_timestamp + min_epoch_duration @@ -131,16 +132,16 @@ def test_distribution_order(alice, bob, charlie, reward_manager, fixed_rewards, # Third distribution - should be 2 tokens fixed_rewards.distribute_reward(sender=bob) assert fixed_rewards.get_number_of_remaining_epochs() == 0 - assert reward_token.balanceOf(recovery_gauge) == 8 * 10**18 + assert reward_token.balanceOf(test_gauge) == 8 * 10**18 -def test_distribution_timing(alice, bob, charlie, reward_manager, fixed_rewards, recovery_gauge, chain): +def test_distribution_timing(alice, bob, charlie, reward_manager, fixed_rewards, test_gauge, chain): new_epochs = [2 * 10**18, 1 * 10**18, 5 * 10**18] min_epoch_duration = 3 * DAY fixed_rewards.set_reward_epochs(new_epochs, sender=charlie) # Setup the reward manager and receiver - fixed_rewards.setup(reward_manager.address, recovery_gauge.address, min_epoch_duration, sender=charlie) + fixed_rewards.setup(reward_manager.address, test_gauge.address, min_epoch_duration, sender=charlie) # First distribution can happen immediately fixed_rewards.distribute_reward(sender=bob) @@ -175,13 +176,13 @@ def test_distribute_revert_no_reward_manager(bob, fixed_rewards): with ape.reverts("Setup not completed"): fixed_rewards.distribute_reward(sender=bob) -def test_distribute_revert_no_epochs(alice, bob, charlie, reward_manager, fixed_rewards, recovery_gauge, chain): +def test_distribute_revert_no_epochs(alice, bob, charlie, reward_manager, fixed_rewards, test_gauge, chain): new_epochs = [2 * 10**18, 1 * 10**18, 5 * 10**18] min_epoch_duration = 3 * DAY fixed_rewards.set_reward_epochs(new_epochs, sender=charlie) # Setup the reward manager and receiver - fixed_rewards.setup(reward_manager.address, recovery_gauge.address, min_epoch_duration, sender=charlie) + fixed_rewards.setup(reward_manager.address, test_gauge.address, min_epoch_duration, sender=charlie) # Distribute all epochs for i in range(3): @@ -194,13 +195,13 @@ def test_distribute_revert_no_epochs(alice, bob, charlie, reward_manager, fixed_ with ape.reverts("No remaining reward epochs"): fixed_rewards.distribute_reward(sender=bob) -def test_get_next_epoch_info(alice, bob, charlie, reward_manager, fixed_rewards, recovery_gauge, chain): +def test_get_next_epoch_info(alice, bob, charlie, reward_manager, fixed_rewards, test_gauge, chain): new_epochs = [2 * 10**18, 1 * 10**18, 5 * 10**18] min_epoch_duration = 3 * DAY fixed_rewards.set_reward_epochs(new_epochs, sender=charlie) # Setup the reward manager and receiver - fixed_rewards.setup(reward_manager.address, recovery_gauge.address, min_epoch_duration, sender=charlie) + fixed_rewards.setup(reward_manager.address, test_gauge.address, min_epoch_duration, sender=charlie) # Check initial next epoch amount, time_until = fixed_rewards.get_next_epoch_info() @@ -215,13 +216,13 @@ def test_get_next_epoch_info(alice, bob, charlie, reward_manager, fixed_rewards, assert amount == 1 * 10**18 # Second epoch amount assert time_until > 0 # Should have time restriction now -def test_get_next_epoch_info_revert_no_epochs(alice, bob, charlie, reward_manager, fixed_rewards, recovery_gauge, chain): +def test_get_next_epoch_info_revert_no_epochs(alice, bob, charlie, reward_manager, fixed_rewards, test_gauge, chain): new_epochs = [2 * 10**18, 1 * 10**18, 5 * 10**18] fixed_rewards.set_reward_epochs(new_epochs, sender=charlie) min_epoch_duration = 3 * DAY # Setup the reward manager and receiver - fixed_rewards.setup(reward_manager.address, recovery_gauge.address, min_epoch_duration, sender=charlie) + fixed_rewards.setup(reward_manager.address, test_gauge.address, min_epoch_duration, sender=charlie) # Distribute all epochs for i in range(3): @@ -234,13 +235,13 @@ def test_get_next_epoch_info_revert_no_epochs(alice, bob, charlie, reward_manage with ape.reverts("No remaining reward epochs"): fixed_rewards.get_next_epoch_info() -def test_remaining_epochs_count(alice, bob, charlie, reward_manager, fixed_rewards, recovery_gauge, chain): +def test_remaining_epochs_count(alice, bob, charlie, reward_manager, fixed_rewards, test_gauge, chain): new_epochs = [2 * 10**18, 1 * 10**18, 5 * 10**18] min_epoch_duration = 4 * DAY fixed_rewards.set_reward_epochs(new_epochs, sender=charlie) # Setup the reward manager and receiver - fixed_rewards.setup(reward_manager.address, recovery_gauge.address, min_epoch_duration, sender=charlie) + fixed_rewards.setup(reward_manager.address, test_gauge.address, min_epoch_duration, sender=charlie) # Distribute epochs and check count fixed_rewards.distribute_reward(sender=bob) @@ -260,36 +261,36 @@ def test_min_epoch_duration_default(fixed_rewards): """Test that min_epoch_duration is initialized to WEEK""" assert fixed_rewards.min_epoch_duration() == WEEK -def test_setup_with_custom_epoch_duration(bob, reward_manager, recovery_gauge, fixed_rewards): +def test_setup_with_custom_epoch_duration(bob, reward_manager, test_gauge, fixed_rewards): """Test setting a custom min_epoch_duration during setup""" custom_duration = 4 * DAY # 4 days - fixed_rewards.setup(reward_manager.address, recovery_gauge.address, custom_duration, sender=bob) + fixed_rewards.setup(reward_manager.address, test_gauge.address, custom_duration, sender=bob) assert fixed_rewards.min_epoch_duration() == custom_duration assert fixed_rewards.is_setup_complete() -def test_setup_revert_epoch_too_short(bob, reward_manager, recovery_gauge, fixed_rewards): +def test_setup_revert_epoch_too_short(bob, reward_manager, test_gauge, fixed_rewards): """Test that setting too short epoch duration reverts""" too_short = 2 * DAY # 2 days (minimum is 3 days) with ape.reverts("epoch duration must be between 3 days and a year"): - fixed_rewards.setup(reward_manager.address, recovery_gauge.address, too_short, sender=bob) + fixed_rewards.setup(reward_manager.address, test_gauge.address, too_short, sender=bob) -def test_setup_revert_epoch_too_long(bob, reward_manager, recovery_gauge, fixed_rewards): +def test_setup_revert_epoch_too_long(bob, reward_manager, test_gauge, fixed_rewards): """Test that setting too long epoch duration reverts""" too_long = 53 * WEEK # More than a year with ape.reverts("epoch duration must be between 3 days and a year"): - fixed_rewards.setup(reward_manager.address, recovery_gauge.address, too_long, sender=bob) + fixed_rewards.setup(reward_manager.address, test_gauge.address, too_long, sender=bob) -def test_distribution_respects_min_epoch_duration(bob, charlie, reward_manager, fixed_rewards, recovery_gauge, chain): +def test_distribution_respects_min_epoch_duration(bob, charlie, reward_manager, fixed_rewards, test_gauge, chain): """Test that distribution timing respects custom min_epoch_duration""" # Setup with 4-day minimum duration custom_duration = 4 * DAY new_epochs = [1 * 10**18, 2 * 10**18] fixed_rewards.set_reward_epochs(new_epochs, sender=charlie) - fixed_rewards.setup(reward_manager.address, recovery_gauge.address, custom_duration, sender=bob) + fixed_rewards.setup(reward_manager.address, test_gauge.address, custom_duration, sender=bob) # First distribution should work fixed_rewards.distribute_reward(sender=bob) diff --git a/tests/RewardManager/conftest.py b/tests/RewardManager/conftest.py index 4ebb655..160a2ec 100644 --- a/tests/RewardManager/conftest.py +++ b/tests/RewardManager/conftest.py @@ -23,17 +23,17 @@ def lost_token(project, alice, charlie): @pytest.fixture(scope="module") -def recovery_gauge(project, alice, charlie, diana, reward_token): +def test_gauge(project, alice, charlie, diana, reward_token): # bob manager address # diana is recovery address - gauge = alice.deploy(project.RecoveryGauge, reward_token, diana) + gauge = alice.deploy(project.TestGauge, reward_token, diana) return gauge @pytest.fixture(scope="module") -def reward_manager(project, alice, bob, charlie, diana, reward_token, recovery_gauge): +def reward_manager(project, alice, bob, charlie, diana, reward_token, test_gauge): # bob manager address # diana is recovery address - reward_manager_contract = alice.deploy(project.RewardManager, [bob, charlie], reward_token, [recovery_gauge], diana) + reward_manager_contract = alice.deploy(project.RewardManager, [bob, charlie], reward_token, [test_gauge], diana) reward_token.approve(reward_manager_contract, 10 ** 19, sender=bob) print(reward_manager_contract) return reward_manager_contract \ No newline at end of file diff --git a/tests/RewardManager/test_deposit_reward.py b/tests/RewardManager/test_deposit_reward.py index f5e67a1..fa7a816 100644 --- a/tests/RewardManager/test_deposit_reward.py +++ b/tests/RewardManager/test_deposit_reward.py @@ -12,49 +12,49 @@ def test_reward_manager_manager(bob, charlie, reward_manager): def test_reward_manager_reward_token(bob, reward_token, reward_manager): assert reward_manager.reward_token() == reward_token -def test_reward_manager_receivers(bob, recovery_gauge, reward_manager): - reward_receivers = reward_manager.reward_receivers(0) - print(reward_receivers) - assert recovery_gauge == reward_receivers +def test_reward_manager_receivers(bob, test_gauge, reward_manager): + receiving_gauges = reward_manager.receiving_gauges(0) + print(receiving_gauges) + assert test_gauge == receiving_gauges # send reward token to reward manager contract, then deposit_reward_tokens -def test_reward_manager_send_reward_token(alice, bob, diana, reward_token, recovery_gauge, reward_manager): +def test_reward_manager_send_reward_token(alice, bob, diana, reward_token, test_gauge, reward_manager): amount = 10 ** 16 reward_manager_balance = reward_token.balanceOf(reward_manager, sender=alice) assert reward_manager_balance == 0 reward_token.transferFrom(bob, reward_manager, amount, sender=bob) reward_manager_balance = reward_token.balanceOf(reward_manager, sender=alice) assert reward_manager_balance == amount - reward_manager.send_reward_token(recovery_gauge, amount, sender=bob) - assert recovery_gauge.recover_token(sender=alice) + reward_manager.send_reward_token(test_gauge, amount, sender=bob) + assert test_gauge.recover_token(sender=alice) balance_recoverd = reward_token.balanceOf(diana, sender=alice) assert amount == balance_recoverd assert amount == reward_manager_balance -def test_reward_manager_send_reward_token_epoch(alice, bob, diana, reward_token, recovery_gauge, reward_manager): +def test_reward_manager_send_reward_token_epoch(alice, bob, diana, reward_token, test_gauge, reward_manager): amount = 10 ** 16 reward_manager_balance = reward_token.balanceOf(reward_manager, sender=alice) assert reward_manager_balance == 0 reward_token.transferFrom(bob, reward_manager, amount, sender=bob) reward_manager_balance = reward_token.balanceOf(reward_manager, sender=alice) assert reward_manager_balance == amount - reward_manager.send_reward_token(recovery_gauge, amount, 8 * DAY, sender=bob) - assert recovery_gauge.recover_token(sender=alice) + reward_manager.send_reward_token(test_gauge, amount, 8 * DAY, sender=bob) + assert test_gauge.recover_token(sender=alice) balance_recoverd = reward_token.balanceOf(diana, sender=alice) assert amount == balance_recoverd assert amount == reward_manager_balance -def test_reward_manager_sent_revert(alice, recovery_gauge, reward_manager): +def test_reward_manager_sent_revert(alice, test_gauge, reward_manager): with ape.reverts("only reward managers can call this function"): - reward_manager.send_reward_token(recovery_gauge, 10 ** 18, sender=alice) + reward_manager.send_reward_token(test_gauge, 10 ** 18, sender=alice) -def test_reward_manager_epoch_revert_too_short(bob, recovery_gauge, reward_manager): +def test_reward_manager_epoch_revert_too_short(bob, test_gauge, reward_manager): with ape.reverts("epoch duration must be between 3 days and a year"): - reward_manager.send_reward_token(recovery_gauge, 10 ** 18, DAY, sender=bob) + reward_manager.send_reward_token(test_gauge, 10 ** 18, DAY, sender=bob) -def test_reward_manager_epoch_revert_too_long(bob, recovery_gauge, reward_manager): +def test_reward_manager_epoch_revert_too_long(bob, test_gauge, reward_manager): with ape.reverts("epoch duration must be between 3 days and a year"): - reward_manager.send_reward_token(recovery_gauge, 10 ** 18, 53 * WEEK, sender=bob) + reward_manager.send_reward_token(test_gauge, 10 ** 18, 53 * WEEK, sender=bob) def test_recover_token(bob, charlie, diana, lost_token, reward_manager): amount = 10 ** 18 diff --git a/tests/RewardManager/test_recovery_gauge.py b/tests/RewardManager/test_recovery_gauge.py index 5b11e44..b1d6ff2 100644 --- a/tests/RewardManager/test_recovery_gauge.py +++ b/tests/RewardManager/test_recovery_gauge.py @@ -3,24 +3,24 @@ import sys -def test_recovery_gauge_reward_token(recovery_gauge, reward_token): - assert recovery_gauge.reward_token() == reward_token +def test_test_gauge_reward_token(test_gauge, reward_token): + assert test_gauge.reward_token() == reward_token -def test_recovery_gauge_recovery_address(diana, recovery_gauge): - assert recovery_gauge.recovery_address() == diana +def test_test_gauge_recovery_address(diana, test_gauge): + assert test_gauge.recovery_address() == diana -def test_recovery_gauge_deposit_reward_token(bob, recovery_gauge, reward_token): +def test_test_gauge_deposit_reward_token(bob, test_gauge, reward_token): balance = reward_token.balanceOf(bob) - assert reward_token.approve(recovery_gauge, balance, sender=bob) + assert reward_token.approve(test_gauge, balance, sender=bob) print(balance) - recovery_gauge.deposit_reward_token(reward_token, balance, sender=bob) + test_gauge.deposit_reward_token(reward_token, balance, sender=bob) -def test_recovery_gauge_recover_token(alice, bob, diana, recovery_gauge, reward_token): +def test_test_gauge_recover_token(alice, bob, diana, test_gauge, reward_token): balance = reward_token.balanceOf(bob) - assert reward_token.approve(recovery_gauge, balance, sender=bob) - recovery_gauge.deposit_reward_token(reward_token, balance, sender=bob) + assert reward_token.approve(test_gauge, balance, sender=bob) + test_gauge.deposit_reward_token(reward_token, balance, sender=bob) - assert recovery_gauge.recover_token(sender=alice) + assert test_gauge.recover_token(sender=alice) balance_recoverd = reward_token.balanceOf(diana, sender=alice) assert balance_recoverd == balance \ No newline at end of file