def test_can_withdraw(staked_3pool, tripool_rewards): dai = Contract("dai") staked_3pool.unape_balanced(Contract("3pool")) assert dai.balanceOf(staked_3pool) > 0
def strategy_ecrv_live_old(): yield Contract("0xB5F6747147990c4ddCeBbd0d4ef25461a967D079")
def voter_proxy(): yield Contract("0x9a165622a744C20E3B2CB443AeD98110a33a231b")
def token(): token_address = "0x8888801af4d980682e47f1a9036e589479e835c5" # this should be the address of the ERC-20 used by the strategy/vault (DAI) yield Contract(token_address)
def weth(): token_address = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2" yield Contract(token_address)
def xdai(): acct = accounts.load("curve-deploy") for addr in XDAI: streamer = Contract(addr) token = streamer.reward_tokens(0) streamer.notify_reward_amount(token, {"from": acct})
def test_no_emissions(chain, usdc, whale, gov, strategist, rando, vault, Strategy, strategy, GenericAave, aUsdc): # Clone magic vault = Contract("0xa5cA62D95D24A4a350983D5B8ac4EB8638887396" ) # using SUSD vault (it is not in the LP program) tx = strategy.clone(vault) cloned_strategy = Strategy.at(tx.return_value) cloned_strategy.setWithdrawalThreshold(strategy.withdrawalThreshold(), {"from": vault.governance()}) cloned_strategy.setDebtThreshold(strategy.debtThreshold(), {"from": vault.governance()}) cloned_strategy.setProfitFactor(strategy.profitFactor(), {"from": vault.governance()}) cloned_strategy.setMaxReportDelay(strategy.maxReportDelay(), {"from": vault.governance()}) assert cloned_strategy.numLenders() == 0 aSUSD = interface.IAToken( "0x6c5024cd4f8a59110119c56f8933403a539555eb") # aSUSD # Clone the aave lender original_aave = GenericAave.at(strategy.lenders(strategy.numLenders() - 1)) tx = original_aave.cloneAaveLender(cloned_strategy, "ClonedAaveSUSD", aSUSD, False, {"from": vault.governance()}) cloned_lender = GenericAave.at(tx.return_value) assert cloned_lender.lenderName() == "ClonedAaveSUSD" cloned_strategy.addLender(cloned_lender, {"from": vault.governance()}) currency = interface.ERC20( "0x57ab1ec28d129707052df4df418d58a2d46d5f51") #sUSD susd_whale = "0x49be88f0fcc3a8393a59d3688480d7d253c37d2a" currency.transfer(strategist, 100e18, {'from': susd_whale}) starting_balance = currency.balanceOf(strategist) decimals = currency.decimals() currency.approve(vault, 2**256 - 1, {"from": whale}) currency.approve(vault, 2**256 - 1, {"from": strategist}) deposit_limit = 1_000_000_000 * (10**(decimals)) debt_ratio = 10_000 vault.updateStrategyDebtRatio(vault.withdrawalQueue(0), 0, {'from': vault.governance()}) vault.updateStrategyDebtRatio(vault.withdrawalQueue(1), 0, {'from': vault.governance()}) vault.addStrategy(cloned_strategy, debt_ratio, 0, 2**256 - 1, 500, {"from": vault.governance()}) vault.setDepositLimit(deposit_limit, {"from": vault.governance()}) assert deposit_limit == vault.depositLimit() with brownie.reverts(): cloned_lender.setIsIncentivised(True, {'from': strategist}) # ------------------ set up proposal ------------------ # chain.sleep(12 * 3600) # to be able to execute # chain.mine(1) # print("executing proposal 11") # to be able to test before the proposal is executed # executor = Contract.from_abi("AaveGovernanceV2", "0xec568fffba86c094cf06b22134b23074dfe2252c", executor_abi, owner="0x30fe242a69d7694a931791429815db792e24cf97") # tx = executor.execute(11) # should fail because sUSD is not incentivised with brownie.reverts(): cloned_lender.setIsIncentivised(True, {'from': strategist}) # our humble strategist deposits some test funds depositAmount = 50 * (10**(decimals)) vault.deposit(depositAmount, {"from": strategist}) assert cloned_strategy.estimatedTotalAssets() == 0 chain.mine(1) assert cloned_strategy.harvestTrigger(1) == True cloned_strategy.harvest({"from": strategist}) assert (cloned_strategy.estimatedTotalAssets() >= depositAmount * 0.999999 ) # losing some dust is ok assert cloned_strategy.harvestTrigger(1) == False assert cloned_lender.harvestTrigger(1) == False # harvest is unavailable with brownie.reverts(): cloned_lender.harvest({'from': strategist}) # if called, it does not revert assert cloned_lender.harvestTrigger(1) == False chain.sleep(10 * 3600 * 24 + 1) # we wait 10 days for the cooldown period chain.mine(1) assert cloned_lender.harvestTrigger(1) == False # always unavailable cloned_strategy.harvest({'from': strategist}) chain.sleep(6 * 3600) chain.mine(1) vault.withdraw({"from": strategist})
def pool_token(): yield Contract("0x0cec1a9154ff802e7934fc916ed7ca50bde6844e")
def comp_bonus(): # making uni the bonus for this test, since comp is the want yield Contract("0x1f9840a85d5af5bf1d1762f925bdaddc4201f984")
def comp_want_pool(): yield Contract("0xBC82221e131c082336cf698F0cA3EBd18aFd4ce7")
def uni_want_pool(): yield Contract("0x0650d780292142835F6ac58dd8E2a336e87b4393")
def uni(): yield Contract("0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D")
def test_operation(pm, chain): dai_liquidity = accounts.at("0xbebc44782c7db0a1a60cb6fe97d0b483032ff1c7", force=True) # using curve pool (lots of dai) crv3_liquidity = accounts.at("0x6c3F90f043a72FA612cbac8115EE7e52BDe6E490", force=True) # yearn treasury (lots of crv3) altCRV_liquidity = accounts.at( "0xe6e6e25efda5f69687aa9914f8d750c523a1d261", force=True) # giant amount rewards = accounts[2] gov = accounts[3] guardian = accounts[4] bob = accounts[5] alice = accounts[6] strategist = accounts[7] tinytim = accounts[8] dai = Contract("0x6b175474e89094c44da98b954eedeac495271d0f", owner=gov) # DAI token dai.approve(dai_liquidity, Wei("1000000 ether"), {"from": dai_liquidity}) dai.transferFrom(dai_liquidity, gov, Wei("300000 ether"), {"from": dai_liquidity}) crv3 = Contract("0x6c3F90f043a72FA612cbac8115EE7e52BDe6E490", owner=gov) # crv3 token address (threePool) altCRV = Contract("0x1AEf73d49Dedc4b1778d0706583995958Dc862e6", owner=gov) # altCRV token (mUSDCrv) crv3.approve(crv3_liquidity, Wei("1000000 ether"), {"from": crv3_liquidity}) crv3.transferFrom(crv3_liquidity, gov, Wei("100 ether"), {"from": crv3_liquidity}) altCRV.approve(altCRV_liquidity, Wei("1000000 ether"), {"from": altCRV_liquidity}) altCRV.transferFrom(altCRV_liquidity, gov, Wei("1000 ether"), {"from": altCRV_liquidity}) # config dai vault. Vault = pm(config["dependencies"][0]).Vault yDAI = Vault.deploy({"from": gov}) yDAI.initialize(dai, gov, rewards, "", "", {"from": gov}) yDAI.setDepositLimit(Wei("1000000 ether")) threePool = Contract("0xbEbc44782C7dB0a1A60Cb6fe97d0b483032FF1C7", owner=gov) # crv3 pool address (threePool) altCrvPool = Contract("0x8474DdbE98F5aA3179B3B3F5942D724aFcdec9f6", owner=gov) # atlCrvPool pool address (musdCrv) targetVault = Contract("0x0FCDAeDFb8A7DfDa2e9838564c5A1665d856AFDF", owner=gov) # target vault (musdCrv) targetVaultStrat = Contract("0xBA0c07BBE9C22a1ee33FE988Ea3763f21D0909a0", owner=gov) # targetVault strat (threePool) targetVaultStratOwner = Contract( "0xFEB4acf3df3cDEA7399794D0869ef76A6EfAff52", owner=gov) # targetVault stratOwner (threePool) strategy = guardian.deploy(StrategyDAImUSDv2, yDAI, dai, threePool, targetVault, crv3, altCRV, altCrvPool) strategy.setStrategist(strategist) yDAI.addStrategy(strategy, 10_000, 0, 0, {"from": gov}) dai.approve(gov, Wei("1000000 ether"), {"from": gov}) dai.transferFrom(gov, bob, Wei("1000 ether"), {"from": gov}) dai.transferFrom(gov, alice, Wei("4000 ether"), {"from": gov}) dai.transferFrom(gov, tinytim, Wei("10 ether"), {"from": gov}) dai.approve(yDAI, Wei("1000000 ether"), {"from": bob}) dai.approve(yDAI, Wei("1000000 ether"), {"from": alice}) dai.approve(yDAI, Wei("1000000 ether"), {"from": tinytim}) crv3.approve(gov, Wei("1000000 ether"), {"from": gov}) yDAI.approve(gov, Wei("1000000 ether"), {"from": gov}) targetVault.approve(gov, Wei("1000000 ether"), {"from": gov}) altCRV.approve(gov, Wei("1000000 ether"), {"from": gov}) dai.approve(threePool, Wei("1000000 ether"), {"from": gov}) crv3.approve(altCrvPool, Wei("1000000 ether"), {"from": gov}) targetVaultStrat.setStrategistReward(0, {"from": targetVaultStratOwner}) targetVaultStrat.setTreasuryFee(0, {"from": targetVaultStratOwner}) targetVaultStrat.setWithdrawalFee(0, {"from": targetVaultStratOwner}) # users deposit to vault yDAI.deposit(Wei("1000 ether"), {"from": bob}) yDAI.deposit(Wei("4000 ether"), {"from": alice}) yDAI.deposit(Wei("10 ether"), {"from": tinytim}) a = yDAI.pricePerShare() chain.mine(1) strategy.harvest({"from": gov}) assert targetVault.balanceOf(strategy) > 0 chain.sleep(3600 * 24 * 7 * 10) chain.mine(1) a = yDAI.pricePerShare() # small profit t = targetVault.getPricePerFullShare() c = strategy.estimatedTotalAssets() targetVaultStrat.harvest({"from": targetVaultStratOwner}) s = targetVault.getPricePerFullShare() d = strategy.estimatedTotalAssets() assert t < s assert d > c assert yDAI.strategies(strategy).dict()['totalDebt'] < d strategy.harvest({"from": gov}) chain.mine(1) b = yDAI.pricePerShare() assert b > a #withdrawals have a slippage protection parameter, defaults to 1 = 0.01%. #overwriting here to be 1.5%, to account for slippage from multiple hops. #slippage also counts "beneficial" slippage, such as DAI being overweight in these pools #d = yUSDT3.balanceOf(alice) c = yDAI.balanceOf(alice) yDAI.withdraw(c, alice, 150, {"from": alice}) assert dai.balanceOf(alice) > 0 assert dai.balanceOf(strategy) == 0 assert dai.balanceOf(bob) == 0 assert targetVault.balanceOf(strategy) > 0 d = yDAI.balanceOf(bob) yDAI.withdraw(d, bob, 150, {"from": bob}) assert dai.balanceOf(bob) > 0 assert dai.balanceOf(strategy) == 0 e = yDAI.balanceOf(tinytim) yDAI.withdraw(e, tinytim, 150, {"from": tinytim}) assert dai.balanceOf(tinytim) > 0 assert dai.balanceOf(strategy) == 0 # We should have made profit assert yDAI.pricePerShare() > 1 #print("\ntinytim", dai.balanceOf(tinytim)/1e18) #print("\nbob", dai.balanceOf(bob)/1e18) #print("\nalice", dai.balanceOf(alice)/1e18) #print("\nvault", targetVault.balanceOf(strategy)/1e18) pass
def __init__(self, name, vault): self.name = name self.vault = Contract(vault) self.token = self.vault.token() self.scale = 10**self.vault.decimals()
def test_fee_distribution(): alice = accounts[0] lp_tripool = Contract("0x6c3F90f043a72FA612cbac8115EE7e52BDe6E490") # get list of active pools provider = Contract("0x0000000022D53366457F9d5E68Ec105046FC4383") registry = Contract(provider.get_registry()) pool_list = [ Contract(registry.pool_list(i)) for i in range(registry.pool_count()) ] # deploy new pool proxy proxy = PoolProxy.deploy(alice, alice, alice, {"from": alice}) # transfer ownership of all pools to new pool proxy for pool in pool_list: owner = pool.owner() pool.commit_transfer_ownership(proxy, {"from": owner}) chain.sleep(86400 * 3) for pool in pool_list: owner = pool.owner() pool.apply_transfer_ownership({"from": owner}) # yes, we are traveling back in time here # this is necessary so that SNX oracle data is not considered outdated chain.mine(timestamp=history[0].timestamp) # deploy the fee distributor distributor = FeeDistributor.deploy( "0x5f3b5DfEb7B28CDbD7FAba78963EE202a494e2A2", # VotingEscrow chain.time(), lp_tripool, alice, alice, {"from": alice}, ) # deploy the burners underlying_burner = UnderlyingBurner.deploy(distributor, alice, alice, alice, {"from": alice}) MetaBurner.deploy(distributor, alice, alice, alice, {"from": alice}) usdn_burner = USDNBurner.deploy(proxy, distributor, alice, alice, alice, {"from": alice}) btc_burner = BTCBurner.deploy(underlying_burner, alice, alice, alice, {"from": alice}) ETHBurner.deploy(underlying_burner, alice, alice, alice, {"from": alice}) EuroBurner.deploy(underlying_burner, alice, alice, alice, {"from": alice}) ABurner.deploy(underlying_burner, alice, alice, alice, {"from": alice}) CBurner.deploy(underlying_burner, alice, alice, alice, {"from": alice}) YBurner.deploy(underlying_burner, alice, alice, alice, {"from": alice}) lp_burner = LPBurner.deploy(alice, alice, alice, {"from": alice}) # set LP burner to unwrap sbtcCRV -> sBTC and transfer to BTC burner lp_burner.set_swap_data( "0x075b1bb99792c9E1041bA13afEf80C91a1e70fB3", "0xfe18be6b3bd88a2d2a7f928d00292e7a9963cfc6", btc_burner, ) # set the burners within pool proxy to_set = [(k[-1], x) for k, v in BURNERS.items() for x in v] burners = [i[0] for i in to_set] + [ZERO_ADDRESS] * (40 - len(to_set)) coins = [i[1] for i in to_set] + [ZERO_ADDRESS] * (40 - len(to_set)) coin_list = [Contract(x) for v in BURNERS.values() for x in v] burner_list = [k[-1] for k in BURNERS.keys()] proxy.set_many_burners(coins[:20], burners[:20], {"from": alice}) proxy.set_many_burners(coins[20:], burners[20:], {"from": alice}) proxy.set_burner(lp_tripool, distributor, {"from": alice}) # approve USDN burner to donate to USDN pool proxy.set_donate_approval("0x0f9cb53Ebe405d49A0bbdBD291A65Ff571bC83e1", usdn_burner, True, {"from": alice}) # withdraw pool fees to pool proxy proxy.withdraw_many(pool_list[:20], {"from": alice}) proxy.withdraw_many( pool_list[20:] + [ZERO_ADDRESS] * (20 - len(pool_list[20:])), {"from": alice}) # individually execute the burners for each coin for coin in coin_list + [lp_tripool]: if coin == "0x57ab1ec28d129707052df4df418d58a2d46d5f51": # for sUSD we settle manually to avoid a ganache bug chain.sleep(700) Contract("0x0bfDc04B38251394542586969E2356d0D731f7DE").settle( underlying_burner, "0x7355534400000000000000000000000000000000000000000000000000000000", {"from": alice}, ) proxy.burn(coin, {"from": alice}) # call execute on underlying burner underlying_burner.execute({"from": alice}) # verify zero-balances for all tokens in all contracts for coin in coin_list: for burner in burner_list: assert coin.balanceOf(burner) < 2 assert coin.balanceOf(proxy) < 2 assert coin.balanceOf(alice) < 2 assert coin.balanceOf(distributor) < 2 # verify zero-balance for 3CRV for burner in burner_list: assert lp_tripool.balanceOf(burner) == 0 assert lp_tripool.balanceOf(proxy) == 0 assert lp_tripool.balanceOf(alice) == 0 # verify that fee distributor has received 3CRV amount = lp_tripool.balanceOf(distributor) assert amount > 0 print(f"Success! Final 3CRV balance in distributor: {amount/1e18:.4f}")
def uni_bonus(): yield Contract("0xc00e94cb662c3520282e6f5717214004a7f26888")
def polygon(): acct = accounts.load("curve-deploy") for addr in POLYGON: streamer = Contract(addr) token = streamer.reward_tokens(0) streamer.notify_reward_amount(token, {"from": acct, "gas_price": "30 gwei"})
def comp_faucet(): yield Contract("0x72F06a78bbAac0489067A1973B0Cef61841D58BC")
def test_aave_rewards(chain, usdc, whale, gov, strategist, rando, vault, Strategy, strategy, GenericAave, aUsdc): # Clone magic tx = strategy.clone(vault) cloned_strategy = Strategy.at(tx.return_value) cloned_strategy.setWithdrawalThreshold(strategy.withdrawalThreshold(), {"from": gov}) cloned_strategy.setDebtThreshold(strategy.debtThreshold(), {"from": gov}) cloned_strategy.setProfitFactor(strategy.profitFactor(), {"from": gov}) cloned_strategy.setMaxReportDelay(strategy.maxReportDelay(), {"from": gov}) assert cloned_strategy.numLenders() == 0 # Clone the aave lender original_aave = GenericAave.at(strategy.lenders(strategy.numLenders() - 1)) tx = original_aave.cloneAaveLender(cloned_strategy, "ClonedAaveUSDC", aUsdc, False, {"from": gov}) cloned_lender = GenericAave.at(tx.return_value) assert cloned_lender.lenderName() == "ClonedAaveUSDC" cloned_strategy.addLender(cloned_lender, {"from": gov}) starting_balance = usdc.balanceOf(strategist) currency = usdc decimals = currency.decimals() usdc.approve(vault, 2**256 - 1, {"from": whale}) usdc.approve(vault, 2**256 - 1, {"from": strategist}) deposit_limit = 1_000_000_000 * (10**(decimals)) debt_ratio = 10_000 vault.addStrategy(cloned_strategy, debt_ratio, 0, 2**256 - 1, 500, {"from": gov}) vault.setDepositLimit(deposit_limit, {"from": gov}) assert deposit_limit == vault.depositLimit() # ------------------ set up proposal ------------------ # chain.sleep(12 * 3600) # to be able to execute # chain.mine(1) # print("executing proposal 11") # to be able to test before the proposal is executed # executor = Contract.from_abi("AaveGovernanceV2", "0xec568fffba86c094cf06b22134b23074dfe2252c", executor_abi, owner="0x30fe242a69d7694a931791429815db792e24cf97") # tx = executor.execute(11) incentives_controller = Contract(aUsdc.getIncentivesController()) assert incentives_controller.getDistributionEnd() > 0 # ------------------ test starts ------------------ # turning on claiming incentives logic cloned_lender.setIsIncentivised(True, {'from': strategist}) # our humble strategist deposits some test funds depositAmount = 50000 * (10**(decimals)) vault.deposit(depositAmount, {"from": strategist}) assert cloned_strategy.estimatedTotalAssets() == 0 chain.mine(1) assert cloned_strategy.harvestTrigger(1) == True cloned_strategy.harvest({"from": strategist}) assert (cloned_strategy.estimatedTotalAssets() >= depositAmount * 0.999999 ) # losing some dust is ok assert cloned_strategy.harvestTrigger(1) == False assert cloned_lender.harvestTrigger(1) == True # first harvest with brownie.reverts(): ## should fail for any non-management account cloned_lender.harvest({'from': whale}) with brownie.reverts(): ## not in management so should revert cloned_lender.setKeep3r(whale, {'from': whale}) cloned_lender.setKeep3r(whale, {'from': strategist}) cloned_lender.harvest({'from': whale}) assert cloned_lender.harvestTrigger(1) == False chain.sleep(10 * 3600 * 24 + 1) # we wait 10 days for the cooldown period chain.mine(1) assert cloned_lender.harvestTrigger(1) == True assert incentives_controller.getRewardsBalance([aUsdc], cloned_lender) > 0 previousBalance = aUsdc.balanceOf(cloned_lender) cloned_lender.harvest({ 'from': strategist }) # redeem staked tokens, sell them, deposit them, claim rewards assert incentives_controller.getRewardsBalance([aUsdc], cloned_lender) == 0 assert aUsdc.balanceOf( cloned_lender) > previousBalance # deposit sold rewards cloned_strategy.harvest({'from': strategist}) status = cloned_strategy.lendStatuses() form = "{:.2%}" formS = "{:,.0f}" for j in status: print( f"Lender: {j[0]}, Deposits: {formS.format(j[1]/1e6)}, APR: {form.format(j[2]/1e18)}" ) chain.sleep(6 * 3600) chain.mine(1) vault.withdraw({"from": strategist})
def uni_faucet(): yield Contract("0xa5dddefD30e234Be2Ac6FC1a0364cFD337aa0f61")
def test_migrate_investment_vault( snx, chain, gov, vault, strategy, susd, susd_vault, susd_whale, snx_whale, bob, snx_oracle, guardian, pm, rewards, management, ): chain.snapshot() # Move stale period to 16 days resolver = Contract(strategy.resolver()) settings = Contract( resolver.getAddress(encode_single("bytes32", b"SystemSettings")) ) settings.setRateStalePeriod(24 * 3600 * 16, {"from": settings.owner()}) settings.setDebtSnapshotStaleTime(24 * 3600 * 16, {"from": settings.owner()}) snx.transfer(bob, Wei("1000 ether"), {"from": snx_whale}) snx.approve(vault, 2 ** 256 - 1, {"from": bob}) vault.deposit({"from": bob}) # Invest with an SNX price of 20 snx_oracle.updateSnxPrice(Wei("20 ether"), {"from": gov}) strategy.harvest({"from": gov}) chain.sleep(86400 + 1) # just over 24h chain.mine() assert strategy.balanceOfWant() == Wei("1000 ether") assert strategy.balanceOfSusd() == 0 assert strategy.balanceOfSusdInVault() > 0 Vault = pm(config["dependencies"][0]).Vault new_vault = guardian.deploy(Vault) new_vault.initialize(susd, gov, rewards, "", "", guardian) new_vault.setDepositLimit(2 ** 256 - 1, {"from": gov}) new_vault.setManagement(management, {"from": gov}) new_vault.setPerformanceFee(0, {"from": gov}) new_vault.setManagementFee(0, {"from": gov}) previous_balance = strategy.balanceOfSusdInVault() strategy.migrateSusdVault(new_vault, 10_000, {"from": gov}) assert previous_balance == new_vault.totalAssets() assert previous_balance == strategy.balanceOfSusdInVault() vault.withdraw({"from": bob}) assert snx.balanceOf(vault) == 0 assert vault.balanceOf(bob) == 0 assert snx.balanceOf(bob) == Wei("1000 ether") chain.revert()
def comp_ticket(): yield Contract("0x27b85f596feb14e4b5faa9671720a556a7608c69")
def dai(): token_address = "0x6B175474E89094C44Da98b954EedeAC495271d0F" # this should be the address of the ERC-20 used by the strategy/vault (DAI) yield Contract(token_address)
def uni_ticket(): yield Contract("0xa92a861fc11b99b24296af880011b47f9cafb5ab")
def token_seth(interface): yield Contract("0x5e74C9036fb86BD7eCdcb084a0673EFc32eA31cb")
def comp(): token_address = "0xc00e94cb662c3520282e6f5717214004a7f26888" yield Contract(token_address)
def strategy_ecrv_live(): yield Contract("0xdD498eB680B0CE6Cac17F7dab0C35Beb6E481a6d")
def unitoken(): token_address = "0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984" yield Contract(token_address)
def token_ecrv(interface, gov): yield Contract("0xA3D87FffcE63B53E0d54fAa1cc983B7eB0b74A9c", owner=gov)
def test_earns_rewards(staked_3pool, tripool_rewards): minter = Contract("minter") crv = Contract("crv") chain.mine(timedelta=60 * 60 * 24) minter.mint(tripool_rewards, {"from": staked_3pool}) assert crv.balanceOf(staked_3pool) > 0