def test_tip_after_withdrawn(ygift, token, giftee, chain, duration): amount = Wei("1000 ether") tip = amount / 2 start = chain[-1].timestamp token.approve(ygift, 2**256 - 1) ygift.mint(giftee, token, amount, "name", "msg", "url", start, duration) chain.sleep(duration) ygift.collect(0, 2**256 - 1, {"from": giftee}) ygift.tip(0, tip, "tip") ygift.collect(0, 2**256 - 1, {"from": giftee}) gift = ygift.gifts(0).dict() assert gift["amount"] == 0 assert gift["tipped"] == 0 assert token.balanceOf(giftee) == amount + tip
def test_change_debt_with_profit(gov, token, vault, dudesahn, whale, strategy, curveVoterProxyStrategy): token.approve(vault, 2**256 - 1, {"from": whale}) vault.deposit(100e18, {"from": whale}) strategy.harvest({"from": dudesahn}) prev_params = vault.strategies(strategy).dict() currentDebt = vault.strategies(strategy)[2] vault.updateStrategyDebtRatio(strategy, currentDebt / 2, {"from": gov}) token.transfer(strategy, Wei("100 ether"), {"from": whale}) # need to harvest our other strategy first so we don't pay all of the management fee from this strategy curveVoterProxyStrategy.harvest({"from": gov}) strategy.harvest({"from": dudesahn}) new_params = vault.strategies(strategy).dict() assert new_params["totalGain"] > prev_params["totalGain"] assert new_params["totalGain"] - prev_params["totalGain"] > Wei( "100 ether") assert new_params["debtRatio"] == currentDebt / 2 assert new_params["totalLoss"] == prev_params["totalLoss"] assert approx(vault.totalAssets() * 0.012, Wei("1 ether")) == strategy.estimatedTotalAssets()
def test_revoke_live(token_ecrv, strategy_ecrv_live, vault_ecrv_live, whale, gov_live): token_ecrv.approve(vault_ecrv_live, 2**256 - 1, {"from": whale}) vault_ecrv_live.deposit(Wei("100 ether"), {"from": whale}) strategy_ecrv_live.harvest({"from": gov_live}) genericStateOfStrat(strategy_ecrv_live, token_ecrv, vault_ecrv_live) genericStateOfVault(vault_ecrv_live, token_ecrv) vault_ecrv_live.revokeStrategy(strategy_ecrv_live, {"from": gov_live}) strategy_ecrv_live.harvest({"from": gov_live}) genericStateOfStrat(strategy_ecrv_live, token_ecrv, vault_ecrv_live) genericStateOfVault(vault_ecrv_live, token_ecrv)
def test_wrapped_props(accounts, distributor, launcpad, dai, niftsy20, weth): for i in range(distributor.balanceOf(launcpad)): logging.info('tokenId={}, erc20Balance={}, {}, ETHBalance = {}'.format( distributor.tokenOfOwnerByIndex(launcpad, i), Wei( distributor.getERC20CollateralBalance( distributor.tokenOfOwnerByIndex(launcpad, i), niftsy20)).to('ether'), Wei( distributor.getERC20CollateralBalance( distributor.tokenOfOwnerByIndex(launcpad, i), weth)).to('ether'), distributor.getTokenValue( distributor.tokenOfOwnerByIndex(launcpad, i))[0])) assert distributor.getERC20CollateralBalance( distributor.tokenOfOwnerByIndex(launcpad, i), niftsy20) == ERC20_COLLATERAL_AMOUNT assert distributor.getERC20CollateralBalance( distributor.tokenOfOwnerByIndex(launcpad, i), weth) == ERC20_COLLATERAL_AMOUNT_WETH assert distributor.getTokenValue( distributor.tokenOfOwnerByIndex(launcpad, i))[0] == Wei(ETH_AMOUNT) / COUNT
def main(): tree = json.load(open("snapshot/04-merkle.json")) user = get_user() dist = MerkleDistributor.at(DISTRIBUTOR, owner=user) if user not in tree["claims"]: return click.secho(f"{user} is not included in the distribution", fg="red") claim = tree["claims"][user] if dist.isClaimed(claim["index"]): return click.secho(f"{user} has already claimed", fg="yellow") amount = Wei(claim["amount"]).to("ether") _amount = click.style(f"{amount:,.2f} PYTHO", fg="green", bold=True) print(f"Claimable amount: {_amount}") dist.claim(claim["index"], user, claim["amount"], claim["proof"])
def test_good_migration( strategy, chain, Strategy, web3, vault, currency, whale, rando, gov, strategist ): # Call this once to seed the strategy with debt deposit_limit = Wei("1000 ether") vault.setDepositLimit(deposit_limit, {"from": gov}) vault.addStrategy(strategy, 10_000, 0, 2 ** 256 - 1, 50, {"from": gov}) amount1 = Wei("500 ether") deposit(amount1, whale, currency, vault) amount1 = Wei("50 ether") deposit(amount1, gov, currency, vault) strategy.harvest({"from": gov}) sleep(chain, 10) strategy.harvest({"from": gov}) strategy_debt = vault.strategies(strategy).dict()["totalDebt"] prior_position = strategy.estimatedTotalAssets() assert strategy_debt > 0 new_strategy = strategist.deploy(Strategy, vault) assert vault.strategies(new_strategy).dict()["totalDebt"] == 0 assert currency.balanceOf(new_strategy) == 0 # Only Governance can migrate with brownie.reverts(): vault.migrateStrategy(strategy, new_strategy, {"from": rando}) vault.migrateStrategy(strategy, new_strategy, {"from": gov}) assert vault.strategies(strategy).dict()["totalDebt"] == 0 assert vault.strategies(new_strategy).dict()["totalDebt"] == strategy_debt assert ( new_strategy.estimatedTotalAssets() > prior_position * 0.999 or new_strategy.estimatedTotalAssets() < prior_position * 1.001 )
def test_various( chain, gov, vault, rewards, strategist, strategy, wFTM, wFTM_whale, alice, bob, fUSD, fusdVault, fUSD_whale, ): wFTM.transfer(alice, Wei("1000 ether"), {"from": wFTM_whale}) wFTM.approve(vault, 2 ** 256 - 1, {"from": alice}) vault.deposit({"from": alice}) # harvest strategy.harvest({"from": gov}) chain.sleep(604800) # 1 week chain.mine(1) # Donate some fUSD to the fusdVault to mock earnings fUSD.transfer(fusdVault, Wei("10 ether"), {"from": fUSD_whale}) wFTM.transfer(bob, Wei("2000 ether"), {"from": wFTM_whale}) wFTM.approve(vault, 2 ** 256 - 1, {"from": bob}) vault.deposit({"from": bob}) # Run Harvest strategy.harvest({"from": gov}) chain.sleep(604800) # 1 week chain.mine(1) vault.withdraw({"from": alice}) # Donate some fUSD to the fusdVault to mock earnings fUSD.transfer(fusdVault, Wei("100 ether"), {"from": fUSD_whale}) # Run Harvest strategy.harvest({"from": gov}) chain.sleep(604800) # 1 week chain.mine(1) vault.withdraw({"from": bob}) assert wFTM.balanceOf(alice) > Wei("1000 ether") assert wFTM.balanceOf(bob) > Wei("1000 ether") assert strategy.balanceOfCollateral() == 0 assert strategy.balanceOfDebt() == 0 assert strategy.balanceOfFusd() < Wei("0.5 ether") # rounding error assert strategy.balanceOfFusdInVault() == 0 assert fusdVault.totalAssets() == 0
def test_claim_allocation_1(accounts, launcpadWLNative, distributor, dai, niftsy20, weth, ERC721Distr, whitelist): whitelist.increaseAllocationBatch([accounts[2], accounts[3]], zero_address, [Wei(ETH_AMOUNT)/10, 2*Wei(ETH_AMOUNT)/10], {"from": accounts[0]}) assert whitelist.availableAllocation(accounts[2], zero_address) == Wei(ETH_AMOUNT)/10 assert whitelist.availableAllocation(accounts[3], zero_address) == 2*Wei(ETH_AMOUNT)/10 whitelist.decreaseAllocationBatch([accounts[2], accounts[3]], zero_address, [0.4*Wei(ETH_AMOUNT)/10, Wei(ETH_AMOUNT)/10], {"from": accounts[0]}) assert whitelist.availableAllocation(accounts[2], zero_address) == 0.6*Wei(ETH_AMOUNT)/10 assert whitelist.availableAllocation(accounts[3], zero_address) == Wei(ETH_AMOUNT)/10
def test_claim_Ether(accounts, launcpadWL, distributor, dai, niftsy20, weth, ERC721Distr): #not enough ether with reverts("Received amount less then price"): launcpadWL.claimNFT(1, zero_address, {"value": '0.01 ether'}) #enough ether and there is the change - claim bbe1 = accounts[0].balance() payAmount = launcpadWL.getWNFTPrice(1, zero_address) + Wei(change_amount) launcpadWL.claimNFT(1, zero_address, {"value": payAmount}) assert accounts[0].balance() == bbe1 - launcpadWL.getWNFTPrice( 1, zero_address) assert launcpadWL.balance() == launcpadWL.getWNFTPrice(1, zero_address) assert distributor.balanceOf(launcpadWL) == COUNT - 1 assert distributor.balanceOf(accounts[0]) == 1 #unwrap claimed token bbe0 = accounts[0].balance() bbn0 = niftsy20.balanceOf(accounts[0]) bbw0 = weth.balanceOf(accounts[0]) bbeD = distributor.balance() bbnD = niftsy20.balanceOf(distributor) bbwD = weth.balanceOf(distributor) distributor.unWrap721(1) assert bbe0 + Wei(ETH_AMOUNT) / COUNT == accounts[0].balance() assert bbn0 + ERC20_COLLATERAL_AMOUNT == niftsy20.balanceOf(accounts[0]) assert bbw0 + ERC20_COLLATERAL_AMOUNT_WETH == weth.balanceOf(accounts[0]) assert bbeD - Wei(ETH_AMOUNT) / COUNT == distributor.balance() assert bbnD - ERC20_COLLATERAL_AMOUNT == niftsy20.balanceOf(distributor) assert bbwD - ERC20_COLLATERAL_AMOUNT_WETH == weth.balanceOf(distributor) assert distributor.balanceOf(accounts[0]) == 0
def test_apr(gov, vault, hegic, hegicStaking, strategy): hegic.approve(vault, 2**256 - 1, {"from": gov}) vault.addStrategy( strategy, 10_000, 0, 500, {"from": gov}, # 500 bps fee for strategist ) vault.deposit(Wei("888000 ether"), {"from": gov}) strategy.harvest() assert hegic.balanceOf(strategy) == 0 startingBalance = vault.totalAssets() assert startingBalance == Wei("888000 ether") stateOfStrat(strategy, hegic, hegicStaking) stateOfVault(vault, strategy) for i in range(10): day = (1 + i) * ONE_DAY print(f"\n----Day {day/ONE_DAY}----") hegicStaking.sendProfit({"value": Wei("0.1 ether")}) strategy.harvest() stateOfStrat(strategy, hegic, hegicStaking) stateOfVault(vault, strategy) profit = (vault.totalAssets() - startingBalance).to("ether") strState = vault.strategies(strategy) totalReturns = strState[6] totaleth = totalReturns.to("ether") print(f"Real Profit: {profit:.5f}") day = (1 + i) * ONE_DAY apr = (totalReturns / startingBalance) * (DAYS_PER_YEAR / day) print(f"implied apr: {apr:.8%}")
def test_withdraw_before_and_after_transfer(ygift, token, giftee, receiver, chain): amount = Wei("100 ether") start = chain[-1].timestamp token.approve(ygift, 2**256 - 1) ygift.mint(giftee, token, amount, "name", "msg", "url", start, 0) ygift.collect(0, amount / 2, {"from": giftee}) gift = ygift.gifts(0).dict() assert gift["amount"] == amount / 2 assert token.balanceOf(giftee) == amount / 2 ygift.safeTransferFrom(giftee, receiver, 0, {"from": giftee}) ygift.collect(0, amount / 4, {"from": receiver}) gift = ygift.gifts(0).dict() assert gift["amount"] == amount / 4 assert token.balanceOf(receiver) == amount / 4
def test_transfer_liquidity(liquid_lgt, accounts): sender, recipient = accounts[:2] sender_initial_liquidity = liquid_lgt.poolBalanceOf(sender) recipient_initial_liquidity = liquid_lgt.poolBalanceOf(recipient) transfer_amount = Wei("0.01 ether") tx = liquid_lgt.poolTransfer(recipient, transfer_amount, {'from': sender}) assert tx.return_value event = tx.events['TransferLiquidity'] assert event["from"] == sender assert event["to"] == recipient assert event["value"] == transfer_amount assert sender_initial_liquidity - transfer_amount == liquid_lgt.poolBalanceOf( sender) assert recipient_initial_liquidity + transfer_amount == liquid_lgt.poolBalanceOf( recipient)
def test_cannot_withdraw_not_owned_gift(ygift, token, giftee, chain, receiver): amount = Wei("100 ether") start = chain[-1].timestamp token.approve(ygift, 2**256 - 1) ygift.mint(giftee, token, amount * 10, "name", "msg", "url", start, 0) with brownie.reverts("yGift: You are not the NFT owner"): ygift.collect(0, amount, {"from": receiver}) with brownie.reverts("yGift: You are not the NFT owner"): ygift.collect(0, amount * 10, {"from": receiver}) with brownie.reverts("yGift: You are not the NFT owner"): ygift.collect(0, amount * 100, {"from": receiver}) ygift.collect(0, amount * 5, {"from": giftee}) with brownie.reverts("yGift: You are not the NFT owner"): ygift.collect(0, amount * 5, {"from": receiver})
def test_revoke(token_ecrv, strategy_ecrv, vault_ecrv, whale, gov, strategist): token_ecrv.approve(vault_ecrv, 2**256 - 1, {"from": whale}) vault_ecrv.deposit(Wei("100 ether"), {"from": whale}) strategy_ecrv.harvest({"from": strategist}) assert token_ecrv.balanceOf(vault_ecrv) < dust genericStateOfStrat(strategy_ecrv, token_ecrv, vault_ecrv) genericStateOfVault(vault_ecrv, token_ecrv) vault_ecrv.revokeStrategy(strategy_ecrv, {"from": gov}) strategy_ecrv.harvest({"from": strategist}) genericStateOfStrat(strategy_ecrv, token_ecrv, vault_ecrv) genericStateOfVault(vault_ecrv, token_ecrv)
def whale(accounts, web3, weth, gov, chain): #big binance7 wallet #acc = accounts.at('0xBE0eB53F46cd790Cd13851d5EFf43D12404d33E8', force=True) #big binance8 wallet acc = accounts.at('0xf977814e90da44bfa03b6295a0616a897441acec', force=True) #lots of weth account wethAcc = accounts.at('0x767Ecb395def19Ab8d1b2FCc89B3DDfBeD28fD6b', force=True) weth.transfer(acc, weth.balanceOf(wethAcc),{"from": wethAcc} ) weth.transfer(gov, Wei('100 ether'),{"from": acc} ) assert weth.balanceOf(acc) > 0 yield acc
def test_withdraw_gas(nftbox, voucher, minter, accounts, chain): voucher.setCaller(nftbox, True, {'from':minter}) nftbox.setBoxVoucher(voucher, {'from':minter}) nftbox.createBoxMould(50, 50, 20, Wei('0.1 ether'), [], [], "This is a test box", "", "", "", "", {'from':minter}) for i in range(1, 6): voucher.safeTransferFrom(minter, accounts[i], 1, 4, "", {'from':minter}) with brownie.reverts('!price'): nftbox.reserveBoxes(1, 4, {'from':accounts[i]}) nftbox.reserveBoxes(1, 4, {'from':accounts[i], 'value': Wei('0.1 ether') * 4 * 21 // 20}) nftbox.setLockOnBox(1, False, {'from':minter}) with brownie.reverts('ERC1155: burn amount exceeds balance'): nftbox.buyBoxesWithVouchers(1, 2, {'from':accounts[0], 'value':Wei('0.1 ether') * 2}) nftbox.distributeReservedBoxes(1, 10, {'from':minter}) assert nftbox.getReservationCount(1) == 10 assert nftbox.voucherValidityInterval(1) == 0 nftbox.distributeReservedBoxes(1, 13, {'from':minter}) assert nftbox.getReservationCount(1) == 0 assert nftbox.voucherValidityInterval(1) != 0 for i in range(1, 6): assert nftbox.balanceOf(accounts[i]) == 4 pre = minter.balance() nftbox.withdrawGasMoney({'from':minter}) assert minter.balance() == pre + 20 * 5 * Wei('0.1 ether') // 100 assert nftbox.balance() == 20 * Wei('0.1 ether')
def test_forward_with_value_exact(liquid_lgt, relayer, storage, accounts): """ send 0.2 ether with the call and buy 2 tokens """ initial_tokens = liquid_lgt.poolTokenReserves() initial_balance = accounts[0].balance() calldata = "bc25bd200000000000000000000000000000000000000000000000000000000000000000" expected_eth_sold = liquid_lgt.getEthToTokenOutputPrice(6) total_ether = Wei(expected_eth_sold + "0.2 ether") tx = relayer.forward(6, DEADLINE, storage, "0.2 ether", calldata, { 'from': accounts[0], 'value': total_ether }) assert tx.return_value == expected_eth_sold assert storage.get() == "0.2 ether" assert initial_tokens - 6 == liquid_lgt.poolTokenReserves() assert initial_balance - total_ether == accounts[0].balance()
def badger_hunt_unit(): deployer = accounts[0] badger = deploy_badger_minimal(deployer) distribute_from_whales(deployer) badger.deploy_logic("BadgerHunt", BadgerHunt) badger.deploy_badger_hunt() source = accounts.at("0x394DCfbCf25C5400fcC147EbD9970eD34A474543", force=True) badger.token.transfer(badger.badgerHunt, Wei("100000 ether"), {"from": source}) return badger
def main(): badger = connect_badger(load_deployer=True) safe = ApeSafe(badger.opsMultisig.address) helper = ApeSafeHelper(badger, safe) logger = helper.contract_from_abi(badger.rewardsLogger.address, "RewardsLogger", RewardsLogger.abi) schedules = [] # Concat schedules for all vaults for key in vaults_to_run: vault = badger.getSett(key) start = 1625158800 duration = days(7) end = start + duration badger_amount = Wei("360 ether") schedules.append( LoggerUnlockSchedule(( vault, badger.token.address, badger_amount, start, end, duration, )), ) # Add all schedules to logger for i in range(0, len(schedules)): schedule = schedules[i] logger.setUnlockSchedule( schedule.beneficiary, schedule.token, schedule.amount, schedule.start, schedule.end, schedule.duration, ) # Print for key in vaults_to_run: vault = badger.getSett(key) badger.print_logger_unlock_schedules(vault, name=vault.name()) helper.publish()
def test_owner_recovers_only_eth(deployer, stranger, steth_token): insurance_purchaser = InsurancePurchaser.deploy(steth_to_eth_max_slippage, ldo_to_steth_max_slippage, {"from": deployer}) stranger.transfer(insurance_purchaser.address, "1 ether") deployer_eth_before = deployer.balance() steth_balance = steth_token.balanceOf(deployer) # you can pass here any token insurance_purchaser.recover_erc20(steth_token.address, steth_balance, {"from": deployer}) assert insurance_purchaser.balance() == 0 assert deployer.balance() - deployer_eth_before == Wei("1 ether")
def testLoaner(accounts, requireMainnetFork, flashLoaner, WETH, iETH): print("flashLoaner.address", flashLoaner.address) amount = Wei('500 ether') tx = flashLoaner.doStuffWithFlashLoan(WETH.address, iETH.address, amount) balances = tx.events["BalanceOf"] assert (balances[0]["balance"] == 0) assert (balances[1]["balance"] == amount) assert (balances[2]["balance"] == 0) executeOperation = tx.events['ExecuteOperation'] assert (executeOperation[0]["loanToken"] == WETH.address) assert (executeOperation[0]["iToken"] == iETH.address) assert (executeOperation[0]["loanAmount"] == amount)
def test_tip(ygift, token, giftee, chain): amount = Wei("1000 ether") tip = amount * 2 start = chain[-1].timestamp token.approve(ygift, 2**256 - 1) ygift.mint(giftee, token, amount, "name", "msg", "url", start, 1000) ygift.tip(0, tip, "tip") gift = ygift.gifts(0).dict() assert gift["amount"] == amount assert gift["tipped"] == tip # tips are available instantly chain.sleep(500) chain.mine() assert ygift.collectible(0) >= tip ygift.collect(0, tip, {"from": giftee}) assert token.balanceOf(giftee) == tip
def main(): safe = ApeSafe('0xD089cc83f5B803993E266ACEB929e52A993Ca2C8') agent_address = '0x3e40d73eb977dc6a537af587d48316fee66e9c8c' eth_spent = 0 for cover in unslashed_covers: print("Calc cover for ", cover["policy_name"]) eth_to_cover = cover["damage_eth_covered"] if eth_to_cover == 0: continue um = safe.contract(cover["marketAddress"]) ut = interface.ERC20(cover["premiumToken"]) deposit_delta = um.coverToPremiumTokens( eth_to_cover * 1e18) * um.premiumTokenPrice18eRatio() / 1e18 print("Cover for", eth_to_cover, " ETH") print("ETH required to make deposit: ", deposit_delta / 1e18) premium_balance_before = ut.balanceOf(agent_address) um.depositPremium({'value': deposit_delta}) premium_balance_after = ut.balanceOf(agent_address) print("Premium tokens delta: ", (premium_balance_after - premium_balance_before) / 1e18) print("Premium tokens balance after: ", (premium_balance_after) / 1e18) print("ETH amount", Wei(deposit_delta), deposit_delta / 1e18) eth_spent += deposit_delta print("total ETH to spend", eth_spent / 1e18) safe_tx = safe.multisend_from_receipts() print("safe tx preview:") safe.preview(safe_tx) sys.stdout.write('Are you sure (y/n)? ') if not prompt_bool(): print('Aborting') return safe.post_transaction(safe_tx) print("safe tx sent!")
def test_not_buyable_edition_many(nftbox, minter, accounts): nftbox.createBoxMould(5, Wei('0.01 ether'), [1, 2, 3, 4], [], [], "This is a test box", {'from':minter}) with brownie.reverts("NFTBoxes: Minting too many boxes."): nftbox.buyManyBoxes(1, 6, {'from':accounts[0], "value": Wei("0.01 ether") * 6}) nftbox.buyManyBoxes(1, 3, {'from':accounts[0], "value": Wei("0.01 ether") * 3}) with brownie.reverts("NFTBoxes: Minting too many boxes."): nftbox.buyManyBoxes(1, 6, {'from':accounts[0], "value": Wei("0.01 ether") * 6}) nftbox.buyManyBoxes(1, 2, {'from':accounts[0], "value": Wei("0.01 ether") * 2}) with brownie.reverts("NFTBoxes: Minting too many boxes."): nftbox.buyManyBoxes(1, 1, {'from':accounts[0], "value": Wei("0.01 ether")})
def test_mint(ygift, token, giftee, chain): amount = Wei("1000 ether") start = chain[-1].timestamp + 1000 duration = 1000 token.approve(ygift, 2**256 - 1) ygift.mint(giftee, token, amount, "name", "msg", "url", start, duration) gift = ygift.gifts(0).dict() assert gift == { "token": token, "name": "name", "message": "msg", "url": "url", "amount": amount, "tipped": 0, "start": start, "duration": duration, }
def test_revoke(token_ecrv, strategy_ecrv, vault_ecrv, whale, gov, strategist): debt_ratio = 10_000 vault_ecrv.addStrategy(strategy_ecrv, debt_ratio, 0, 1000, {"from": gov}) token_ecrv.approve(vault_ecrv, 2**256 - 1, {"from": whale}) vault_ecrv.deposit(Wei("100 ether"), {"from": whale}) strategy_ecrv.harvest({"from": strategist}) genericStateOfStrat(strategy_ecrv, token_ecrv, vault_ecrv) genericStateOfVault(vault_ecrv, token_ecrv) vault_ecrv.revokeStrategy(strategy_ecrv, {"from": gov}) strategy_ecrv.harvest({"from": strategist}) genericStateOfStrat(strategy_ecrv, token_ecrv, vault_ecrv) genericStateOfVault(vault_ecrv, token_ecrv)
def test_clone(gov, vault, keeper, strategy, strategist, Strategy): # Do the regular add strategy with the regular one vault.setDepositLimit(Wei("1000000 ether"), {"from": gov}) vault.addStrategy(strategy, 10_000, 0, 2**256 - 1, 1_000, {"from": gov}) # Switch rewards with keeper to make sure the proxy worked tx = strategy.clone(vault, strategist, keeper, strategist) new_strategy = Strategy.at(tx.return_value) # Check that we have the same thing but with keeper/rewards switched assert new_strategy.keeper() != new_strategy.rewards() assert strategy.keeper() == new_strategy.rewards() assert strategy.rewards() == new_strategy.keeper() # Migrate to the new proxied strategy vault.migrateStrategy(strategy, new_strategy, {"from": gov})
def test_harvest(accounts, farming, niftsy20): collateral = farming.getERC20CollateralBalance(1, niftsy20) logging.info('col = {}'.format(collateral)) logging.info('avail = {}'.format(farming.getAvailableRewardAmount(1, niftsy20))) logging.info('rasch = {}'.format(farming.getRewardSettings(niftsy20)[3][1]*farming.getERC20CollateralBalance(1, niftsy20)/10000)) rewards = farming.rewards(1) farming.harvest(1, niftsy20.address, {'from':accounts[0]}) logging.info('getERC20CollateralBalance({},{})={}'.format( 1, niftsy20, Wei(farming.getERC20CollateralBalance(1, niftsy20)).to('ether') )) assert collateral + farming.getRewardSettings(niftsy20)[3][1]*collateral/10000 == farming.getERC20CollateralBalance(1, niftsy20) assert rewards[0] < farming.rewards(1)[0] logging.info('rewwww = {}'.format(farming.rewards(1)[1])) assert farming.rewards(1)[1] == 0
def test_balances(gov, hegic, hegicStaking, vault, strategy): hegic.approve(vault, 2**256 - 1, {"from": gov}) vault.addStrategy(strategy, 10_000, 0, 0, {"from": gov}) # deposit 888001 in total to test vault.deposit(Wei("888001 ether"), {"from": gov}) strategy.harvest() hegicStaking.sendProfit({"value": Wei("1 ether")}) assert strategy.balanceOfWant() == Wei("1 ether") assert strategy.balanceOfStake() == Wei("888000 ether") assert strategy.ethFutureProfit() == Wei("1 ether") assert strategy.hegicFutureProfit() == Wei("3076 ether")
def main(): guest = "0xcB16133a37Ef19F90C570B426292BDcca185BF47" gov = "0x9b5f6921302cc0560fE2eE72E8fcED9D5D26123d" rewards = "0x93A62dA5a14C80f265DAbC077fCEE437B1a0Efde" configurations = json.load(open("configurations.json")) for i, config in enumerate(configurations["vaults"]): print(f"[{i}] {config['name']}") config = configurations["vaults"][int( input("choose configuration to deploy: "))] deployer = accounts.load(input("deployer account: ")) if input("deploy vault? y/n: ") == "y": # gov = get_address("gov") # rewards = get_address("rewards") vault = Vault.deploy( config["want"], gov, rewards, config["name"], config["symbol"], { "from": deployer, "gas_price": Wei("25 gwei") }, ) else: vault = Vault.at(get_address("vault")) strategy = StrategySushiswapPair.deploy(vault, config["pid"], { "from": deployer, "gas_price": Wei("25 gwei") }) deposit_limit = Wei('10 ether') vault.setDepositLimit(deposit_limit, { "from": deployer, "gas_price": Wei("25 gwei") }) vault.addStrategy(strategy, deposit_limit, deposit_limit, 1000, { "from": deployer, "gas_price": Wei("25 gwei") }) gov = "0xFEB4acf3df3cDEA7399794D0869ef76A6EfAff52" vault.setGovernance(gov, {"from": deployer, "gas_price": Wei("25 gwei")}) secho( f"deployed {config['symbol']}\nvault: {vault}\nstrategy: {strategy}\n", fg="green", )