def mint_Aave(token: MintableForkToken, target: str, amount: int) -> bool:
# Aave aTokens
if not hasattr(token, "UNDERLYING_ASSET_ADDRESS"):
return False
token = MintableForkToken(token.UNDERLYING_ASSET_ADDRESS())
lending_pool = Contract("0x7d2768dE32b0b80b7a3454c06BdAc94A69DDc7A9")
token._mint_for_testing(target, amount)
token.approve(lending_pool, amount, {"from": target})
lending_pool.deposit(token, amount, target, 0, {"from": target})
return True
def _mint_for_testing(self, target, amount, tx=None):
if self.address == "0x674C6Ad92Fd080e4004b2312b45f796a192D27a0":
# USDN
self.deposit(
target, amount,
{'from': "0x90f85042533F11b362769ea9beE20334584Dcd7D"})
return
if self.address == "0x0E2EC54fC0B509F445631Bf4b91AB8168230C752":
# LinkUSD
self.mint(target, amount,
{'from': "0x62F31E08e279f3091d9755a09914DF97554eAe0b"})
return
if self.address == "0x196f4727526eA7FB1e17b2071B3d8eAA38486988":
# RSV
self.changeMaxSupply(2**128, {'from': self.owner()})
self.mint(target, amount, {'from': self.minter()})
return
if self.address == "0x5228a22e72ccC52d415EcFd199F99D0665E7733b":
# pBTC
self.mint(target, amount, {'from': self.pNetwork()})
return
if self.name().startswith("Aave"):
underlying = _MintableTestToken(self.UNDERLYING_ASSET_ADDRESS())
lending_pool = Contract(
"0x7d2768dE32b0b80b7a3454c06BdAc94A69DDc7A9")
underlying._mint_for_testing(target, amount)
underlying.approve(lending_pool, amount, {'from': target})
lending_pool.deposit(underlying, amount, target, 0,
{'from': target})
return
for address in _holders[self.address].copy():
if address == self.address:
# don't claim from the treasury - that could cause wierdness
continue
balance = self.balanceOf(address)
try:
if amount > balance:
self.transfer(target, balance, {'from': address})
amount -= balance
else:
self.transfer(target, amount, {'from': address})
return
except Exception:
# sometimes tokens just don't want to be stolen
pass
raise ValueError(
f"Insufficient tokens available to mint {self.name()}")
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})
