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, )