def test_migrate_lpstrat(
currencyLP,
AlchemixETHStrategy,
strategylp,
chain,
vaultlp,
whaleLP,
gov,
strategist,
interface,
):
debt_ratio = 10_000
vaultlp.addStrategy(strategylp, debt_ratio, 0, 2 ** 256 - 1, 1_000, {"from": gov})
currencyLP.approve(vaultlp, 2 ** 256 - 1, {"from": whaleLP})
vaultlp.deposit(Wei("100 ether"), {"from": whaleLP})
strategylp.harvest({"from": strategist})
chain.sleep(2592000)
chain.mine(1)
strategylp.harvest({"from": strategist})
totalasset_beforemig = strategylp.estimatedTotalAssets()
assert totalasset_beforemig > 0
strategy2 = strategist.deploy(AlchemixETHStrategy, vaultlp)
vaultlp.migrateStrategy(strategylp, strategy2, {"from": gov})
# Check that we got all the funds on migration
assert strategy2.estimatedTotalAssets() >= totalasset_beforemig
def test_erc20_auction_twoPurchases(erc20_auction, payment_token):
token_buyer_a = accounts[2]
token_buyer_b = accounts[3]
assert erc20_auction.tokensClaimable(token_buyer_a,
{'from': accounts[0]}) == 0
assert erc20_auction.tokensClaimable(token_buyer_b,
{'from': accounts[0]}) == 0
tokens_to_transfer = 20 * TENPOW18
tx = payment_token.transfer(token_buyer_a, tokens_to_transfer,
{'from': accounts[0]})
tx = payment_token.approve(erc20_auction, tokens_to_transfer,
{'from': token_buyer_a})
tx = erc20_auction.commitTokens(tokens_to_transfer,
{'from': token_buyer_a})
assert 'AddedCommitment' in tx.events
tokens_to_transfer = 4 * tokens_to_transfer
tx = payment_token.transfer(token_buyer_b, tokens_to_transfer,
{'from': accounts[0]})
tx = payment_token.approve(erc20_auction, tokens_to_transfer,
{'from': token_buyer_b})
tx = erc20_auction.commitTokens(tokens_to_transfer,
{'from': token_buyer_b})
assert 'AddedCommitment' in tx.events
chain.sleep(AUCTION_TIME + 100)
chain.mine()
# AG need to double check these numbers
assert erc20_auction.tokensClaimable(
token_buyer_a, {'from': accounts[0]}) == AUCTION_TOKENS / 5
assert erc20_auction.tokensClaimable(
token_buyer_b, {'from': accounts[0]}) == 4 * AUCTION_TOKENS / 5
def rule_swap_into_existing(self, st_acct, st_token, st_amount, st_idx):
"""
Increase the underyling balance of an existing NFT via a cross-asset swap.
"""
if self.active_token_ids.get(st_acct):
idx = int(st_idx * len(self.active_token_ids[st_acct]))
token_id = self.active_token_ids[st_acct][idx]
else:
token_ids = self._all_token_ids()
idx = int(st_idx * len(token_ids))
token_id = token_ids[idx]
synth = Settler.at(hex(token_id % 2**160)).synth()
idx = int(st_idx * len(TOKENS[st_token]))
initial = TOKENS[st_token][idx]
amount = self._mint(st_acct, initial, st_amount)
if self.active_token_ids.get(st_acct) and TOKENS[st_token][0] != synth:
self.swap.swap_into_synth(initial, synth, amount, 0, st_acct,
token_id, {"from": st_acct})
chain.mine(timedelta=600)
else:
with brownie.reverts():
self.swap.swap_into_synth(initial, synth, amount, 0, st_acct,
token_id, {"from": st_acct})
def test_basic(vault, strategy, snx, snx_whale, cySNX):
gov = vault.governance()
snx.approve(vault, 2**256 - 1, {"from": snx_whale})
vault.deposit(Wei("1_000 ether"), {"from": snx_whale})
s0 = Contract(vault.withdrawalQueue(0))
debt_ratio = vault.strategies(s0).dict()["debtRatio"]
assert debt_ratio > 0
vault.updateStrategyDebtRatio(s0, 0, {"from": gov})
# Invest only 1k SNX
vault.addStrategy(strategy, debt_ratio, 0, Wei("1_000 ether"), 1000,
{"from": gov})
strategy.harvest({"from": gov})
# No more deposits into the strategy
vault.updateStrategyMaxDebtPerHarvest(strategy, 0, {"from": gov})
chain.mine(2000)
chain.sleep(3600 * 8)
cySNX.mint(0, {"from": gov})
strategy.harvest({"from": gov})
assert vault.strategies(strategy).dict()["totalGain"] > 0
assert vault.strategies(strategy).dict()["totalLoss"] == 0
strategy.setEmergencyExit({"from": gov})
strategy.harvest({"from": gov})
assert vault.strategies(strategy).dict()["totalLoss"] == 0
assert vault.strategies(strategy).dict()["totalDebt"] <= 1
def test_migration_via_vault(gov, vault, strategy, new_strategy, token, whale, amount):
scale = 10 ** token.decimals()
# Deposit to the vault
token.approve(vault, 2 ** 256 - 1, {"from": whale})
vault.deposit(amount, {"from": whale})
# assert token.balanceOf(vault.address) == amount
strategy.harvest({"from": gov})
chain.sleep(864000)
chain.mine(1)
crv = Contract(strategy.crv(), owner=gov)
cvx = Contract(strategy.cvx(), owner=gov)
fis = Contract(strategy.fis(), owner=gov)
print(f"crv before: {crv.balanceOf(new_strategy)}")
print(f"cvx before: {cvx.balanceOf(new_strategy)}")
print(f"fis before: {fis.balanceOf(new_strategy)}")
oldStrategyAssets = strategy.estimatedTotalAssets()
vault.migrateStrategy(strategy, new_strategy, {"from": gov})
assert oldStrategyAssets == new_strategy.estimatedTotalAssets()
print(f"crv after: {crv.balanceOf(new_strategy)}")
print(f"cvx after: {cvx.balanceOf(new_strategy)}")
print(f"fis after: {fis.balanceOf(new_strategy)}")
def test_shares_balance_decrease_liquidation(
vault, vault_user, liquidations_admin, deposit_to_terra, steth_token,
beth_token, helpers, withdraw_from_terra, lido_oracle_report):
deposit_to_terra(TERRA_ADDRESS, vault_user, amount=10**18)
lido_oracle_report(steth_rebase_mult=1)
vault.collect_rewards({'from': liquidations_admin})
withdraw_from_terra(TERRA_ADDRESS,
to_address=vault_user,
amount=0.5 * 10**18)
vault.withdraw(0.5 * 10**18, vault.version(), {'from': vault_user})
chain.mine(timedelta=3600 * 28)
vault_steth_balance_before = steth_token.balanceOf(vault)
vault_beth_balance_before = beth_token.balanceOf(vault)
lido_oracle_report(steth_rebase_mult=1.1)
vault.collect_rewards({'from': liquidations_admin})
assert beth_token.balanceOf(vault) == vault_beth_balance_before
assert helpers.equal_with_precision(steth_token.balanceOf(vault),
vault_steth_balance_before, 100)
def test_multi_emerg_withdraw(lp_staker, alice, bob, token, token2):
lp_staker.addPool(token2, 0, {'from': alice})
token2.approve(lp_staker, 2**256-1, {'from': alice})
token2.approve(lp_staker, 2**256-1, {'from': bob})
deposit = 10000 * 10**18
chain.sleep(1001)
chain.mine()
lp_staker.deposit(1, deposit, {'from': alice})
lp_staker.deposit(1, deposit * 2, {'from': bob})
lp_staker.deposit(2, deposit * 3, {'from': bob})
lp_staker.deposit(2, deposit * 4, {'from': bob})
lp_staker.deposit(1, deposit * 5, {'from': alice})
lp_staker.deposit(1, deposit * 6, {'from': bob})
lp_staker.deposit(2, deposit * 7, {'from': bob})
lp_staker.deposit(2, deposit * 8, {'from': bob})
chain.sleep(100)
chain.mine()
lp_staker.emergencyWithdraw(1, {'from': alice})
lp_staker.emergencyWithdraw(2, {'from': alice})
lp_staker.emergencyWithdraw(1, {'from': bob})
lp_staker.emergencyWithdraw(2, {'from': bob})
assert token.balanceOf(alice) == 1000000 * 10**18
assert token.balanceOf(bob) == 1000000 * 10**18
assert token2.balanceOf(alice) == 1000000 * 10**18
assert token2.balanceOf(bob) == 1000000 * 10**18
def test_profitable_harvest(accounts, dai, gov, token, vault, strategy, user,
user217, user8, strategist, amount, amount217,
amount8, RELATIVE_APPROX, chain):
# Deposit to the vault
token.approve(vault.address, amount, {"from": user})
token.approve(vault.address, amount217, {"from": user217})
vault.deposit(amount, {"from": user})
vault.deposit(amount217, {"from": user217})
assert token.balanceOf(vault.address) == amount + amount217
# Harvest 1: Send funds through the strategy
strategy.harvest()
assert pytest.approx(strategy.estimatedTotalAssets(),
rel=RELATIVE_APPROX) == amount + amount217
before_pps = vault.pricePerShare()
# TODO: Add some code before harvest #2 to simulate earning yield
sleepAndHarvest(10, strategy, gov, vault, dai)
# Harvest 2: Realize profit
strategy.harvest()
chain.sleep(3600 * 6) # 6 hrs needed for profits to unlock
chain.mine(1)
profit = token.balanceOf(vault.address) # Profits go to vault
assert vault.pricePerShare() >= before_pps
# Withdraws should not fail
vault.withdraw(amount, {"from": user})
vault.withdraw(amount217, {"from": user217})
# Depositors after withdraw should have a profit or gotten the original amount
assert token.balanceOf(user) >= amount
assert token.balanceOf(user217) >= amount217
# Make sure it isnt less than 1 after depositors withdrew
assert vault.pricePerShare() / 1e18 >= 1
def test_direct_transfer_with_actual_profits(
vault, strategy, token, token_whale, borrow_token, borrow_whale, yvault, gov
):
initialProfit = vault.strategies(strategy).dict()["totalGain"]
assert initialProfit == 0
token.approve(vault, 2 ** 256 - 1, {"from": token_whale})
vault.deposit(500_000 * (10 ** token.decimals()), {"from": token_whale})
chain.sleep(1)
strategy.harvest({"from": gov})
# send some profit to yvault
borrow_token.transfer(
yvault, 20_000 * (10 ** borrow_token.decimals()), {"from": borrow_whale}
)
# sleep for a day
chain.sleep(24 * 3600)
chain.mine(1)
# receive a direct transfer
airdropAmount = 1_000 * (10 ** token.decimals())
token.transfer(strategy, airdropAmount, {"from": token_whale})
# sleep for another day
chain.sleep(24 * 3600)
chain.mine(1)
strategy.harvest({"from": gov})
assert (
vault.strategies(strategy).dict()["totalGain"] > initialProfit + airdropAmount
)
def test_hyperbolic_auction_tokens_claimable(hyperbolic_auction):
token_buyer = accounts[2]
eth_to_transfer = 20 * TENPOW18
hyperbolic_auction.commitEth(token_buyer, True, {"from": token_buyer, "value":eth_to_transfer})
chain.sleep(AUCTION_TIME+100)
chain.mine()
assert hyperbolic_auction.tokensClaimable(accounts[2]) == AUCTION_TOKENS
def test_hyperbolic_auction_withdraw_tokens(hyperbolic_auction):
token_buyer = accounts[2]
eth_to_transfer = 100 * TENPOW18
with reverts("HyperbolicAuction: auction has not finished yet"):
hyperbolic_auction.withdrawTokens({'from':accounts[0]})
hyperbolic_auction.commitEth(token_buyer, True, {"from": token_buyer, "value":eth_to_transfer})
assert hyperbolic_auction.finalized({'from': accounts[0]}) == False
chain.sleep(AUCTION_TIME+1)
chain.mine()
assert hyperbolic_auction.auctionSuccessful({'from': accounts[0]}) == True
with reverts("HyperbolicAuction: not finalized"):
hyperbolic_auction.withdrawTokens({'from':accounts[0]})
with reverts("HyperbolicAuction: sender must be an operator"):
hyperbolic_auction.finalizeAuction({'from':accounts[8]})
hyperbolic_auction.finalizeAuction({'from':accounts[0]})
assert hyperbolic_auction.finalized({'from': accounts[0]}) == True
hyperbolic_auction.withdrawTokens({"from":token_buyer})
with reverts("HyperbolicAuction: no tokens to claim"):
hyperbolic_auction.withdrawTokens({"from":token_buyer})
def test_new_farming(accounts, farming, niftsy20):
chain.sleep(110)
chain.mine(10)
assert farming.getAvailableRewardAmount(
2, niftsy20) == farming.getRewardSettings(
niftsy20)[0][1] * farming.getERC20CollateralBalance(
2, niftsy20) / 10000
collateral = farming.getERC20CollateralBalance(2, niftsy20)
logging.info('col = {}'.format(collateral))
logging.info('avail = {}'.format(
farming.getAvailableRewardAmount(2, niftsy20)))
logging.info('rasch = {}'.format(
farming.getRewardSettings(niftsy20)[0][1] *
farming.getERC20CollateralBalance(2, niftsy20) / 10000))
rewards = farming.rewards(2)
farming.harvest(2, niftsy20.address, {'from': accounts[1]})
logging.info('getERC20CollateralBalance({},{})={}'.format(
2, niftsy20,
Wei(farming.getERC20CollateralBalance(2, niftsy20)).to('ether')))
assert collateral + farming.getRewardSettings(niftsy20)[0][
1] * collateral / 10000 == farming.getERC20CollateralBalance(
2, niftsy20)
assert rewards[0] < farming.rewards(2)[0]
assert farming.rewards(2)[1] == 0
def test_check_reward(accounts, farming, niftsy20):
chain.sleep(1100)
chain.mine(10)
#logging.info('getCurrenntAPYByTokenId_1 = {}'.format(farming.getCurrenntAPYByTokenId(1, niftsy20)))
#logging.info('getPlanAPYByTokenId1 = {}'.format(farming.getPlanAPYByTokenId(1, niftsy20)))
#logging.info('getCurrenntAPYByTokenId_2 = {}'.format(farming.getCurrenntAPYByTokenId(2, niftsy20)))
#logging.info('timeInStake()={}'.format(
# chain.time() - farming.rewards(farming.lastWrappedNFTId())[0]
#))
#logging.info('getERC20CollateralBalance({},{})={}'.format(
# 2,
# niftsy20,
# farming.getERC20CollateralBalance(2, niftsy20)
#))
#logging.info('farming.getAvailableRewardAmount(1, niftsy20)={}'.format(
# Wei(farming.getAvailableRewardAmount(1, niftsy20)).to('ether')
#))
#logging.info('farming.getAvailableRewardAmount(2, niftsy20)={}'.format(
# Wei(farming.getAvailableRewardAmount(2, niftsy20)).to('ether')
#))
assert farming.getAvailableRewardAmount(
1, niftsy20) == farming.getRewardSettings(
niftsy20)[3][1] * farming.getERC20CollateralBalance(
1, niftsy20) / 10000
def test_migrate(
currency,
AlchemixStakingStrategy,
stakingstrategy,
chain,
vault,
whale,
gov,
strategist,
interface,
):
debt_ratio = 10_000
vault.addStrategy(
stakingstrategy, debt_ratio, 0, 2 ** 256 - 1, 1_000, {"from": gov}
)
currency.approve(vault, 2 ** 256 - 1, {"from": whale})
vault.deposit(Wei("100 ether"), {"from": whale})
stakingstrategy.harvest({"from": strategist})
chain.sleep(2592000)
chain.mine(1)
stakingstrategy.harvest({"from": strategist})
totalasset_beforemig = stakingstrategy.estimatedTotalAssets()
assert totalasset_beforemig > 0
strategy2 = strategist.deploy(AlchemixStakingStrategy, vault)
vault.migrateStrategy(stakingstrategy, strategy2, {"from": gov})
# Check that we got all the funds on migration
assert strategy2.estimatedTotalAssets() >= totalasset_beforemig
def test_impact(comptroller):
chain.mine(timedelta=1200)
comptroller.impactBatch([True], [1e18])
comptroller.impactBatch([True], [1e18])
roller0 = comptroller.impactRollers(0)
roller1 = comptroller.impactRollers(1)
roller2 = comptroller.impactRollers(2)
print(roller0)
print(roller1)
print(roller2)
comptroller.impactBatch([True], [1e18])
roller0 = comptroller.impactRollers(0)
roller1 = comptroller.impactRollers(1)
roller2 = comptroller.impactRollers(2)
print(roller0)
print(roller1)
print(roller2)
def staking_rewards(GazeLPStaking, GazeRewards, gaze_coin, lp_token,
weth_token, access_control):
staking_rewards = GazeLPStaking.deploy({'from': accounts[0]})
staking_rewards.initLPStaking(gaze_coin, lp_token, weth_token,
access_control, {"from": accounts[0]})
vault = accounts[1]
rewards_contract = GazeRewards.deploy(gaze_coin, access_control,
staking_rewards,
chain.time() + 10, 0, 0,
{'from': accounts[0]})
assert gaze_coin.balanceOf(vault) > 0
gaze_coin.approve(rewards_contract, ONE_MILLION, {"from": vault})
rewards_contract.setVault(vault, {"from": accounts[0]})
staking_rewards.setRewardsContract(rewards_contract, {"from": accounts[0]})
staking_rewards.setTokensClaimable(True, {"from": accounts[0]})
weeks = [0, 1, 2, 3, 4, 5]
rewards = [
70000 * TENPOW18, 60000 * TENPOW18, 50000 * TENPOW18, 50000 * TENPOW18,
45000 * TENPOW18, 42000 * TENPOW18
]
rewards_contract.setRewards(weeks, rewards)
chain.sleep(20)
chain.mine()
return staking_rewards
def test_impact_roller_expected_impact(comptroller):
cap = comptroller.oiCap()
pressure = 1e18 / cap
chain.mine(timedelta=ONE_BLOCK)
comptroller.impactBatch([True], [1e18])
chain.mine(timedelta=ONE_BLOCK)
comptroller.impactBatch([True], [1e18])
chain.mine(timedelta=ONE_BLOCK)
comptroller.impactBatch([True], [1e18])
chain.mine(timedelta=ONE_BLOCK)
comptroller.impactBatch([True], [1e18])
chain.mine(timedelta=ONE_BLOCK)
comptroller.impactBatch([True], [1e18])
assert comptroller.impactCycloid() == 5
assert comptroller.impactRollers(1)[1] / 1e18 == approx(1 * pressure)
assert comptroller.impactRollers(2)[1] / 1e18 == approx(2 * pressure)
assert comptroller.impactRollers(3)[1] / 1e18 == approx(3 * pressure)
assert comptroller.impactRollers(4)[1] / 1e18 == approx(4 * pressure)
assert comptroller.impactRollers(5)[1] / 1e18 == approx(5 * pressure)
assert comptroller.impactRollers(5)[0] == chain[-1].timestamp
assert comptroller.impactRollers(6)[0] == 0
def pass_and_exec_dao_vote(vote_id):
print(f'executing vote {vote_id}')
# together these accounts hold 15% of LDO total supply
ldo_holders = [
'0x3e40d73eb977dc6a537af587d48316fee66e9c8c',
'0xb8d83908aab38a159f3da47a59d84db8e1838712',
'0xa2dfc431297aee387c05beef507e5335e684fbcd'
]
helper_acct = Helpers.accounts[0]
for holder_addr in ldo_holders:
print(f'voting from {holder_addr}')
helper_acct.transfer(holder_addr, '0.1 ether')
account = Helpers.accounts.at(holder_addr, force=True)
Helpers.dao_voting.vote(vote_id, True, False, {'from': account})
# wait for the vote to end
chain.mine(timedelta=(3 * 60 * 60 * 24))
assert Helpers.dao_voting.canExecute(vote_id)
tx = Helpers.dao_voting.executeVote(vote_id, {'from': helper_acct})
print(f'vote {vote_id} executed')
return tx
def test_usd_to_btc(Settler, alice, swap, sUSD, sBTC, curve_susd, curve_sbtc,
usd_idx, btc_idx):
initial = MintableForkToken(curve_susd.coins(usd_idx))
final = MintableForkToken(curve_sbtc.coins(btc_idx))
amount = 1_000_000 * 10**initial.decimals()
initial._mint_for_testing(alice, amount)
initial.approve(swap, 2**256 - 1, {"from": alice})
tx = swap.swap_into_synth(initial, sBTC, amount, 0, {"from": alice})
token_id = tx.events["Transfer"][-1]["token_id"]
chain.mine(timedelta=600)
amount = swap.token_info(token_id)["underlying_balance"]
swap.swap_from_synth(token_id, final, amount, 0, {"from": alice})
settler = Settler.at(hex(token_id))
for coin in (initial, sBTC, sUSD):
assert coin.balanceOf(swap) == 0
assert coin.balanceOf(settler) == 0
assert coin.balanceOf(alice) == 0
assert final.balanceOf(swap) == 0
assert final.balanceOf(settler) == 0
assert final.balanceOf(alice) > 0
assert swap.balanceOf(alice) == 0
def test_increase(vault, strategy, gov, token, token_whale, borrow_token,
borrow_whale, yvault):
token.approve(vault, 2**256 - 1, {"from": token_whale})
vault.deposit(20 * (10**token.decimals()), {"from": token_whale})
vault.updateStrategyDebtRatio(strategy, 5_000, {"from": gov})
chain.sleep(1)
strategy.harvest({"from": gov})
assert vault.strategies(
strategy).dict()["totalDebt"] == 10 * (10**token.decimals())
borrow_token.transfer(yvault, 200 * (10**borrow_token.decimals()),
{"from": borrow_whale})
tx = strategy.harvest({"from": gov})
chain.sleep(60 * 60 * 24 * 2)
chain.mine(1)
# Go all the way up to 10k
vault.updateStrategyDebtRatio(strategy, 10_000, {"from": gov})
chain.sleep(1)
strategy.harvest({"from": gov})
assert vault.strategies(
strategy).dict()["totalDebt"] >= 20 * (10**token.decimals())
assert vault.strategies(strategy).dict()["totalLoss"] == 0
def sleepAndHarvest(times, strat, gov):
for i in range(times):
debugStratData(strat, "Before harvest" + str(i))
chain.sleep(2500)
chain.mine(1)
strat.harvest({"from": gov})
debugStratData(strat, "After harvest" + str(i))
def test_emissions_against_other_gauge(alice, mock_lp_token, gauge_controller,
liquidity_gauge, root_gauge):
gauge_controller.add_type("Test", 10**18, {"from": alice})
gauge_controller.add_gauge(liquidity_gauge, 0, 1, {"from": alice})
gauge_controller.add_gauge(root_gauge, 0, 1, {"from": alice})
# alice is the only staker in `liquidity_gauge`
mock_lp_token.approve(liquidity_gauge, 2**256 - 1, {"from": alice})
tx = liquidity_gauge.deposit(100000, {"from": alice})
# sleep until the start of the next epoch week
chain.mine(timestamp=(tx.timestamp // WEEK + 1) * WEEK)
# 110 weeks ensures we see 2 reductions in the rate
for i in range(1, 110):
# checkpointing the root gauge mints all the allocated emissions for the next week
tx = root_gauge.checkpoint()
emissions = root_gauge.emissions(
) # emissions this week are delayed y a week so
claimable = liquidity_gauge.claimable_tokens(alice, {
"from": alice
}).return_value
# root gauge emissions should be equal to regular gauge claimable amount
assert math.isclose(emissions, claimable, rel_tol=1e-6)
# now we time travel one week, and get the claimable rewards from the regular gauge
chain.mine(timestamp=(tx.timestamp // WEEK + 1) * WEEK)
def test_dutch_auction_twoPurchases(dutch_auction):
token_buyer_a = accounts[2]
token_buyer_b = accounts[3]
assert dutch_auction.tokensClaimable(token_buyer_a,
{'from': accounts[0]}) == 0
assert dutch_auction.tokensClaimable(token_buyer_b,
{'from': accounts[0]}) == 0
assert dutch_auction.tokensRemaining() == AUCTION_TOKENS
eth_to_transfer = 20 * TENPOW18
tx = dutch_auction.commitEth({
'from': token_buyer_a,
'value': eth_to_transfer
})
assert 'AddedCommitment' in tx.events
tx = dutch_auction.commitEth({
'from': token_buyer_b,
'value': 4 * eth_to_transfer
})
assert 'AddedCommitment' in tx.events
chain.sleep(AUCTION_TIME + 100)
chain.mine()
assert dutch_auction.tokensRemaining() == 0
# AG need to double check these numbers
assert dutch_auction.tokensClaimable(
token_buyer_a, {'from': accounts[0]}) == AUCTION_TOKENS / 5
assert dutch_auction.tokensClaimable(
token_buyer_b, {'from': accounts[0]}) == 4 * AUCTION_TOKENS / 5
def test_eth_to_btc(Settler, alice, swap, sBTC, sETH, curve_sbtc, curve_seth,
btc_idx):
final = MintableForkToken(curve_sbtc.coins(btc_idx))
tx = swap.swap_into_synth(ETH_ADDRESS, sBTC, alice.balance(), 0, {
'from': alice,
'value': alice.balance()
})
token_id = tx.events['Transfer'][-1]['token_id']
chain.mine(timedelta=600)
amount = swap.token_info(token_id)['underlying_balance']
swap.swap_from_synth(token_id, final, amount, 0, {'from': alice})
settler = Settler.at(hex(token_id))
for coin in (sETH, sBTC):
assert coin.balanceOf(swap) == 0
assert coin.balanceOf(settler) == 0
assert coin.balanceOf(alice) == 0
assert swap.balance() == 0
assert settler.balance() == 0
assert alice.balance() == 0
assert final.balanceOf(swap) == 0
assert final.balanceOf(settler) == 0
assert final.balanceOf(alice) > 0
assert swap.balanceOf(alice) == 0
def test_erc20_auction_claim(erc20_auction, payment_token):
token_buyer = accounts[2]
tokens_to_transfer = 100 * TENPOW18
with reverts():
erc20_auction.withdrawTokens({'from': accounts[0]})
tx = payment_token.transfer(token_buyer, tokens_to_transfer,
{'from': accounts[0]})
tx = payment_token.approve(erc20_auction, tokens_to_transfer,
{'from': token_buyer})
tx = erc20_auction.commitTokens(tokens_to_transfer, {'from': token_buyer})
assert erc20_auction.finalised({'from': accounts[0]}) == False
chain.sleep(AUCTION_TIME + 100)
chain.mine()
assert erc20_auction.auctionSuccessful({'from': accounts[0]}) == True
erc20_auction.withdrawTokens({'from': token_buyer})
# Check for multiple withdraws
with reverts():
erc20_auction.withdrawTokens({'from': token_buyer})
erc20_auction.withdrawTokens({'from': accounts[0]})
erc20_auction.finaliseAuction({'from': accounts[0]})
with reverts():
erc20_auction.finaliseAuction({'from': accounts[0]})
def test_btc_to_eth(Settler, alice, bob, swap, sBTC, sETH, curve_sbtc,
curve_seth, btc_idx):
initial = MintableForkToken(curve_sbtc.coins(btc_idx))
amount = 5 * 10**initial.decimals()
initial._mint_for_testing(alice, amount)
initial.approve(swap, 2**256 - 1, {'from': alice})
alice.transfer(bob, alice.balance())
tx = swap.swap_into_synth(initial, sETH, amount, 0, {'from': alice})
token_id = tx.events['Transfer'][-1]['token_id']
chain.mine(timedelta=600)
amount = swap.token_info(token_id)['underlying_balance']
swap.swap_from_synth(token_id, ETH_ADDRESS, amount, 0, {'from': alice})
settler = Settler.at(hex(token_id))
for coin in (initial, sETH, sBTC):
assert coin.balanceOf(swap) == 0
assert coin.balanceOf(settler) == 0
assert coin.balanceOf(alice) == 0
assert swap.balance() == 0
assert settler.balance() == 0
assert alice.balance() > 0
assert swap.balanceOf(alice) == 0
def rule_swap_into(self, st_acct, st_token, st_synth, st_idx, st_amount):
"""
Generate a new NFT via a cross-asset swap.
"""
idx = int(st_idx * len(TOKENS[st_token]))
initial = TOKENS[st_token][idx]
synth = TOKENS[st_synth][0]
amount = self._mint(st_acct, initial, st_amount)
if st_token == st_synth:
# initial token and target synth come from the same asset class
# no cross-asset swap is possible
with brownie.reverts():
self.swap.swap_into_synth(initial, synth, amount, 0,
{"from": st_acct})
else:
tx = self.swap.swap_into_synth(initial, synth, amount, 0,
{"from": st_acct})
token_id = tx.events["Transfer"][-1]["token_id"]
assert token_id != 0
if "NewSettler" in tx.events:
settler = tx.events["NewSettler"]["addr"]
assert settler not in self.settlers
self.settlers.append(settler)
# make sure `token_id` isn't previously assigned
assert (token_id not in list(self.active_token_ids.values()) +
self.used_token_ids)
self.active_token_ids.setdefault(st_acct, []).append(token_id)
chain.mine(timedelta=600)
def test_impact_pressure(comptroller, entry):
entry *= 1e18
chain.mine(timedelta=ONE_BLOCK)
cap = comptroller.oiCap()
_lambda = comptroller.lmbda()
comptroller.impactBatch([True], [entry])
impact = comptroller.viewImpact(True, 1e18)
inverse_euler = Decimal(1) / Decimal(math.e)
impact_1 = (Decimal(entry) / Decimal(1e18)) / \
(Decimal(cap) / Decimal(1e18))
impact_2 = (Decimal(1e18) / Decimal(1e18)) / (Decimal(cap) / Decimal(1e18))
pressure = impact_1 + impact_2
impact_factor = Decimal(_lambda / 1e18) * pressure
expected = (Decimal(1) - (inverse_euler ** impact_factor)) * Decimal(1e18)
assert abs(expected - impact) < 1e6
def get_uni_feeds(feed_owner, feed_info):
market_obs = feed_info.market_info[0]
market_shims = feed_info.market_info[1]
depth_obs = feed_info.depth_info[0]
depth_shims = feed_info.depth_info[1]
UniswapV3MockFactory = getattr(brownie, 'UniswapV3FactoryMock')
IUniswapV3OracleMock = getattr(interface, 'IUniswapV3OracleMock')
uniswapv3_factory = feed_owner.deploy(UniswapV3MockFactory)
market_token0 = "0x6B175474E89094C44Da98b954EedeAC495271d0F"
market_token1 = WRAPPED_ETH_ADDR
depth_token0 = "0xBB0E17EF65F82Ab018d8EDd776e8DD940327B28b"
depth_token1 = WRAPPED_ETH_ADDR
# TODO: place token0 and token1 into the json
uniswapv3_factory.createPool(market_token0, market_token1)
uniswapv3_factory.createPool(depth_token0, depth_token1)
market_mock = IUniswapV3OracleMock(uniswapv3_factory.allPools(0))
depth_mock = IUniswapV3OracleMock(uniswapv3_factory.allPools(1))
market_mock.loadObservations(
market_obs, market_shims, {'from': feed_owner})
depth_mock.loadObservations(depth_obs, depth_shims, {'from': feed_owner})
chain.mine(timestamp=feed_info.market_info[2]['timestamp'][0])
return uniswapv3_factory.address, market_mock.address, depth_mock.address, market_token1 # noqa: E501
def test_huge_debt(vault, strategy, gov, token, token_whale):
prev_balance = token.balanceOf(token_whale)
token.approve(vault, 2**256 - 1, {"from": token_whale})
vault.deposit(500_000 * (10**token.decimals()), {"from": token_whale})
chain.sleep(1)
strategy.harvest({"from": gov})
lp = get_lending_pool()
prev_debt = lp.getUserAccountData(strategy).dict()["totalDebtETH"]
print(f"T=0 totalDebtETH: {prev_debt}")
# After first investment sleep for aproximately a month
chain.sleep(60 * 60 * 24 * 30)
chain.mine(1)
new_debt = lp.getUserAccountData(strategy).dict()["totalDebtETH"]
print(f"T=365 totalDebtETH: {new_debt}")
assert new_debt > prev_debt
# Test that there is no loss until withdrawal
strategy.harvest({"from": gov})
assert vault.strategies(strategy).dict()["totalLoss"] == 0
vault.withdraw(vault.balanceOf(token_whale), token_whale, 10_000,
{"from": token_whale})
# we are currently in a profitable scenario so there is no loss
print(f"diff {prev_balance-token.balanceOf(token_whale)}")
assert token.balanceOf(token_whale) - prev_balance > 0
