def rebase(badger: BadgerSystem, account):
digg = badger.digg
supplyBefore = digg.token.totalSupply()
print("spfBefore", digg.token._sharesPerFragment())
print("supplyBefore", digg.token.totalSupply())
print(digg.cpiMedianOracle.getData.call())
sushi = SushiswapSystem()
pair = sushi.getPair(digg.token, registry.tokens.wbtc)
uni = UniswapSystem()
uniPair = uni.getPair(digg.token, registry.tokens.wbtc)
last_rebase_time = digg.uFragmentsPolicy.lastRebaseTimestampSec()
min_rebase_time = digg.uFragmentsPolicy.minRebaseTimeIntervalSec()
in_rebase_window = digg.uFragmentsPolicy.inRebaseWindow()
now = chain.time()
time_since_last_rebase = now - last_rebase_time
min_time_passed = (last_rebase_time + min_rebase_time) < now
console.print({
"last_rebase_time": last_rebase_time,
"in_rebase_window": in_rebase_window,
"now": now,
"time_since_last_rebase": time_since_last_rebase,
"min_time_passed": min_time_passed,
})
# Rebase if sufficient time has passed since last rebase and we are in the window.
# Give adequate time between TX attempts
if time_since_last_rebase > hours(
2) and in_rebase_window and min_time_passed:
console.print(
"[bold yellow]===== 📈 Rebase! 📉=====[/bold yellow]")
print("pair before", pair.getReserves())
print("uniPair before", uniPair.getReserves())
tx_timer.start_timer(account, "Rebase")
tx = digg.orchestrator.rebase({"from": account})
tx_timer.end_timer()
if rpc.is_active():
chain.mine()
print(tx.call_trace())
print(tx.events)
supplyAfter = digg.token.totalSupply()
print("spfAfter", digg.token._sharesPerFragment())
print("supplyAfter", supplyAfter)
print("supplyChange", supplyAfter / supplyBefore)
print("supplyChangeOtherWay", supplyBefore / supplyAfter)
print("pair after", pair.getReserves())
print("uniPair after", uniPair.getReserves())
else:
console.print("[white]===== No Rebase =====[/white]")
def verify_rewards(badger: BadgerSystem, startBlock, endBlock, before_data, after_data):
before = before_data["claims"]
after = after_data["claims"]
print(startBlock, endBlock)
periodStartTime = web3.eth.getBlock(int(startBlock))["timestamp"]
periodEndTime = web3.eth.getBlock(int(endBlock))["timestamp"]
digg_contract = get_digg_contract()
spf = digg_contract._initialSharesPerFragment()
expected_totals = get_expected_total_rewards(periodEndTime)
sanity_badger = expected_totals["badger"]
sanity_digg = expected_totals["digg"] * digg_contract._initialSharesPerFragment()
total_before_badger = before_data["tokenTotals"][badger_token]
total_before_digg = before_data["tokenTotals"][digg_token]
total_before_farm = int(before_data["tokenTotals"][farm_token])
total_before_xsushi = int(before_data["tokenTotals"][xSushi_token])
total_before_dfd = int(before_data["tokenTotals"].get(dfd_token, 0))
total_after_badger = after_data["tokenTotals"][BADGER]
total_after_digg = after_data["tokenTotals"][DIGG]
total_after_farm = int(after_data["tokenTotals"][farm_token])
total_after_xsushi = int(after_data["tokenTotals"][xSushi_token])
total_after_dfd = int(after_data["tokenTotals"].get(dfd_token, 0))
digg_badger = total_after_badger - total_before_badger
diff_digg = total_after_digg - total_before_digg
table = []
table.append(["block range", startBlock, endBlock])
table.append(["block duration", int(endBlock) - int(startBlock), "-"])
table.append(["duration", hours(periodEndTime - periodStartTime), "-"])
table.append(["badger before", val(total_before_badger), "-"])
table.append(["badger after", val(total_after_badger), "-"])
table.append(["badger diff", val(digg_badger), "-"])
table.append(["badger sanity ", val(sanity_badger), "-"])
table.append(["digg before", val(total_before_digg // spf, decimals=9), "-"])
table.append(["digg after", val(total_after_digg // spf, decimals=9), "-"])
table.append(["digg diff", val(diff_digg // spf, decimals=9), "-"])
table.append(["digg sanity", val(sanity_digg // spf, decimals=9), "-"])
print(tabulate(table, headers=["key", "value", "scaled"]))
print_token_diff_table("Farm", total_before_farm, total_after_farm, 0)
print_token_diff_table("xSushi", total_before_xsushi, total_after_xsushi, 0)
print_token_diff_table("dfd", total_before_dfd, total_after_dfd, 40000 * 1e18)
assert total_after_digg < sanity_digg
assert total_after_badger < sanity_badger
def verify_rewards(badger: BadgerSystem, startBlock, endBlock, before_data, after_data):
before = before_data["claims"]
after = after_data["claims"]
print(startBlock, endBlock)
periodStartTime = web3.eth.getBlock(int(startBlock))["timestamp"]
periodEndTime = web3.eth.getBlock(int(endBlock))["timestamp"]
digg_contract = get_digg_contract()
spf = digg_contract._initialSharesPerFragment()
expected_totals = get_expected_total_rewards(periodEndTime)
sanity_badger = expected_totals["badger"]
sanity_digg = expected_totals["digg"] * digg_contract._initialSharesPerFragment()
total_before_badger = int(before_data["tokenTotals"].get(BADGER, 0))
total_after_badger = int(after_data["tokenTotals"].get(BADGER, 0))
total_before_digg = int(before_data["tokenTotals"].get(DIGG, 0))
total_after_digg = int(after_data["tokenTotals"].get(DIGG, 0))
diff_badger = total_after_badger - total_before_badger
diff_digg = total_after_digg - total_before_digg
table = []
table.append(["block range", startBlock, endBlock])
table.append(["block duration", int(endBlock) - int(startBlock), "-"])
table.append(["duration", hours(periodEndTime - periodStartTime), "-"])
table.append(["badger before", val(total_before_badger), "-"])
table.append(["badger after", val(total_after_badger), "-"])
table.append(["badger diff", val(diff_badger), "-"])
table.append(["badger sanity ", val(sanity_badger), "-"])
table.append(["digg before", val(total_before_digg // spf, decimals=9), "-"])
table.append(["digg after", val(total_after_digg // spf, decimals=9), "-"])
table.append(["digg diff", val(diff_digg // spf, decimals=9), "-"])
table.append(["digg sanity", val(sanity_digg // spf, decimals=9), "-"])
print(tabulate(table, headers=["key", "value", "scaled"]))
for name, token in TOKENS_TO_CHECK.items():
if name in ["Digg", "Badger"]:
continue
total_before_token = int(before_data["tokenTotals"].get(token, 0))
total_after_token = int(after_data["tokenTotals"].get(token, 0))
print_token_diff_table(
name, total_before_token, total_after_token, 20000 * 1e18
)
assert total_after_digg < sanity_digg
assert total_after_badger < sanity_badger
def verify_rewards(badger: BadgerSystem, startBlock, endBlock, before_data,
after_data):
before = before_data["claims"]
after = after_data["claims"]
print(startBlock, endBlock)
periodStartTime = web3.eth.getBlock(int(startBlock))["timestamp"]
periodEndTime = web3.eth.getBlock(int(endBlock))["timestamp"]
spf = digg_contract._initialSharesPerFragment()
expected_totals = get_expected_total_rewards(periodEndTime)
sanity_badger = expected_totals["badger"]
sanity_digg = expected_totals[
"digg"] * digg_contract._initialSharesPerFragment()
total_before_badger = before_data["tokenTotals"][badger_token]
total_before_digg = before_data["tokenTotals"][digg_token]
total_after_badger = after_data["tokenTotals"][badger_token]
total_after_digg = after_data["tokenTotals"][digg_token]
digg_badger = total_after_badger - total_before_badger
diff_digg = total_after_digg - total_before_digg
table = []
table.append(["block range", startBlock, endBlock])
table.append(["block duration", int(endBlock) - int(startBlock), "-"])
table.append(["duration", hours(periodEndTime - periodStartTime), "-"])
table.append(["badger before", val(total_before_badger), "-"])
table.append(["badger after", val(total_after_badger), "-"])
table.append(["badger diff", val(digg_badger), "-"])
table.append(["badger sanity ", val(sanity_badger), "-"])
table.append(
["digg before",
val(total_before_digg // spf, decimals=9), "-"])
table.append(["digg after", val(total_after_digg // spf, decimals=9), "-"])
table.append(["digg diff", val(diff_digg // spf, decimals=9), "-"])
table.append(["digg sanity", val(sanity_digg // spf, decimals=9), "-"])
print(tabulate(table, headers=["key", "value", "scaled"]))
assert total_after_digg < sanity_digg
assert total_after_badger < sanity_badger
def main():
badger = connect_badger(badger_config.prod_json)
deployer = badger.deployer
multi = GnosisSafe(badger.devMultisig)
rebaseParams = {}
rebaseParams[
"minRebaseTimeIntervalSec"] = badger.digg.uFragmentsPolicy.minRebaseTimeIntervalSec(
)
rebaseParams[
"rebaseWindowOffsetSec"] = badger.digg.uFragmentsPolicy.rebaseWindowOffsetSec(
)
rebaseParams[
"rebaseWindowLengthSec"] = badger.digg.uFragmentsPolicy.rebaseWindowLengthSec(
)
console.print(rebaseParams)
newWindowLength = hours(6)
console.print(newWindowLength)
multi.execute(
MultisigTxMetadata(description="Set Rebase Params"),
{
"to":
badger.digg.uFragmentsPolicy.address,
"data":
badger.digg.uFragmentsPolicy.setRebaseTimingParameters.
encode_input(
rebaseParams["minRebaseTimeIntervalSec"],
rebaseParams["rebaseWindowOffsetSec"],
newWindowLength,
),
},
)
chain.mine()
tx = badger.digg.orchestrator.rebase({"from": badger.deployer})
print(tx.call_trace())
tx = badger.digg.orchestrator.rebase({"from": badger.deployer})
print(tx.call_trace())
"native.cvxCrv",
"native.cvx",
],
},
"bsc": {
"harvest":
["native.pancakeBnbBtcB", "native.pancakeBnbBtcb", "native.test"],
"tend": [],
"earn": [],
},
}
run_intervals = {
"eth": {
"harvest": days(1),
"tend": hours(12),
"earn": minutes(60),
},
"bsc": {
"harvest": minutes(10),
"tend": minutes(15),
"earn": minutes(10),
},
}
earn_default_percentage_threshold = 0.01
btc_threshold = Wei("2 ether")
earn_threshold_value_override = {
"eth": {
"native.renCrv": btc_threshold,
def __init__(self):
self.globalStakingStartBlock = 11252068
self.rootUpdateMinInterval = hours(0.9)
self.maxStartBlockAge = 3200
self.debug = False
def main():
"""
Connect to badger system, and configure multisig for running transactions in local fork without access to accounts
"""
# Connect badger system from file
badger = connect_badger()
digg = badger.digg
# Sanity check file addresses
expectedMultisig = "0xB65cef03b9B89f99517643226d76e286ee999e77"
assert badger.devMultisig == expectedMultisig
if rpc.is_active():
distribute_test_ether(badger.devMultisig, Wei("5 ether"))
# Multisig wrapper
# Get price data from sushiswap, uniswap, and coingecko
digg_usd_coingecko = 41531.72
btc_usd_coingecko = 32601.13
digg_per_btc = digg_usd_coingecko / btc_usd_coingecko
uniTWAP = get_average_daily_price("scripts/oracle/data/uni_digg_hour")
sushiTWAP = get_average_daily_price("scripts/oracle/data/sushi_digg_hour")
averageTWAP = Average([uniTWAP, sushiTWAP])
console.print({
"uniTWAP": uniTWAP,
"sushiTWAP": sushiTWAP,
"averageTWAP": averageTWAP
})
supplyBefore = digg.token.totalSupply()
print("spfBefore", digg.token._sharesPerFragment())
print("supplyBefore", digg.token.totalSupply())
marketValue = Wei(str(averageTWAP) + " ether")
print(marketValue)
print(int(marketValue * 10**18))
print("digg_per_btc", digg_per_btc, averageTWAP, marketValue)
if rpc.is_active():
distribute_test_ether(digg.centralizedOracle, Wei("5 ether"))
centralizedMulti = GnosisSafe(digg.centralizedOracle)
print(digg.marketMedianOracle.providerReports(digg.centralizedOracle, 0))
print(digg.marketMedianOracle.providerReports(digg.centralizedOracle, 1))
print(digg.cpiMedianOracle.providerReports(digg.constantOracle, 0))
print(digg.cpiMedianOracle.providerReports(digg.constantOracle, 1))
print(digg.cpiMedianOracle.getData.call())
sushi = SushiswapSystem()
pair = sushi.getPair(digg.token, registry.tokens.wbtc)
uni = UniswapSystem()
uniPair = uni.getPair(digg.token, registry.tokens.wbtc)
print("pair before", pair.getReserves())
print("uniPair before", uniPair.getReserves())
tx = centralizedMulti.execute(
MultisigTxMetadata(description="Set Market Data"),
{
"to": digg.marketMedianOracle.address,
"data":
digg.marketMedianOracle.pushReport.encode_input(marketValue),
},
)
chain.mine()
print(tx.call_trace())
print(tx.events)
chain.sleep(hours(0.4))
chain.mine()
in_rebase_window = digg.uFragmentsPolicy.inRebaseWindow()
while not in_rebase_window:
print("Not in rebase window...")
chain.sleep(hours(0.1))
chain.mine()
in_rebase_window = digg.uFragmentsPolicy.inRebaseWindow()
tx = digg.orchestrator.rebase({"from": accounts[0]})
chain.mine()
supplyAfter = digg.token.totalSupply()
print("spfAfter", digg.token._sharesPerFragment())
print("supplyAfter", supplyAfter)
print("supplyChange", supplyAfter / supplyBefore)
print("supplyChangeOtherWay", supplyBefore / supplyAfter)
print("pair after", pair.getReserves())
print("uniPair after", uniPair.getReserves())
def main():
badger = connect_badger("deploy-final.json")
admin = badger.devProxyAdmin
multisig = badger.devMultisig
contracts = badger.contracts_upgradeable
deployer = badger.deployer
expectedMultisig = "0xB65cef03b9B89f99517643226d76e286ee999e77"
assert multisig == expectedMultisig
"""
Total $BADGER 603,750
Setts
renbtcCRV — 83,437.5 $BADGER
sbtcCRV — 83,437.5 $BADGER
tbtcCRV — 83,437.5 $BADGER
Badger — 70,000 $BADGER
(NEW) wBTC/ETH Sushiswap LP — 40,000 $BADGER
Badger <>wBTC Uniswap LP — 110,000 $BADGER
(NEW) Badger <>wBTC Sushiswap LP— 50,000 $BADGER
wbtc/eth = 34,285 $BADGER (which should be distributed evenly over 3 days ie today 1pm to tomorrow, tomorrow to wednesday, wed- thursday then new emissions)
Badger <>wBTC Sushiswap LP— 30,000 $BADGER (10k/day)
Super Sett
Harvest renbtc CRV —83,437.5 $BADGER
"""
rest = RewardsSchedule(badger)
rest.setStart(to_timestamp(datetime.datetime(2020, 12, 28, 16, 30)))
rest.setDuration(hours(67.5))
rest.setAmounts({
"native.sushiWbtcEth": Wei("34285 ether"),
"native.sushiBadgerWbtc": Wei("30000 ether"),
})
# rest.setAmounts(
# {
# "native.sushiWbtcEth": Wei("60000 ether"),
# "native.sushiBadgerWbtc": Wei("83437.5 ether"),
# "native.sbtcCrv": Wei("83437.5 ether"),
# "native.tbtcCrv": Wei("83437.5 ether"),
# "native.uniBadgerWbtc": Wei("110000 ether"),
# "harvest.renCrv": Wei("83437.5 ether"),
# }
# )
rest.testTransactions()
rest.printState("Week 4 - Sushi Emerges")
total = rest.total
expected = Wei("64285 ether")
print("overall total ", total)
print("expected total ", expected)
assert total == expected
console.print("\n[green] ✅ Total matches expected {} [/green]".format(
val(expected)))
def rootUpdater(badger, startBlock, endBlock, test=True):
"""
Root Updater Role
- Check how much time has passed since the last published update
- If sufficient time has passed, run the rewards script and p
- If there is a discrepency, notify admin
(In case of a one-off failure, Script will be attempted again at the rootUpdaterInterval)
"""
badgerTree = badger.badgerTree
keeper = badger.keeper
nextCycle = getNextCycle(badger)
assert keeper == badger.keeper
console.print("\n[bold cyan]===== Root Updater =====[/bold cyan]\n")
currentMerkleData = fetchCurrentMerkleData(badger)
currentRewards = fetch_current_rewards_tree(badger)
currentTime = chain.time()
timeSinceLastupdate = currentTime - currentMerkleData["lastUpdateTime"]
if timeSinceLastupdate < hours(0):
console.print(
"[bold yellow]===== Result: Last Update too Recent =====[/bold yellow]"
)
return False
if badgerTree.hasPendingRoot():
console.print(
"[bold yellow]===== Result: Pending Root Since Last Update =====[/bold yellow]"
)
return False
print("Geyser Rewards", startBlock, endBlock, nextCycle)
geyserRewards = calc_geyser_rewards(badger, startBlock, endBlock,
nextCycle)
# metaFarmRewards = calc_harvest_meta_farm_rewards(badger, startBlock, endBlock)
newRewards = geyserRewards
cumulativeRewards = process_cumulative_rewards(currentRewards, newRewards)
# Take metadata from geyserRewards
console.print("Processing to merkle tree")
merkleTree = rewards_to_merkle_tree(cumulativeRewards, startBlock,
endBlock, geyserRewards)
# Publish data
rootHash = hash(merkleTree["merkleRoot"])
contentFileName = content_hash_to_filename(rootHash)
console.log({
"merkleRoot": merkleTree["merkleRoot"],
"rootHash": str(rootHash),
"contentFile": contentFileName,
"startBlock": startBlock,
"endBlock": endBlock,
"currentContentHash": currentMerkleData["contentHash"],
})
print("Uploading to file " + contentFileName)
# TODO: Upload file to AWS & serve from server
with open(contentFileName, "w") as outfile:
json.dump(merkleTree, outfile)
with open(contentFileName) as f:
after_file = json.load(f)
compare_rewards(
badger,
startBlock,
endBlock,
currentRewards,
after_file,
currentMerkleData["contentHash"],
)
console.print("===== Root Updater Complete =====")
if not test:
upload(contentFileName)
badgerTree.proposeRoot(merkleTree["merkleRoot"], rootHash,
merkleTree["cycle"])
return True
def test_single_user_harvest_flow(settConfig):
badger = badger_single_sett(settConfig)
depositAmount = 50 * 1e8 # renBTC decimal is 8
# test settings
controller = badger.getController(settConfig["id"])
sett = badger.getSett(settConfig["id"])
strategy = badger.getStrategy(settConfig["id"])
want = badger.getStrategyWant(settConfig["id"])
deployer = badger.deployer
# production settings
# controller = interface.IController("0x9b4efa18c0c6b4822225b81d150f3518160f8609");
# sett = interface.ISett("0x77f07Dd580cc957109c70c7fa81aa5704f8a3572")
# strategy = StrategyUnitProtocolRenbtc.at("0x5640d6E2F72e76FBCb5296d59EA28C7375F1fE12");
# want = interface.IERC20("0xEB4C2781e4ebA804CE9a9803C67d0893436bB27D")
# deployer = accounts.at("0x576cD258835C529B54722F84Bb7d4170aA932C64", force=True)
# controllerGov = accounts.at("0xB65cef03b9B89f99517643226d76e286ee999e77", force=True)
# ethWhale = accounts.at("0x3f5CE5FBFe3E9af3971dD833D26bA9b5C936f0bE", force=True)
# ethWhale.transfer(deployer, "100 ether")
# settGuestList = interface.IVipCappedGuestList("0x9FC48e61B6a75eE263ca160aCF3288A99238719E");
# settGuestList.setGuests([deployer], [True], {"from": deployer});
# settGuestList.setUserDepositCap(depositAmount * 2, {"from": deployer});
# settGuestList.setTotalDepositCap(depositAmount * 10, {"from": deployer});
# controller.setVault(want, sett, {"from": deployer});
# controller.approveStrategy(want, strategy, {"from": controllerGov});
# controller.setStrategy(want, strategy, {"from": deployer});
settKeeper = accounts.at(sett.keeper(), force=True)
strategyKeeper = accounts.at(strategy.keeper(), force=True)
snap = SnapshotManager(badger, settConfig["id"])
governance = strategy.governance()
tendable = strategy.isTendable()
distribute_from_whales(deployer)
startingBalance = want.balanceOf(deployer)
assert startingBalance >= depositAmount
assert startingBalance >= 0
# Deposit
want.approve(sett, MaxUint256, {"from": deployer})
# sett.deposit(depositAmount, {"from": deployer});
snap.settDeposit(depositAmount, {"from": deployer})
assert want.balanceOf(sett) > 0
print("want.balanceOf(sett)", want.balanceOf(sett))
# Earn
# sett.earn({"from": settKeeper});
snap.settEarn({"from": settKeeper})
# Harvest
chain.sleep(hours(0.1))
chain.mine()
# strategy.harvest({"from": strategyKeeper})
snap.settHarvest({"from": strategyKeeper})
# Withdraw half
# sett.withdraw(depositAmount // 2, {"from": deployer})
snap.settWithdraw(depositAmount // 2, {"from": deployer})
# KeepMinRatio to maintain collateralization safe enough from liquidation
currentRatio = strategy.currentRatio()
safeRatio = currentRatio + 20
strategy.setMinRatio(safeRatio, {"from": governance})
strategy.keepMinRatio({"from": governance})
assert strategy.currentRatio() > safeRatio
# sugar-daddy usdp discrepancy due to accrued interest in Unit Protocol
debtTotal = strategy.getDebtBalance()
curveGauge = interface.ICurveGauge(
"0x055be5DDB7A925BfEF3417FC157f53CA77cA7222")
usdp3crvInGauge = curveGauge.balanceOf(strategy)
curvePool = interface.ICurveFi(
"0x42d7025938bEc20B69cBae5A77421082407f053A")
usdpOfPool = curvePool.calc_withdraw_one_coin(usdp3crvInGauge, 0)
sugar = (debtTotal - usdpOfPool) * 2
usdpToken = interface.IERC20("0x1456688345527bE1f37E9e627DA0837D6f08C925")
if sugar > 0:
usdpToken.transfer(strategy, sugar, {"from": deployer})
print("sugar debt=", sugar)
# Harvest again
chain.sleep(hours(0.1))
chain.mine()
# strategy.harvest({"from": strategyKeeper})
snap.settHarvest({"from": strategyKeeper})
# Withdraw all
wantInSettBalance = sett.getPricePerFullShare() * sett.totalSupply() / 1e18
print("wantInSett=", wantInSettBalance)
print("wantInStrategy=", strategy.balanceOfPool())
print("pricePerFullShare=", sett.getPricePerFullShare())
wantToWithdraw = sett.balanceOf(
deployer) * sett.getPricePerFullShare() / 1e18
print("wantToWithdraw=", wantToWithdraw)
assert wantToWithdraw <= wantInSettBalance
sugarWithdrawAll = (strategy.getDebtBalance() -
strategy.balanceOfPool()) * 2
if sugarWithdrawAll > 0:
usdpToken.transfer(strategy, sugarWithdrawAll, {"from": deployer})
print("sugarWithdrawAll=", sugarWithdrawAll)
renbtcToken = interface.IERC20(
"0xEB4C2781e4ebA804CE9a9803C67d0893436bB27D")
controller.withdrawAll(renbtcToken, {"from": deployer})
# sett.withdrawAll({"from": deployer})
snap.settWithdrawAll({"from": deployer})
assert True
def main():
test = True
fileName = "deploy-" + "final" + ".json"
badger = connect_badger(fileName)
coverage_expire_timestamp = 1614470400 # 2/28/2021 12:00 AM UTC
rewards_expire_timestamp = coverage_expire_timestamp - days(
1) # 2/27/2021 12:00 AM UTC
print(rewards_expire_timestamp, 1614384000)
assert rewards_expire_timestamp == 1614384000
multisig = badger.devMultisig
deployer = badger.deployer
rewardsEscrow = badger.rewardsEscrow
convert_to_test_mode(multisig)
blacksmith = Contract.from_explorer(
"0xe0b94a7bb45dd905c79bb1992c9879f40f1caed5")
confirm_blacksmith_contract(blacksmith)
claimAmount = Wei("46875 ether")
noClaimAmount = Wei("78125 ether")
claimLp = Contract.from_explorer(
"0xbad3ca7e741f785a05d7b3394db79fcc4b6d85af")
noClaimLp = Contract.from_explorer(
"0xa553c12ab7682efda28c47fdd832247d62788273")
total = claimAmount + noClaimAmount
assert total == Wei("125000 ether")
# Approve blacksmith as valid recipient
data = badger.rewardsEscrow.approveRecipient.encode_input(blacksmith)
exec_direct(multisig, {
"to": rewardsEscrow.address,
"data": data
}, deployer)
print("ove blacksmith as valid recipient")
print(rewardsEscrow.address)
print(data)
# Approve BADGER token as valid recipient
data = badger.rewardsEscrow.approveRecipient.encode_input(badger.token)
exec_direct(multisig, {
"to": rewardsEscrow.address,
"data": data
}, deployer)
print("Approve BADGER token as valid recipient")
print(rewardsEscrow.address)
print(data)
# Approve blacksmith to take appropriate BADGER amount
call = badger.token.approve.encode_input(blacksmith, total)
data = badger.rewardsEscrow.call.encode_input(badger.token, 0, call)
exec_direct(multisig, {
"to": rewardsEscrow.address,
"data": data
}, deployer)
print("Approve blacksmith to take appropriate BADGER amount")
print(rewardsEscrow.address)
print(call)
print(data)
assert badger.token.allowance(rewardsEscrow, blacksmith) == total
startTime = 1607293800
endTime = rewards_expire_timestamp
print(chain.time())
assert startTime - chain.time() > 0
assert startTime - chain.time() < hours(2)
# Transfer CLAIM amount to blacksmith
call = blacksmith.addBonusToken.encode_input(claimLp, badger.token,
startTime, endTime,
claimAmount)
data = badger.rewardsEscrow.call.encode_input(blacksmith, 0, call)
exec_direct(multisig, {
"to": rewardsEscrow.address,
"data": data
}, deployer)
print("Transfer CLAIM amount to blacksmith")
print(rewardsEscrow.address)
print(call)
print(data)
assert badger.token.balanceOf(blacksmith) == claimAmount
# Transfer NOCLAIM amount to blacksmith
print("Transfer NOCLAIM amount to blacksmith")
call = blacksmith.addBonusToken.encode_input(noClaimLp, badger.token,
startTime, endTime,
noClaimAmount)
data = badger.rewardsEscrow.call.encode_input(blacksmith, 0, call)
exec_direct(multisig, {
"to": rewardsEscrow.address,
"data": data
}, deployer)
print("Transfer NOCLAIM amount to blacksmith")
print(rewardsEscrow.address)
print(call)
print(data)
assert badger.token.balanceOf(blacksmith) == total
from helpers.time_utils import hours
from dotmap import DotMap
rewards_config = DotMap(
globalStakingStartBlock=11252068, rootUpdateInterval=hours(2) - 300,
)