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)
