def test_claim_historic_while_active(alice, bob, chain, gauge_v2, coin_reward): amount = gauge_v2.balanceOf(alice) // 2 chain.sleep(int(86400 * 3.5)) gauge_v2.transfer(bob, amount, {"from": alice}) chain.sleep(WEEK) # this should have no effect gauge_v2.claim_historic_rewards([coin_reward] + [ZERO_ADDRESS] * 7, {"from": alice}) gauge_v2.claim_historic_rewards([coin_reward] + [ZERO_ADDRESS] * 7, {"from": bob}) assert approx(coin_reward.balanceOf(alice) / REWARD, 0.5, 1e-4) assert coin_reward.balanceOf(bob) == 0 # correctly claiming after `claim_historic_rewards` should still work as expected rewards = [] for acct in (alice, bob): gauge_v2.claim_rewards({"from": acct}) rewards += [coin_reward.balanceOf(acct)] assert sum(rewards) <= REWARD assert approx(rewards[0] / rewards[1], 3, 1e-4) assert approx(REWARD, sum(rewards), 1.001 / WEEK)
def test_claim_two_lp(alice, bob, chain, gauge_v2, mock_lp_token, coin_reward, no_call_coverage): # Deposit mock_lp_token.approve(gauge_v2, LP_AMOUNT, {'from': alice}) gauge_v2.deposit(LP_AMOUNT, {'from': alice}) chain.sleep(WEEK) chain.mine() # Calculate rewards claimable_rewards = [ gauge_v2.claimable_reward.call(acc, coin_reward, {'from': acc}) for acc in (alice, bob) ] # Claim rewards rewards = [] for acct in (alice, bob): gauge_v2.claim_rewards({'from': acct}) rewards += [coin_reward.balanceOf(acct)] # Calculation == results assert tuple(claimable_rewards) == tuple(rewards) # Approximately equal apart from what caused by 1 s ganache-cli jitter assert sum(rewards) <= REWARD assert approx(sum(rewards), REWARD, 1.001 / WEEK) # ganache-cli jitter of 1 s assert approx(rewards[0], rewards[1], 2.002 * WEEK)
def test_duration(accounts, rpc, liquidity_gauge, minter, token, st_duration): accts = accounts[1:] deposit_time = [] for i in range(3): tx = liquidity_gauge.deposit(10**18, {'from': accts[i]}) deposit_time.append(tx.timestamp) durations = [] balances = [] for i in range(3): rpc.sleep(st_duration[i]) tx = liquidity_gauge.withdraw(10**18, {'from': accts[i]}) durations.append(tx.timestamp - deposit_time[i]) minter.mint(liquidity_gauge, {'from': accts[i]}) balances.append(token.balanceOf(accts[i])) total_minted = sum(balances) weight1 = durations[0] weight2 = weight1 + (durations[1] - durations[0]) * 1.5 weight3 = weight2 + (durations[2] - durations[1]) * 3 total_weight = weight1 + weight2 + weight3 assert approx(balances[0] / total_minted, weight1 / total_weight, 1e-4) assert approx(balances[1] / total_minted, weight2 / total_weight, 1e-4) assert approx(balances[2] / total_minted, weight3 / total_weight, 1e-4)
def test_claim_two_lp( accounts, chain, liquidity_gauge_reward, mock_lp_token, coin_reward, no_call_coverage ): # Deposit mock_lp_token.approve(liquidity_gauge_reward, LP_AMOUNT, {"from": accounts[0]}) liquidity_gauge_reward.deposit(LP_AMOUNT, {"from": accounts[0]}) chain.sleep(WEEK) # Claim rewards rewards = [] for i in range(2): liquidity_gauge_reward.claim_rewards({"from": accounts[i]}) rewards += [coin_reward.balanceOf(accounts[i])] # Calculate rewards claimable_rewards = [ liquidity_gauge_reward.claimable_reward(acc, {"from": acc}) for acc in accounts[:2] ] # Calculation == results assert tuple(claimable_rewards) == tuple(rewards) # Approximately equal apart from what caused by 1 s ganache-cli jitter assert sum(rewards) <= REWARD assert approx(sum(rewards), REWARD, 1.001 / WEEK) # ganache-cli jitter of 1 s assert approx(rewards[0], rewards[1], 2.002 * WEEK)
def test_amounts(accounts, rpc, liquidity_gauge, minter, token, st_amounts): accts = accounts[1:] deposit_time = [] for i in range(3): tx = liquidity_gauge.deposit(st_amounts[i], {'from': accts[i]}) deposit_time.append(tx.timestamp) rpc.sleep(MONTH) balances = [] for i in range(3): liquidity_gauge.withdraw(st_amounts[i], {'from': accts[i]}) for i in range(3): minter.mint(liquidity_gauge, {'from': accts[i]}) balances.append(token.balanceOf(accts[i])) total_deposited = sum(st_amounts) total_minted = sum(balances) assert approx(balances[0] / total_minted, st_amounts[0] / total_deposited, 1e-4) assert approx(balances[1] / total_minted, st_amounts[1] / total_deposited, 1e-4) assert approx(balances[2] / total_minted, st_amounts[2] / total_deposited, 1e-4)
def test_transfer_full_balance(alice, bob, chain, gauge_v2, coin_reward): amount = gauge_v2.balanceOf(alice) gauge_v2.transfer(bob, amount, {'from': alice}) chain.sleep(WEEK) rewards = [] for acct in (alice, bob): gauge_v2.claim_rewards({'from': acct}) rewards += [coin_reward.balanceOf(acct)] assert sum(rewards) <= REWARD assert approx(rewards[0], rewards[1], 1e-4) assert approx(REWARD, sum(rewards), 1.001 / WEEK)
def test_transfer_full_balance(alice, bob, chain, rewards_only_gauge, coin_reward): amount = rewards_only_gauge.balanceOf(alice) rewards_only_gauge.transfer(bob, amount, {"from": alice}) chain.sleep(WEEK) rewards = [] for acct in (alice, bob): rewards_only_gauge.claim_rewards({"from": acct}) rewards += [coin_reward.balanceOf(acct)] assert sum(rewards) <= REWARD assert approx(rewards[0], rewards[1], 1e-4) assert approx(REWARD, sum(rewards), 1.001 / WEEK)
def test_transfer_triggers_claim_for_receiver(alice, bob, chain, gauge_v2, coin_reward): amount = gauge_v2.balanceOf(alice) // 2 gauge_v2.transfer(bob, amount, {"from": alice}) chain.sleep(WEEK) gauge_v2.transfer(alice, amount, {"from": bob}) rewards = [] for acct in (alice, bob): gauge_v2.claim_rewards({"from": acct}) rewards += [coin_reward.balanceOf(acct)] assert sum(rewards) <= REWARD assert approx(rewards[0] / rewards[1], 3, 1e-4) assert approx(REWARD, sum(rewards), 1.001 / WEEK)
def test_transfer_triggers_claim_for_sender(alice, bob, chain, gauge_v2, coin_reward): amount = gauge_v2.balanceOf(alice) gauge_v2.transfer(bob, amount, {"from": alice}) reward = coin_reward.balanceOf(alice) assert approx(REWARD // 2, reward, 1e-4)
def test_claim_historic_multiple(alice, chain, coin_reward, coin_a, reward_contract, reward_contract_2, gauge_v2): chain.sleep(WEEK) sigs = [ reward_contract.stake.signature[2:], reward_contract.withdraw.signature[2:], reward_contract.getReward.signature[2:], ] sigs = f"0x{sigs[0]}{sigs[1]}{sigs[2]}{'00' * 20}" gauge_v2.set_rewards(reward_contract_2, sigs, [coin_a] + [ZERO_ADDRESS] * 7, {"from": alice}) coin_a._mint_for_testing(REWARD, {"from": reward_contract_2}) reward_contract_2.notifyRewardAmount(REWARD, {"from": alice}) chain.sleep(WEEK) gauge_v2.set_rewards(ZERO_ADDRESS, "0x00", [ZERO_ADDRESS] * 8, {"from": alice}) gauge_v2.claim_historic_rewards([coin_reward, coin_a] + [ZERO_ADDRESS] * 6, {"from": alice}) for coin in (coin_reward, coin_a): reward = coin.balanceOf(alice) assert reward <= REWARD assert approx(REWARD, reward, 1.001 / WEEK)
def test_claim_one_lp(bob, chain, gauge_v2, coin_reward): chain.sleep(WEEK) gauge_v2.withdraw(LP_AMOUNT, {'from': bob}) gauge_v2.claim_rewards({'from': bob}) reward = coin_reward.balanceOf(bob) assert reward <= REWARD assert approx(REWARD, reward, 1.001 / WEEK) # ganache-cli jitter of 1 s
def test_claim_one_lp(accounts, chain, liquidity_gauge_reward, coin_reward): chain.sleep(WEEK) liquidity_gauge_reward.withdraw(LP_AMOUNT, {"from": accounts[1]}) liquidity_gauge_reward.claim_rewards({"from": accounts[1]}) reward = coin_reward.balanceOf(accounts[1]) assert reward <= REWARD assert approx(REWARD, reward, 1.001 / WEEK) # ganache-cli jitter of 1 s
def test_claim_for_other(bob, charlie, chain, rewards_only_gauge, coin_reward): rewards_only_gauge.withdraw(LP_AMOUNT, {"from": bob}) rewards_only_gauge.claim_rewards(bob, {"from": charlie}) assert coin_reward.balanceOf(charlie) == 0 reward = coin_reward.balanceOf(bob) assert reward <= REWARD assert approx(REWARD, reward, 1.001 / WEEK) # ganache-cli jitter of 1 s
def test_claim_one_lp(bob, chain, rewards_only_gauge, coin_a, coin_b): chain.sleep(WEEK) rewards_only_gauge.withdraw(LP_AMOUNT, {"from": bob}) rewards_only_gauge.claim_rewards({"from": bob}) for coin in (coin_a, coin_b): reward = coin.balanceOf(bob) assert reward <= REWARD assert approx(REWARD, reward, 1.001 / WEEK) # ganache-cli jitter of 1 s
def test_claim_for_other(bob, charlie, chain, gauge_v2, coin_reward): chain.sleep(WEEK) gauge_v2.withdraw(LP_AMOUNT, {'from': bob}) gauge_v2.claim_rewards(bob, {'from': charlie}) assert coin_reward.balanceOf(charlie) == 0 reward = coin_reward.balanceOf(bob) assert reward <= REWARD assert approx(REWARD, reward, 1.001 / WEEK) # ganache-cli jitter of 1 s
def test_claim_for_other(accounts, chain, liquidity_gauge_reward, coin_reward): chain.sleep(WEEK) liquidity_gauge_reward.withdraw(LP_AMOUNT, {'from': accounts[1]}) liquidity_gauge_reward.claim_rewards(accounts[1], {'from': accounts[2]}) assert coin_reward.balanceOf(accounts[2]) == 0 reward = coin_reward.balanceOf(accounts[1]) assert reward <= REWARD assert approx(REWARD, reward, 1.001 / WEEK) # ganache-cli jitter of 1 s
def test_claim_set_alt_receiver(bob, charlie, chain, rewards_only_gauge, coin_a, coin_b): chain.sleep(WEEK) rewards_only_gauge.claim_rewards(bob, charlie, {"from": bob}) assert coin_a.balanceOf(bob) == 0 assert coin_b.balanceOf(bob) == 0 for coin in (coin_a, coin_b): reward = coin.balanceOf(charlie) assert reward <= REWARD assert approx(REWARD, reward, 1.001 / WEEK) # ganache-cli jitter of 1 s
def test_unset_and_claim_historic(alice, chain, coin_reward, reward_contract, gauge_v2): chain.sleep(WEEK) gauge_v2.set_rewards(ZERO_ADDRESS, "0x00", [ZERO_ADDRESS] * 8, {"from": alice}) gauge_v2.claim_historic_rewards([coin_reward] + [ZERO_ADDRESS] * 7, {"from": alice}) reward = coin_reward.balanceOf(alice) assert reward <= REWARD assert approx(REWARD, reward, 1.001 / WEEK)
def test_transfer_to_self(alice, chain, rewards_only_gauge, coin_reward): sender_balance = rewards_only_gauge.balanceOf(alice) amount = sender_balance // 4 rewards_only_gauge.transfer(alice, amount, {"from": alice}) chain.sleep(WEEK) rewards_only_gauge.claim_rewards({"from": alice}) reward = coin_reward.balanceOf(alice) assert reward <= REWARD assert approx(REWARD, reward, 1.001 / WEEK)
def test_transfer_to_self(alice, chain, gauge_v2, coin_reward): sender_balance = gauge_v2.balanceOf(alice) amount = sender_balance // 4 gauge_v2.transfer(alice, amount, {'from': alice}) chain.sleep(WEEK) gauge_v2.claim_rewards({'from': alice}) reward = coin_reward.balanceOf(alice) assert reward <= REWARD assert approx(REWARD, reward, 1.001 / WEEK)
def test_transfer_zero_tokens(alice, bob, chain, gauge_v2, coin_reward): gauge_v2.transfer(bob, 0, {'from': alice}) chain.sleep(WEEK) for acct in (alice, bob): gauge_v2.claim_rewards({'from': acct}) reward = coin_reward.balanceOf(alice) assert coin_reward.balanceOf(bob) == 0 assert reward <= REWARD assert approx(REWARD, reward, 1.001 / WEEK)
def test_claim_updates_claimed_reward(bob, chain, gauge_v3, coin_a, coin_b): chain.sleep(WEEK) gauge_v3.withdraw(LP_AMOUNT, {"from": bob}) gauge_v3.claim_rewards({"from": bob}) for coin in (coin_a, coin_b): reward = coin.balanceOf(bob) assert reward <= REWARD assert approx(REWARD, reward, 1.001 / WEEK) # ganache-cli jitter of 1 s assert gauge_v3.claimed_reward(bob, coin) == reward
def test_unsetting_claims(alice, chain, coin_reward, reward_contract, gauge_v3): gauge_v3.deposit(LP_AMOUNT, {"from": alice}) coin_reward._mint_for_testing(reward_contract, REWARD) reward_contract.notifyRewardAmount(REWARD, {"from": alice}) chain.sleep(WEEK) gauge_v3.set_rewards(ZERO_ADDRESS, "0x00", [coin_reward] + [ZERO_ADDRESS] * 7, {"from": alice}) reward = coin_reward.balanceOf(gauge_v3) assert reward <= REWARD assert approx(REWARD, reward, 1.001 / WEEK)
def test_unsetting_claims(alice, chain, coin_reward, reward_contract, rewards_only_gauge): rewards_only_gauge.deposit(LP_AMOUNT, {"from": alice}) coin_reward._mint_for_testing(REWARD, {"from": reward_contract}) reward_contract.notifyRewardAmount(REWARD, {"from": alice}) chain.sleep(WEEK) rewards_only_gauge.set_rewards(ZERO_ADDRESS, "0x00", [ZERO_ADDRESS] * 8, {"from": alice}) reward = coin_reward.balanceOf(rewards_only_gauge) assert reward <= REWARD assert approx(REWARD, reward, 1.001 / WEEK)
def test_claim_one_lp(alice, bob, chain, gauge_v3, coin_a, coin_b): chain.sleep(WEEK) gauge_v3.set_rewards_receiver(alice, {"from": bob}) gauge_v3.withdraw(LP_AMOUNT, {"from": bob}) gauge_v3.claim_rewards({"from": bob}) for coin in (coin_a, coin_b): reward = coin.balanceOf(alice) assert reward <= REWARD assert approx(REWARD, reward, 1.001 / WEEK) # ganache-cli jitter of 1 s
def test_claim_for_other(bob, charlie, chain, gauge_v3, coin_a, coin_b): chain.sleep(WEEK) gauge_v3.withdraw(LP_AMOUNT, {"from": bob}) gauge_v3.claim_rewards(bob, {"from": charlie}) assert coin_a.balanceOf(charlie) == 0 for coin in (coin_a, coin_b): reward = coin.balanceOf(bob) assert reward <= REWARD assert approx(REWARD, reward, 1.001 / WEEK) # ganache-cli jitter of 1 s
def teardown(self): """ Travel far enough in future for all rewards to be distributed (1 week) and claim all """ chain.sleep(2 * 7 * 86400) rewards_claimed = 0 for act in self.accounts: self.liquidity_gauge.claim_rewards({"from": act}) rewards_claimed += self.coin_reward.balanceOf(act) if self.rewards_total > 7 * 86400: # Otherwise we may have 0 claimed precision = max(7 * 86400 / self.rewards_total * 2, 1e-10) assert approx(rewards_claimed, self.rewards_total, precision)
def test_random_range_multiple_epochs(token, chain, accounts, start, duration): creation_time = token.start_epoch_time() start += creation_time end = duration + start start_epoch = (start - creation_time) // YEAR end_epoch = (end - creation_time) // YEAR rate = int(YEAR_1_SUPPLY // YEAR / (2 ** 0.25) ** start_epoch) for i in range(end_epoch): chain.sleep(YEAR) chain.mine() token.update_mining_parameters({"from": accounts[0]}) if start_epoch == end_epoch: assert approx(token.mintable_in_timeframe(start, end), rate * (end - start), 2e-16) else: assert token.mintable_in_timeframe(start, end) < rate * end
def test_repeat_token(alice, bob, chain, coin_reward, reward_contract, gauge_v2): amount = gauge_v2.balanceOf(alice) // 2 chain.sleep(int(86400 * 3.5)) gauge_v2.transfer(bob, amount, {"from": alice}) chain.sleep(WEEK) gauge_v2.set_rewards(ZERO_ADDRESS, "0x00", [ZERO_ADDRESS] * 8, {"from": alice}) # repeated use of the same coin in `claim_historic_rewards` should have no effect gauge_v2.claim_historic_rewards([coin_reward] * 8, {"from": bob}) reward = coin_reward.balanceOf(bob) assert reward <= REWARD assert approx(reward / REWARD, 0.25, 1e-4)
def test_ratio_equality( chain, accounts, liquidity_gauge_reward, mock_lp_token, reward_contract, coin_reward, values, ): N_acc = len(values) # fund accounts to be used in the test for acct in accounts[1:N_acc]: mock_lp_token.transfer(acct, 10**21, {"from": accounts[0]}) # approve liquidity_gauge from the funded accounts for acct in accounts[:N_acc]: mock_lp_token.approve(liquidity_gauge_reward, 2**256 - 1, {"from": acct}) # Deposit for value, act in zip(values, accounts[:N_acc]): liquidity_gauge_reward.deposit(value, {"from": act}) # Fund rewards coin_reward._mint_for_testing(10**20) coin_reward.transfer(reward_contract, 10**20) reward_contract.notifyRewardAmount(10**20) chain.sleep(2 * 7 * 86400) # Claim and measure rewards rewards = [] for act in accounts[:N_acc]: before = coin_reward.balanceOf(act) liquidity_gauge_reward.claim_rewards({"from": act}) after = coin_reward.balanceOf(act) rewards.append(after - before) for v, r in zip(values, rewards): if r > 0 and v > 0: precision = max(1 / min(r, v), 1e-15) assert approx(v / sum(values), r / sum(rewards), precision)