def test_deploy_plain_pool_revert(base_pool, new_factory, new_factory_setup,
bob):
coin = ERC20(decimals=7)
new_factory.deploy_metapool(base_pool, "Name", "SYM", coin, 12345,
50000000, 0, {"from": bob})
existing_coin = base_pool.coins(0)
assert new_factory.base_pool_assets(existing_coin)
coins = [existing_coin, ERC20(decimals=9), ZERO_ADDRESS, ZERO_ADDRESS]
# should revert because a metapool already exists for one of the coins
with brownie.reverts("Invalid asset, deploy a metapool"):
new_factory.deploy_plain_pool("Test Plain", "TST", coins, 12345,
50000000, {"from": bob})
def _plain_coins(alice, decimals):
return_true_revert = [
ERC20(decimals=precision, deployer=alice) for precision in decimals
]
return_true_false = [
ERC20(fail=False, decimals=precision, deployer=alice)
for precision in decimals
]
return_none_revert = [
ERC20(success=None, decimals=precision, deployer=alice)
for precision in decimals
]
return [return_true_revert, return_true_false, return_none_revert]
def test_state_machine(state_machine, accounts):
# setup
owner = accounts[0]
distributor = accounts[1]
duration = DAY * 10
# deploy reward token, and mint
reward_token = ERC20()
# deploy stream and approve
reward_stream = owner.deploy(RewardStream, owner, distributor,
reward_token, duration)
# settings = {"stateful_step_count": 25}
state_machine(
StateMachine,
accounts,
owner,
distributor,
duration,
reward_token,
reward_stream,
# settings=settings,
)
def token(request, alice):
success, fail = request.param
if None in (fail, success) and fail is not success:
pytest.skip()
contract = ERC20(success=success, fail=fail)
contract._mint_for_testing(alice, 10**18, {"from": alice})
yield (contract, success, fail)
def test_base_rewards_and_additional_rewards_are_distributed(
alice, chain, base_gauge, meta_gauge, coin_reward):
# base rewards aren't distributed over the course of a week, instead they are instantly
# distributed amongst the LPs in the pool. This is because the base_gauge already has some form
# of delay, adding a second delay would not make much sense.
dummy_reward = ERC20()
dummy_reward._mint_for_testing(alice, REWARD, {"from": alice})
dummy_reward.approve(meta_gauge, 2**256 - 1, {"from": alice})
base_gauge.set_rewards(ZERO_ADDRESS, "0x0",
[coin_reward] + [ZERO_ADDRESS] * 7, {"from": alice})
coin_reward._mint_for_testing(base_gauge, REWARD, {"from": alice})
assert coin_reward.balanceOf(alice) == 0
meta_gauge.add_reward(dummy_reward, alice, {"from": alice})
meta_gauge.deposit_reward_token(dummy_reward, REWARD, {"from": alice})
chain.sleep(86400)
meta_gauge.claim_rewards({"from": alice})
assert coin_reward.balanceOf(alice) == REWARD
assert math.isclose(dummy_reward.balanceOf(alice),
REWARD // 7,
rel_tol=0.0001)
def test_state_machine(state_machine, accounts, VotingEscrow):
token = ERC20("", "", 18)
voting_escrow = VotingEscrow.deploy(
token, "Voting-escrowed CRV", "veCRV", "veCRV_0.99", {"from": accounts[0]}
)
state_machine(StateMachine, accounts[:10], token, voting_escrow, settings={"max_examples": 30})
def test_pool_count(new_factory, coins, new_factory_setup, bob, base_pool):
tx = new_factory.deploy_plain_pool("Test Plain", "TST", coins, 12345,
50000000, 0, 0, {"from": bob})
assert tx.return_value == tx.new_contracts[0]
assert new_factory.pool_count() == 1
coin = ERC20(decimals=7)
tx = new_factory.deploy_metapool(base_pool, "Name", "SYM", coin, 12345,
50000000, 0, {"from": bob})
assert tx.return_value == tx.new_contracts[0]
assert new_factory.pool_count() == 2
coin = ERC20(decimals=7)
pool = Contract("0x7fC77b5c7614E1533320Ea6DDc2Eb61fa00A9714")
tx = new_factory.deploy_metapool(pool, "Name", "SYM", coin, 123456,
50000000, 0, {"from": bob})
assert new_factory.pool_count() == 3
def test_deploy_metapool(MetaImplementationUSD, factory, base_pool, alice, bob):
coin = ERC20(decimals=7)
tx = factory.deploy_metapool(base_pool, "Name", "SYM", coin, 12345, 50000000, {'from': bob})
assert tx.return_value == tx.new_contracts[0]
swap = MetaImplementationUSD.at(tx.return_value)
assert swap.coins(0) == coin
assert swap.A() == 12345
assert swap.fee() == 50000000
assert swap.admin() == alice
assert factory.pool_count() == 3
assert factory.pool_list(2) == swap
assert factory.get_decimals(swap) == [7, 18]
def test_deploy_metapool(MetaUSD, new_factory, new_factory_setup, base_pool,
bob):
coin = ERC20(decimals=7)
tx = new_factory.deploy_metapool(base_pool, "Name", "SYM", coin, 12345,
50000000, 0, {"from": bob})
assert tx.return_value == tx.new_contracts[0]
swap = MetaUSD.at(tx.return_value)
assert swap.coins(0) == coin
assert swap.A() == 12345
assert swap.fee() == 50000000
assert new_factory.pool_count() == 1
assert new_factory.pool_list(0) == swap
assert new_factory.get_decimals(swap) == [7, 18, 0, 0]
def new_base_pool(alice, CurveTokenV3, CurvePool, registry):
lp_token = CurveTokenV3.deploy("Test LP Token", "Tester", {"from": alice})
base_coins = [ERC20() for _ in range(3)]
pool = CurvePool.deploy(alice, base_coins, lp_token, 200, 3000000,
5000000000, {"from": alice})
lp_token.set_minter(pool, {"from": alice})
registry.add_pool_without_underlying(
pool,
3,
lp_token,
"0x0",
pack_values([18, 18, 18]),
pack_values([0, 0, 0]),
True,
False,
"Test Base Pool",
)
return pool
def coin_reward():
return ERC20()
def coin_b():
return ERC20()
def coin_a():
return ERC20()
def coin(pytestconfig):
yield ERC20(
decimals=pytestconfig.getoption('decimals'),
success=eval(pytestconfig.getoption('return_value')),
)
def test_cant_exceed_max(alice, gauge):
for _ in range(8):
gauge.add_reward(ERC20(), alice, {"from": alice})
with brownie.reverts():
gauge.add_reward(ERC20(), alice, {"from": alice})
def coins(alice):
contracts = [ERC20() for i in range(3)]
for c in contracts:
c._mint_for_testing(alice, 10**18, {'from': alice})
return contracts
def token2(bob, swap, lp_token):
contract = ERC20()
contract._mint_for_testing(bob, 1000000 * 10**18)
contract.approve(lp_token, 2**256 - 1, {'from': bob})
return contract
def reward_token(bob):
token = ERC20()
token._mint_for_testing(bob, 10**19)
return token
def token2(alice, bob):
contract = ERC20()
contract._mint_for_testing(alice, 1000000 * 10**18)
contract._mint_for_testing(bob, 1000000 * 10**18)
yield contract
def base_coins(alice):
return [ERC20(deployer=alice) for _ in range(3)]
def coin_b():
yield ERC20("Coin B", "USDB", 18)
def coin_reward():
yield ERC20("YFIIIIII Funance", "YFIIIIII", 18)
def coins(alice):
yield [ERC20() for i in range(3)]
def coin_c():
yield ERC20("Coin C", "mWBTC", 8)
def coin_a():
yield ERC20("Coin A", "USDA", 18)