def tend_all(badger: BadgerSystem, skip):
table = []
for key, vault in badger.sett_system.vaults.items():
if key in skip:
continue
strategy = badger.getStrategy(key)
if not strategy.isTendable():
continue
console.print("\n[bold green]===== Tend: " + key + " =====[/bold green]\n")
snap = SnapshotManager(badger, key)
strategy = badger.getStrategy(key)
keeper = accounts.at(badger.keeper)
before = snap.snap()
if strategy.keeper() == badger.badgerRewardsManager:
snap.settTendViaManager(
strategy, {"from": keeper, "gas_limit": 1000000}, confirm=False,
)
else:
snap.settTend(
{"from": keeper, "gas_limit": 1000000}, confirm=False,
)
tx_wait()
if rpc.is_active():
chain.mine()
after = snap.snap()
snap.printCompare(before, after)
def single_user_harvest_flow(badger: BadgerSystem, settConfig, user):
strategy = badger.getStrategy(settConfig["id"])
want = interface.IERC20(registry.pancake.chefPairs.bnbBtcb)
snap = SnapshotManager(badger, settConfig["id"])
sett = badger.getSett(settConfig["id"])
settKeeper = accounts.at(sett.keeper(), force=True)
strategyKeeper = accounts.at(strategy.keeper(), force=True)
randomUser = accounts[6]
tendable = strategy.isTendable()
startingBalance = want.balanceOf(user)
depositAmount = startingBalance // 200
assert startingBalance >= depositAmount
assert startingBalance >= 0
# Deposit
want.approve(sett, MaxUint256, {"from": user})
snap.settDeposit(depositAmount, {"from": user})
assert want.balanceOf(sett) > 0
print("want.balanceOf(sett)", want.balanceOf(sett))
# Earn
snap.settEarn({"from": settKeeper})
if tendable:
with brownie.reverts("onlyAuthorizedActors"):
strategy.tend({"from": randomUser})
numTends = 48
timeBetweenTends = days(365) // numTends
console.print({"numTends": numTends, "timeBetweenTends": timeBetweenTends})
for i in range(0, numTends):
console.print("Tend {}".format(i))
snap.settTend({"from": strategyKeeper})
chain.sleep(timeBetweenTends)
chain.mine()
with brownie.reverts("onlyAuthorizedActors"):
strategy.harvest({"from": randomUser})
snap.settHarvest({"from": strategyKeeper})
def test_single_user_harvest_flow(settId):
suiteName = "test_single_user_harvest_flow" + ": " + settId
testRecorder = TestRecorder(suiteName)
badger = badger_single_sett(settId)
controller = badger.getController(settId)
sett = badger.getSett(settId)
strategy = badger.getStrategy(settId)
want = badger.getStrategyWant(settId)
snap = SnapshotManager(badger, settId)
deployer = badger.deployer
randomUser = accounts[6]
tendable = strategy.isTendable()
startingBalance = want.balanceOf(deployer)
depositAmount = Wei("1 ether")
assert startingBalance >= depositAmount
# Deposit
want.approve(sett, MaxUint256, {"from": deployer})
snap.settDeposit(depositAmount, {"from": deployer})
# Earn
snap.settEarn(depositAmount, {"from": deployer})
if tendable:
with brownie.reverts("onlyAuthorizedActors"):
strategy.tend({"from": randomUser})
snap.settTend({"from": deployer})
chain.sleep(days(0.5))
chain.mine()
if tendable:
snap.settTend({"from": deployer})
chain.sleep(days(1))
chain.mine()
with brownie.reverts("onlyAuthorizedActors"):
strategy.harvest({"from": randomUser})
snap.settHarvest({"from": deployer})
chain.sleep(days(1))
chain.mine()
if tendable:
snap.settTend({"from": deployer})
chain.sleep(days(3))
chain.mine()
snap.settHarvest({"from": deployer})
snap.settWithdrawAll({"from": deployer})
endingBalance = want.balanceOf(deployer)
assert endingBalance > startingBalance
def tend_all(badger: BadgerSystem, skip, min_profit=0):
"""
Runs tend function for strategies if they are expected to be profitable.
If a profit estimate fails for any reason the default behavior is to treat it as having a profit of zero.
:param badger: badger system
:param skip: strategies to skip checking
:param min_profit: minimum estimated profit (in ETH or BNB) required for harvest to be executed on chain
"""
table = []
for key, vault in badger.sett_system.vaults.items():
if key in skip:
continue
strategy = badger.getStrategy(key)
if not strategy.isTendable():
continue
console.print("\n[bold green]===== Tend: " + key +
" =====[/bold green]\n")
snap = SnapshotManager(badger, key)
strategy = badger.getStrategy(key)
before = snap.snap()
if strategy.keeper() == badger.badgerRewardsManager:
estimated_profit = snap.estimateProfitTendViaManager(
key, strategy, {
"from": keeper,
"gas_limit": 1000000
}, min_profit)
if estimated_profit >= min_profit:
snap.settTendViaManager(
strategy,
{
"from": keeper,
"gas_limit": 1000000
},
confirm=False,
)
else:
keeper = accounts.at(strategy.keeper())
estimated_profit = snap.estimateProfitTend(key, {
"from": keeper,
"gas_limit": 1000000
}, min_profit)
if estimated_profit >= min_profit:
snap.settTend(
{
"from": keeper,
"gas_limit": 1000000
},
confirm=False,
)
tx_wait()
if rpc.is_active():
chain.mine()
after = snap.snap()
snap.printCompare(before, after)
def single_user_harvest_flow(badger: BadgerSystem, sett_id, user):
controller = badger.getController("native")
strategy = badger.getStrategy(sett_id)
want = interface.IERC20(strategy.want())
snap = SnapshotManager(badger, sett_id)
sett = badger.getSett(sett_id)
strategist = accounts.at(strategy.strategist(), force=True)
console.log({
"key":
sett_id,
"want":
strategy.want(),
"token0":
strategy.token0(),
"token1":
strategy.token1(),
"path0":
strategy.getTokenSwapPath(registry.pancake.cake, strategy.token0()),
"path1":
strategy.getTokenSwapPath(registry.pancake.cake, strategy.token1()),
})
strategist = badger.deployer
settKeeper = accounts.at(sett.keeper(), force=True)
strategyKeeper = accounts.at(strategy.keeper(), force=True)
randomUser = accounts[6]
tendable = strategy.isTendable()
startingBalance = want.balanceOf(user)
depositAmount = startingBalance // 200
assert startingBalance >= depositAmount
assert startingBalance >= 0
# Deposit
want.approve(sett, MaxUint256, {"from": user})
snap.settDeposit(depositAmount, {"from": user})
assert want.balanceOf(sett) > 0
print("want.balanceOf(sett)", want.balanceOf(sett))
# Earn
snap.settEarn({"from": settKeeper})
numTends = 48
timeBetweenTends = days(0.5) // numTends
console.print({"numTends": numTends, "timeBetweenTends": timeBetweenTends})
for i in range(0, numTends):
console.print("Tend {}".format(i))
snap.settTend({"from": strategyKeeper})
chain.sleep(timeBetweenTends)
chain.mine()
snap.settHarvest({"from": strategyKeeper})
# if tendable:
# snap.settTend({"from": strategyKeeper})
# snap.settWithdraw(depositAmount // 2, {"from": user})
# chain.sleep(days(3))
# chain.mine()
# snap.settHarvest({"from": strategyKeeper})
# snap.settWithdraw(depositAmount // 2 - 1, {"from": user})
assert False
def assert_single_user_harvest_flow(settConfig):
badger = badger_single_sett(settConfig)
sett = badger.getSett(settConfig["id"])
strategy = badger.getStrategy(settConfig["id"])
want = badger.getStrategyWant(settConfig["id"])
settKeeper = accounts.at(sett.keeper(), force=True)
strategyKeeper = accounts.at(strategy.keeper(), force=True)
snap = SnapshotManager(badger, settConfig["id"])
deployer = badger.deployer
randomUser = accounts[6]
tendable = strategy.isTendable()
startingBalance = want.balanceOf(deployer)
depositAmount = startingBalance // 2
assert startingBalance >= depositAmount
assert startingBalance >= 0
# Deposit
want.approve(sett, MaxUint256, {"from": deployer})
snap.settDeposit(depositAmount, {"from": deployer})
assert want.balanceOf(sett) > 0
print("want.balanceOf(sett)", want.balanceOf(sett))
# Earn
snap.settEarn({"from": settKeeper})
if tendable:
with brownie.reverts("onlyAuthorizedActors"):
strategy.tend({"from": randomUser})
snap.settTend({"from": strategyKeeper})
chain.sleep(days(0.5))
chain.mine()
if tendable:
snap.settTend({"from": strategyKeeper})
chain.sleep(days(1))
chain.mine()
with brownie.reverts("onlyAuthorizedActors"):
strategy.harvest({"from": randomUser})
snap.settHarvest({"from": strategyKeeper})
chain.sleep(days(1))
chain.mine()
if tendable:
snap.settTend({"from": strategyKeeper})
snap.settWithdraw(depositAmount // 2, {"from": deployer})
chain.sleep(days(3))
chain.mine()
snap.settHarvest({"from": strategyKeeper})
snap.settWithdraw(depositAmount // 2 - 1, {"from": deployer})
def assert_single_user_harvest_flow_remove_fees(settConfig):
suiteName = "assert_single_user_harvest_flow_remove_fees" + ": " + settConfig[
"id"]
badger = badger_single_sett(settConfig)
controller = badger.getController(settConfig["id"])
sett = badger.getSett(settConfig["id"])
strategy = badger.getStrategy(settConfig["id"])
want = badger.getStrategyWant(settConfig["id"])
deployer = badger.deployer
randomUser = accounts[6]
snap = SnapshotManager(badger, settConfig["id"])
tendable = strategy.isTendable()
startingBalance = want.balanceOf(deployer)
strategyKeeper = accounts.at(strategy.keeper(), force=True)
depositAmount = Wei("1 ether")
assert startingBalance >= depositAmount
# Deposit
want.approve(sett, MaxUint256, {"from": deployer})
sett.deposit(depositAmount, {"from": deployer})
# Earn
sett.earn({"from": strategyKeeper})
chain.sleep(days(0.5))
chain.mine()
if tendable:
tx = snap.settTend({"from": strategyKeeper})
chain.sleep(days(1))
chain.mine()
with brownie.reverts("onlyAuthorizedActors"):
strategy.harvest({"from": randomUser})
snap.settHarvest({"from": strategyKeeper})
# Harvesting on the HarvestMetaFarm does not increase the underlying position, it sends rewards to the rewardsTree
# For HarvestMetaFarm, we expect FARM rewards to be distributed to rewardsTree
assert want.balanceOf(controller.rewards()) > 0
chain.sleep(days(1))
chain.mine()
if tendable:
tx = strategy.tend({"from": strategyKeeper})
chain.sleep(days(3))
chain.mine()
tx = snap.settHarvest({"from": strategyKeeper})
sett.withdrawAll({"from": deployer})
endingBalance = want.balanceOf(deployer)
report = {
"time": "4 days",
"gains": endingBalance - startingBalance,
"gainsPercentage": (endingBalance - startingBalance) / startingBalance,
}
print(report)
