def test_vault_out_of_order_in_approx_out(vault, users, pool, depositAmounts): depositors = users[:4] deposits = {u: [] for u in depositors} for i, u in enumerate(depositors): for d0, d1 in depositAmounts[i]: shares = vault.balanceOf(u) amount0Before = pool.token0.balanceOf(u) amount1Before = pool.token1.balanceOf(u) # deposit to then withdraw in a different order vault.deposit(d0, d1, 0, 0, u, chain.time() + 60, {"from": u}) sharesOut = vault.balanceOf(u) - shares amount0In = amount0Before - pool.token0.balanceOf(u) amount1In = amount1Before - pool.token1.balanceOf(u) deposits[u].append((sharesOut, amount0In, amount1In)) for u in depositors: for d in deposits[u]: shares, amount0In, amount1In = d amount0Before = pool.token0.balanceOf(u) amount1Before = pool.token1.balanceOf(u) vault.withdraw(shares, 0, 0, u, chain.time() + 60, {"from": u}) amount0Out = pool.token0.balanceOf(u) - amount0Before amount1Out = pool.token1.balanceOf(u) - amount1Before # We don't check if out is less than in here, but we make that check above # so it doesn't happen in back-to-back deposit then withdraw # If someone sandwhiches a deposit and squeezes out a wei or two... gg hope you're proud of yourself assert int(amount0Out) == pytest.approx(amount0In, abs=1e3) assert int(amount1Out) == pytest.approx(amount1In, abs=1e3)
def test_eth_vault_withdraw_from(vault, users, pool): a0InBefore = pool.token0.balanceOf(users[1]) a1InBefore = pool.token1.balanceOf(users[1]) sharesBefore = vault.balanceOf(users[1]) vault.deposit(1e18, 1e18, 0, 0, users[0], chain.time() + 60, {"from": users[0]}) vault.deposit(1e18, 1e18, 0, 0, users[1], chain.time() + 60, {"from": users[1]}) a0In = pool.token0.balanceOf(users[1]) - a0InBefore a1In = pool.token1.balanceOf(users[1]) - a1InBefore shares = vault.balanceOf(users[1]) - sharesBefore before0Bal, beforeBal = ( pool.token0.balanceOf(users[2].address), pool.token1.balanceOf(users[2].address), ) vault.approve(users[2], shares, {"from": users[1]}) vault.withdrawFrom(users[1], shares, 0, 0, users[2], chain.time() + 60, {"from": users[2]}) after0Bal, afterBal = ( pool.token0.balanceOf(users[2].address), pool.token1.balanceOf(users[2].address), ) assert int(before0Bal + a0In) == pytest.approx(after0Bal) assert int(beforeBal + a1In) == pytest.approx(afterBal) with reverts("INSUFFICIENT_ALLOWANCE"): vault.withdrawFrom(users[0], shares, 0, 0, users[2], chain.time() + 60, {"from": users[2]})
def test_dutch_auction(FixedToken, auction_factory, dutch_auction_template, fixed_token_template, token_factory): name = "Test Token" symbol = "TTOKEN" token_2 = _create_token(token_factory, fixed_token_template, name, symbol, TOTAL_TOKENS_2, 1, accounts[2], accounts[2]) token_2 = FixedToken.at(token_2) assert token_2.balanceOf(accounts[2]) == TOTAL_TOKENS_2 funder = accounts[2] tokens_to_market = 50000 * TENPOW18 start_time = chain.time() + 50 end_time = chain.time() + 1000 start_price = 0.01 * TENPOW18 minimum_price = 0.001 * TENPOW18 operator = accounts[2] wallet = accounts[2] point_list = ZERO_ADDRESS payment_currency = ETH_ADDRESS data = dutch_auction_template.getAuctionInitData( auction_factory, token_2, tokens_to_market, start_time, end_time, payment_currency, start_price, minimum_price, operator, point_list, wallet) chain.sleep(10) token_2.approve(auction_factory, tokens_to_market, {"from": accounts[2]}) template_id = auction_factory.getTemplateId(dutch_auction_template) tx = auction_factory.createMarket(template_id, token_2, tokens_to_market, accounts[2], data, {'from': accounts[2]}) assert "MarketCreated" in tx.events
def test_eth_vault_withdraw_from(eth_vault, users, eth_pool): aEthBefore = web3.eth.get_balance(users[1]) aInBefore = eth_pool.token.balanceOf(users[1]) sharesBefore = eth_vault.balanceOf(users[1]) eth_vault.depositETH(1e18, 0, 0, users[0], chain.time() + 60, { "from": users[0], "value": 1e18 }) eth_vault.depositETH(1e18, 0, 0, users[1], chain.time() + 60, { "from": users[1], "value": 1e18 }) aEthIn = aEthBefore - web3.eth.get_balance(users[1]) aIn = aInBefore - eth_pool.token.balanceOf(users[1]) shares = eth_vault.balanceOf(users[1]) - sharesBefore beforeEthBal, beforeBal = ( web3.eth.get_balance(users[2].address), eth_pool.token.balanceOf(users[2].address), ) eth_vault.approve(users[2], shares, {"from": users[1]}) eth_vault.withdrawETHFrom(users[1], shares, 0, 0, users[2], chain.time() + 60, {"from": users[2]}) afterEthBal, afterBal = ( web3.eth.get_balance(users[2].address), eth_pool.token.balanceOf(users[2].address), ) assert int(beforeEthBal + aEthIn) == pytest.approx(afterEthBal) assert int(beforeBal + aIn) == pytest.approx(afterBal) with reverts("INSUFFICIENT_ALLOWANCE"): eth_vault.withdrawETHFrom(users[0], shares, 0, 0, users[2], chain.time() + 60, {"from": users[2]})
def test_crowdsale_end_less_than_start(crowdsale_init_helper, mintable_token): mintable_token.mint(accounts[0], AUCTION_TOKENS, {"from": accounts[0]}) assert mintable_token.balanceOf(accounts[0]) == AUCTION_TOKENS start_time = chain.time() + 10 end_time = start_time - 1 wallet = accounts[4] operator = accounts[0] mintable_token.approve(crowdsale_init_helper, AUCTION_TOKENS, {"from": accounts[0]}) with reverts("Crowdsale: start time is not before end time"): crowdsale_init_helper.initCrowdsale(accounts[0], mintable_token, ETH_ADDRESS, CROWDSALE_TOKENS, start_time, end_time, CROWDSALE_RATE, CROWDSALE_GOAL, operator,ZERO_ADDRESS, wallet, {"from": accounts[0]}) end_time = start_time + CROWDSALE_TIME start_time = chain.time() - 10 with reverts("Crowdsale: start time is before current time"): crowdsale_init_helper.initCrowdsale(accounts[0], mintable_token, ETH_ADDRESS, CROWDSALE_TOKENS, start_time, end_time, CROWDSALE_RATE, CROWDSALE_GOAL, operator,ZERO_ADDRESS, wallet, {"from": accounts[0]}) start_time = chain.time() + 10 payment_currency = ZERO_ADDRESS with reverts("Crowdsale: payment currency is the zero address"): crowdsale_init_helper.initCrowdsale(accounts[0], mintable_token, payment_currency, CROWDSALE_TOKENS, start_time, end_time, CROWDSALE_RATE, CROWDSALE_GOAL, operator,ZERO_ADDRESS, wallet, {"from": accounts[0]}) wallet = ZERO_ADDRESS with reverts("Crowdsale: wallet is the zero address"): crowdsale_init_helper.initCrowdsale(accounts[0], mintable_token, ETH_ADDRESS, CROWDSALE_TOKENS, start_time, end_time, CROWDSALE_RATE, CROWDSALE_GOAL, operator,ZERO_ADDRESS, wallet, {"from": accounts[0]}) wallet = accounts[4] operator = ZERO_ADDRESS with reverts("Crowdsale: operator is the zero address"): crowdsale_init_helper.initCrowdsale(accounts[0], mintable_token, ETH_ADDRESS, CROWDSALE_TOKENS, start_time, end_time, CROWDSALE_RATE, CROWDSALE_GOAL, operator,ZERO_ADDRESS, wallet, {"from": accounts[0]})
def test_stateful(state_machine, accounts, ve_token, ve_boardroom, coin_a, coin_b, coin_c, token): for i in range(5): # ensure accounts[:5] all have tokens that may be locked token.approve(ve_token, 2**256 - 1, {"from": accounts[i]}) token.transfer(accounts[i], 10**18 * 10000000, {"from": accounts[0]}) # accounts[0] locks 10,000,000 tokens for 2 years - longer than the maximum duration of the test ve_token.create_lock(10**18 * 10000000, chain.time() + YEAR * 2, {"from": accounts[0]}) # a week later we deploy the fee distributor chain.sleep(WEEK) distributor = ve_boardroom() distributor.add_token(coin_a, chain.time()) distributor.add_token(coin_c, chain.time()) distributor.add_token(coin_b, chain.time()) distributor.delete_token(coin_c) state_machine( StateMachine, distributor, accounts[:5], ve_token, coin_a, coin_b, settings={"stateful_step_count": 30}, )
def rule_increase_unlock_time(self, st_account, st_lock_duration): unlock_time = (chain.time() + st_lock_duration * WEEK) // WEEK * WEEK if self.voting_balances[st_account]["unlock_time"] <= chain.time(): with brownie.reverts("Lock expired"): self.voting_escrow.increase_unlock_time( unlock_time, {"from": st_account, "gas": GAS_LIMIT} ) elif self.voting_balances[st_account]["value"] == 0: with brownie.reverts("Nothing is locked"): self.voting_escrow.increase_unlock_time( unlock_time, {"from": st_account, "gas": GAS_LIMIT} ) elif unlock_time <= self.voting_balances[st_account]["unlock_time"]: with brownie.reverts("Can only increase lock duration"): self.voting_escrow.increase_unlock_time( unlock_time, {"from": st_account, "gas": GAS_LIMIT} ) elif unlock_time > chain.time() + 86400 * 365 * 4: with brownie.reverts("Voting lock can be 4 years max"): self.voting_escrow.increase_unlock_time( unlock_time, {"from": st_account, "gas": GAS_LIMIT} ) else: tx = self.voting_escrow.increase_unlock_time( unlock_time, {"from": st_account, "gas": GAS_LIMIT} ) self.voting_balances[st_account]["unlock_time"] = tx.events["Deposit"]["locktime"]
def rule_create_lock(self, st_account, st_value, st_lock_duration): unlock_time = (chain.time() + st_lock_duration * WEEK) // WEEK * WEEK if st_value == 0: with brownie.reverts("dev: need non-zero value"): self.voting_escrow.create_lock( st_value, unlock_time, {"from": st_account, "gas": GAS_LIMIT} ) elif self.voting_balances[st_account]["value"] > 0: with brownie.reverts("Withdraw old tokens first"): self.voting_escrow.create_lock( st_value, unlock_time, {"from": st_account, "gas": GAS_LIMIT} ) elif unlock_time <= chain.time(): with brownie.reverts("Can only lock until time in the future"): self.voting_escrow.create_lock( st_value, unlock_time, {"from": st_account, "gas": GAS_LIMIT} ) elif unlock_time > chain.time() + 86400 * 365 * 4: with brownie.reverts("Voting lock can be 4 years max"): self.voting_escrow.create_lock( st_value, unlock_time, {"from": st_account, "gas": GAS_LIMIT} ) else: tx = self.voting_escrow.create_lock( st_value, unlock_time, {"from": st_account, "gas": GAS_LIMIT} ) self.voting_balances[st_account] = { "value": st_value, "unlock_time": tx.events["Deposit"]["locktime"], }
def test_stake(accounts, farming, niftsy20, dai): niftsy20.approve(farming, STAKED_AMOUNT, {'from': accounts[0]}) niftsy20.approve(farming, STAKED_AMOUNT, {'from': accounts[1]}) niftsy20.transfer(accounts[1], STAKED_AMOUNT, {'from': accounts[0]}) farming.WrapForFarming(accounts[0], (niftsy20.address, STAKED_AMOUNT), 0, {'from': accounts[0]}) farming.WrapForFarming(accounts[1], (niftsy20.address, STAKED_AMOUNT / 2), chain.time() + 100, {'from': accounts[1]}) assert farming.getAvailableRewardAmount(1, niftsy20) == 0 assert farming.getAvailableRewardAmount(2, niftsy20) == 0 assert farming.balanceOf(accounts[1]) == 1 assert farming.balanceOf(accounts[0]) == 1 assert farming.getWrappedToken(1)[0] == zero_address assert farming.getWrappedToken(1)[1] == 0 assert farming.getWrappedToken(2)[0] == zero_address assert farming.getWrappedToken(2)[1] == 0 assert farming.ownerOf(1) == accounts[0] assert farming.ownerOf(2) == accounts[1] assert farming.getWrappedToken(1)[4] <= chain.time() + 100 assert farming.getWrappedToken(1)[4] == 0 assert farming.getWrappedToken(2)[4] <= chain.time() + 100 assert farming.getWrappedToken(2)[4] > 0 assert niftsy20.balanceOf(farming) == STAKED_AMOUNT + STAKED_AMOUNT / 2 assert farming.getERC20CollateralBalance(1, niftsy20) == STAKED_AMOUNT assert farming.getERC20CollateralBalance(2, niftsy20) == STAKED_AMOUNT / 2 assert farming.rewards(1)[0] <= chain.time() + 100 assert farming.rewards(1)[0] > 0 assert farming.rewards(2)[0] <= chain.time() + 100 assert farming.rewards(2)[0] > 0 assert farming.totalSupply() == 2
def test_frames_crowdsale_setStartDate(frames_crowdsale): tx = frames_crowdsale.setStartDate(chain.time() + 100, {'from': accounts[0]}) assert 'StartDateUpdated' in tx.events with reverts("dev: Not owner"): frames_crowdsale.setStartDate(chain.time() + 100, {'from': accounts[3]})
def test_eth_vault_out_of_order_in_approx_out(eth_vault, users, eth_pool, depositAmounts): depositors = users[:4] deposits = {u: [] for u in depositors} for i, u in enumerate(depositors): for dEth, d in depositAmounts[i]: shares = eth_vault.balanceOf(u) amountEthBefore = web3.eth.get_balance(u.address) amountBefore = eth_pool.token.balanceOf(u) # deposit to then withdraw in a different order eth_vault.depositETH(d, 0, 0, u, chain.time() + 60, { "from": u, "value": dEth }) sharesOut = eth_vault.balanceOf(u) - shares amountEthIn = amountEthBefore - web3.eth.get_balance(u.address) amountIn = amountBefore - eth_pool.token.balanceOf(u) deposits[u].append((sharesOut, amountEthIn, amountIn)) for u in depositors: for d in deposits[u]: shares, amountEthIn, amountIn = d amountEthBefore = web3.eth.get_balance(u.address) amountBefore = eth_pool.token.balanceOf(u) eth_vault.withdrawETH(shares, 0, 0, u, chain.time() + 60, {"from": u}) amountEthOut = web3.eth.get_balance(u.address) - amountEthBefore amountOut = eth_pool.token.balanceOf(u) - amountBefore # We don't check if out is less than in here, but we make that check above # so it doesn't happen in back-to-back deposit then withdraw # If someone sandwhiches a deposit and squeezes out a wei or two... gg hope you're proud of yourself assert int(amountEthOut) == pytest.approx(amountEthIn, abs=1e3) assert int(amountOut) == pytest.approx(amountIn, abs=1e3)
def batch_auction_pay_by_token(BatchAuction, fixed_token_payment_currency, fixed_token_cal): funder = accounts[5] start_time = chain.time() + 10 end_time = start_time + AUCTION_TIME wallet = accounts[1] batch_auction_pay_by_token = BatchAuction.deploy({"from": accounts[0]}) auction_tokens = 100 * TENPOW18 fixed_token_cal.approve(batch_auction_pay_by_token, auction_tokens, {"from": funder}) start_time = chain.time() + 10 end_time = start_time - 10 with reverts("BatchAuction: end time must be older than start price"): batch_auction_pay_by_token.initAuction( funder, fixed_token_cal, auction_tokens, start_time, end_time, fixed_token_payment_currency, AUCTION_MINIMUM_COMMITMENT, accounts[0], ZERO_ADDRESS, wallet, {"from": accounts[0]}) start_time = chain.time() + 10 end_time = start_time + AUCTION_TIME batch_auction_pay_by_token.initAuction( funder, fixed_token_cal, auction_tokens, start_time, end_time, fixed_token_payment_currency, AUCTION_MINIMUM_COMMITMENT, accounts[0], ZERO_ADDRESS, wallet, {"from": accounts[0]}) with reverts("BatchAuction: auction already initialized"): batch_auction_pay_by_token.initAuction( funder, fixed_token_cal, auction_tokens, start_time, end_time, fixed_token_payment_currency, AUCTION_MINIMUM_COMMITMENT, accounts[0], ZERO_ADDRESS, wallet, {"from": accounts[0]}) chain.sleep(10) return batch_auction_pay_by_token
def parent_nft(DigitalaxGenesisNFT, access_controls): fundsMultisig = accounts[1] genesisStartTimestamp = chain.time() + 10 genesisEndTimestamp = chain.time() + 10 + GENESIS_AUCTION_TIME parent_nft = DigitalaxGenesisNFT.deploy(access_controls, fundsMultisig, genesisStartTimestamp, genesisEndTimestamp, GENESIS_TOKEN_URI, {"from": accounts[0]}) return parent_nft
def staked_nft(DigitalaxGenesisNFT, access_controls): fundsMultisig = accounts[1] genesisStartTimestamp = chain.time() + 10 genesisEndTimestamp = chain.time() + 10 + GENESIS_AUCTION_TIME staked_nft = DigitalaxGenesisNFT.deploy(access_controls, fundsMultisig, genesisStartTimestamp, genesisEndTimestamp, GENESIS_TOKEN_URI, {"from": accounts[0]}) chain.sleep(10) # Add some transactions for this instance to test txn = staked_nft.buy({'from': accounts[1], 'value': '1 ethers'}) assert 'GenesisPurchased' in txn.events txn = staked_nft.buyOrIncreaseContribution({ 'from': accounts[1], 'value': '0.5 ethers' }) txn = staked_nft.buyOrIncreaseContribution({ 'from': accounts[2], 'value': '0.1 ethers' }) txn = staked_nft.buyOrIncreaseContribution({ 'from': accounts[3], 'value': '0.2 ethers' }) txn = staked_nft.buyOrIncreaseContribution({ 'from': accounts[4], 'value': '1.1 ethers' }) txn = staked_nft.buyOrIncreaseContribution({ 'from': accounts[5], 'value': '1.1 ethers' }) txn = staked_nft.buyOrIncreaseContribution({ 'from': accounts[6], 'value': '1.7 ethers' }) txn = staked_nft.buyOrIncreaseContribution({ 'from': accounts[7], 'value': '0.1 ethers' }) txn = staked_nft.buyOrIncreaseContribution({ 'from': accounts[8], 'value': '0.3 ethers' }) txn = staked_nft.buyOrIncreaseContribution({ 'from': accounts[9], 'value': '0.5 ethers' }) assert 'GenesisPurchased' in txn.events return staked_nft
def makeWrapNFT(wrapper, erc721mock, fields, values, account, transferFeeContract): START_NATIVE_COLLATERAL_ = '1 ether' ADD_NATIVE_COLLATERAL_ = '2 ether' ERC20_COLLATERAL_AMOUNT_ = 2e17; TRANSFER_FEE_ = 2e18 ROAYLTY_PERCENT_ = 10 UNWRAP_FEE_THRESHOLD_ = 6e18 protokolFee_ = 10 chargeFeeAfter_ = 10 ROYALTYBENEFICIARY_= '0xbd7e5fb7525ed8583893ce1b1f93e21cc0cf02f6' zero_address_ = '0x0000000000000000000000000000000000000000' UNWRAPAFTER_ = chain.time() + 10 #logging.info('TRANSFER_FEE_ from make 1= {}'.format(TRANSFER_FEE_)) #logging.info('make UNWRAPAFTER_ = {}'.format(UNWRAPAFTER_)) UNDERLINECONTRACT_ = erc721mock.address UNWRAPAFTER_ = chain.time() + 10 for i in range(len(fields)): if fields[i] == 'originalTokenId': ORIGINAL_NFT_IDs_ = [] ORIGINAL_NFT_IDs_.append(values[i]) elif fields[i] == 'unwrapAfter': UNWRAPAFTER_ = values[i] elif fields[i] == 'transferFee': TRANSFER_FEE_ = values[i] elif fields[i] == 'royaltyBeneficiary': ROYALTYBENEFICIARY_ = values[i] elif fields[i] == 'royaltyPercent': ROAYLTY_PERCENT_ = values[i] elif fields[i] == 'start_native_collateral': START_NATIVE_COLLATERAL_ = values[i] else: #result UNWRAP_FEE_THRESHOLD_ = values[i] #logging.info('TRANSFER_FEE_ from make 2= {}'.format(TRANSFER_FEE_)) erc721mock.approve(wrapper.address, ORIGINAL_NFT_IDs_[0], {'from':account}) wrapper.wrap721( UNDERLINECONTRACT_, ORIGINAL_NFT_IDs_[0], UNWRAPAFTER_, TRANSFER_FEE_, ROYALTYBENEFICIARY_, ROAYLTY_PERCENT_, UNWRAP_FEE_THRESHOLD_, transferFeeContract.address, {'from':account, 'value':START_NATIVE_COLLATERAL_}) assert erc721mock.ownerOf(ORIGINAL_NFT_IDs_[0]) == wrapper.address assert wrapper.ownerOf(wrapper.lastWrappedNFTId()) == account
def test_market_create_auction_data(DutchAuction, dutch_auction, auction_factory, dutch_auction_template, fixed_token_cal): assert fixed_token_cal.balanceOf(accounts[0]) == AUCTION_TOKENS template_id = auction_factory.getTemplateId(dutch_auction_template) start_date = chain.time() + 10 end_date = start_date + AUCTION_TIME wallet = accounts[1] new_dutch_auction = auction_factory.deployMarket(template_id).return_value chain.sleep(20) fixed_token_cal.approve(new_dutch_auction, AUCTION_TOKENS, {"from": accounts[0]}) new_dutch_auction = DutchAuction.at(new_dutch_auction) _data = new_dutch_auction.getAuctionInitData(accounts[0], fixed_token_cal, AUCTION_TOKENS, start_date, end_date, ETH_ADDRESS, AUCTION_START_PRICE, AUCTION_RESERVE, wallet, {"from": accounts[0]}) new_dutch_auction = auction_factory.createMarket( template_id, _data, new_dutch_auction).return_value new_dutch_auction = DutchAuction.at(new_dutch_auction) assert new_dutch_auction.totalTokensCommitted() == 0 token_buyer = accounts[2] eth_to_transfer = 20 * TENPOW18 tx = new_dutch_auction.commitEth(accounts[0], { "from": accounts[0], "value": eth_to_transfer }) assert "AddedCommitment" in tx.events
def test_hyperbolic_auction_with_abi_data(HyperbolicAuction,fixed_token2): assert fixed_token2.balanceOf(accounts[0]) == AUCTION_TOKENS start_time = chain.time() +10 end_time = start_time + AUCTION_TIME wallet = accounts[1] operator = accounts[0] hyperbolic_auction_init_with_abi = HyperbolicAuction.deploy({"from": accounts[0]}) fixed_token2.approve(hyperbolic_auction_init_with_abi, AUCTION_TOKENS, {"from": accounts[0]}) _data = hyperbolic_auction_init_with_abi.getAuctionInitData( accounts[0], fixed_token2, AUCTION_TOKENS, start_time, end_time, ETH_ADDRESS, HYPERBOLIC_AUCTION_FACTOR, AUCTION_RESERVE, operator, ZERO_ADDRESS, wallet, {"from": accounts[0]} ) hyperbolic_auction_init_with_abi.initMarket(_data) chain.sleep(12) token_buyer = accounts[2] eth_to_transfer = 20 * TENPOW18 tx = hyperbolic_auction_init_with_abi.commitEth(token_buyer, True, {"from": token_buyer, "value":eth_to_transfer}) assert 'AddedCommitment' in tx.events return hyperbolic_auction_init_with_abi
def staking_rewards_mock(DigitalaxRewards, MockStaking, mona_token, access_controls, staking_genesis_mock, staking_nft_mock, staking_lp_mock): start_time = chain.time() staking_rewards_mock = DigitalaxRewards.deploy(mona_token, access_controls, staking_genesis_mock, staking_nft_mock, staking_lp_mock, start_time, start_time, 0, 0, 0, {'from': accounts[0]}) access_controls.addMinterRole(staking_rewards_mock) assert access_controls.hasMinterRole(staking_rewards_mock) == True staking_genesis_mock.setRewardsContract(staking_rewards_mock) staking_nft_mock.setRewardsContract(staking_rewards_mock) staking_lp_mock.setRewardsContract(staking_rewards_mock) weeks = [0, 1, 2, 3, 4, 5] rewards = [ 700 * TENPOW18, 700 * TENPOW18, 500 * TENPOW18, 350 * TENPOW18, 150 * TENPOW18, 100 * TENPOW18 ] staking_rewards_mock.setRewards(weeks, rewards) weeks = [0, 1] rewards = [450 * TENPOW18, 350 * TENPOW18] staking_rewards_mock.bonusRewards(staking_genesis_mock, weeks, rewards) return staking_rewards_mock
def post_deploy_setup(self, deploy=True): """ Distribute digg to Geyser and allow strategy to take """ super().post_deploy_setup(deploy=deploy) if not deploy: return amount = digg_config_test.geyserParams.unlockSchedules.digg[0].amount digg = self.digg.token digg.transfer(self.rewards, amount, {'from': self.deployer}) self.rewards.notifyRewardAmount(chain.time(), days(7), digg.fragmentsToShares(amount), {'from': self.deployer}) print(digg.balanceOf(self.rewards), digg.sharesOf(self.rewards)) self.rewards.grantRole(PAUSER_ROLE, self.keeper, {'from': self.deployer}) self.rewards.grantRole(UNPAUSER_ROLE, self.guardian, {'from': self.deployer}) # Make strategy the recipient of the DIGG faucet self.rewards.initializeRecipient(self.strategy, {"from": self.deployer})
def dutch_auction(DutchSwapAuction, auction_token): startDate = chain.time() +10 endDate = startDate + AUCTION_TIME wallet = accounts[1] funder = accounts[0] dutch_auction = DutchSwapAuction.deploy({'from': accounts[0]}) tx = auction_token.approve(dutch_auction, AUCTION_TOKENS, {'from':funder}) dutch_auction.initDutchAuction(funder, auction_token, AUCTION_TOKENS, startDate, endDate,ETH_ADDRESS, AUCTION_START_PRICE, AUCTION_RESERVE, wallet, {"from": accounts[0]}) assert dutch_auction.clearingPrice( {'from': accounts[0]}) == AUCTION_START_PRICE # Cannot contribute early # with reverts(): # tx = token_buyer.transfer(dutch_auction, eth_to_transfer) # testing pre auction calcs assert dutch_auction.calculateCommitment(0) == 0 assert dutch_auction.calculateCommitment(AUCTION_START_PRICE) == AUCTION_START_PRICE assert dutch_auction.calculateCommitment(AUCTION_START_PRICE*AUCTION_TOKENS / TENPOW18) == AUCTION_START_PRICE*AUCTION_TOKENS / TENPOW18 assert dutch_auction.calculateCommitment(10 * AUCTION_START_PRICE*AUCTION_TOKENS ) == AUCTION_START_PRICE*AUCTION_TOKENS / TENPOW18 # Move the chain to the moment the auction begins chain.sleep(10) return dutch_auction
def staking_rewards(GazeLPStaking, GazeRewards, gaze_coin, lp_token, weth_token, access_control): staking_rewards = GazeLPStaking.deploy({'from': accounts[0]}) staking_rewards.initLPStaking(gaze_coin, lp_token, weth_token, access_control, {"from": accounts[0]}) vault = accounts[1] rewards_contract = GazeRewards.deploy(gaze_coin, access_control, staking_rewards, chain.time() + 10, 0, 0, {'from': accounts[0]}) assert gaze_coin.balanceOf(vault) > 0 gaze_coin.approve(rewards_contract, ONE_MILLION, {"from": vault}) rewards_contract.setVault(vault, {"from": accounts[0]}) staking_rewards.setRewardsContract(rewards_contract, {"from": accounts[0]}) staking_rewards.setTokensClaimable(True, {"from": accounts[0]}) weeks = [0, 1, 2, 3, 4, 5] rewards = [ 70000 * TENPOW18, 60000 * TENPOW18, 50000 * TENPOW18, 50000 * TENPOW18, 45000 * TENPOW18, 42000 * TENPOW18 ] rewards_contract.setRewards(weeks, rewards) chain.sleep(20) chain.mine() return staking_rewards
def test_init_market_from_data(crowdsale_init_helper, mintable_token, fixed_token2): mintable_token.mint(accounts[0], CROWDSALE_TOKENS, {"from": accounts[0]}) assert mintable_token.balanceOf(accounts[0]) == AUCTION_TOKENS funder = accounts[0] start_time = chain.time() + 10 end_time = start_time + CROWDSALE_TIME wallet = accounts[4] operator = accounts[0] mintable_token.approve(crowdsale_init_helper, CROWDSALE_TOKENS, {"from": funder}) _data = crowdsale_init_helper.getCrowdsaleInitData(accounts[0],mintable_token, ETH_ADDRESS, CROWDSALE_TOKENS, start_time, end_time, CROWDSALE_RATE, CROWDSALE_GOAL, operator, ZERO_ADDRESS, wallet, {"from": accounts[0]}) crowdsale_init_helper.initMarket(_data) totalAmountRaised = 0 token_buyer = accounts[1] eth_to_transfer = 5 * TENPOW18 totalAmountRaised += eth_to_transfer chain.sleep(10) tx = crowdsale_init_helper.buyTokensEth(token_buyer, True, {"value": eth_to_transfer, "from": token_buyer}) assert crowdsale_init_helper.operator() == operator assert 'TokensPurchased' in tx.events assert crowdsale_init_helper.marketStatus()[0] == totalAmountRaised assert crowdsale_init_helper.auctionSuccessful() == False
def rule_increase_amount(self, st_account, st_value): if st_value == 0: with brownie.reverts("dev: need non-zero value"): self.voting_escrow.increase_amount(st_value, { 'from': st_account, 'gas': GAS_LIMIT }) elif self.voting_balances[st_account]['value'] == 0: with brownie.reverts("No existing lock found"): self.voting_escrow.increase_amount(st_value, { 'from': st_account, 'gas': GAS_LIMIT }) elif self.voting_balances[st_account]['unlock_time'] <= chain.time(): with brownie.reverts("Cannot add to expired lock. Withdraw"): self.voting_escrow.increase_amount(st_value, { 'from': st_account, 'gas': GAS_LIMIT }) else: self.voting_escrow.increase_amount(st_value, { 'from': st_account, 'gas': GAS_LIMIT }) self.voting_balances[st_account]['value'] += st_value
def crowdsale_2(Crowdsale, mintable_token, fixed_token2): crowdsale = Crowdsale.deploy({"from": accounts[0]}) mintable_token.mint(accounts[0], CROWDSALE_TOKENS_2, {"from": accounts[0]}) assert mintable_token.balanceOf(accounts[0]) == CROWDSALE_TOKENS_2 start_time = chain.time() + 10 end_time = start_time + CROWDSALE_TIME operator = accounts[0] wallet = accounts[4] mintable_token.approve(crowdsale, CROWDSALE_TOKENS_2, {"from": accounts[0]}) crowdsale.initCrowdsale( accounts[0], mintable_token, fixed_token2, CROWDSALE_TOKENS_2, start_time, end_time, CROWDSALE_RATE_2, CROWDSALE_GOAL, operator, ZERO_ADDRESS, wallet, {"from": accounts[0]} ) assert mintable_token.balanceOf(crowdsale) == CROWDSALE_TOKENS_2 chain.sleep(10) return crowdsale
def test_getMarkets(miso_helper, auction_factory, dutch_auction_template, fixed_token_cal): assert fixed_token_cal.balanceOf(accounts[0]) == AUCTION_TOKENS template_id = auction_factory.getTemplateId(dutch_auction_template) minimum_fee = 0.1 * TENPOW18 integrator_fee_percent = 10 ETH_TO_FEE = 1 * TENPOW18 auction_factory.setMinimumFee(minimum_fee, {"from": accounts[0]}) auction_factory.setIntegratorFeePct(integrator_fee_percent, {"from": accounts[0]}) start_date = chain.time() + 20 end_date = start_date + AUCTION_TIME operator = accounts[0] wallet = accounts[1] chain.sleep(10) fixed_token_cal.approve(auction_factory, AUCTION_TOKENS, {"from": accounts[0]}) _data = dutch_auction_template.getAuctionInitData( auction_factory, fixed_token_cal, AUCTION_TOKENS, start_date, end_date, ETH_ADDRESS, AUCTION_START_PRICE, AUCTION_RESERVE, operator, ZERO_ADDRESS, wallet, {"from": accounts[0]}) tx = auction_factory.createMarket(template_id, fixed_token_cal, AUCTION_TOKENS, wallet, _data, { "from": accounts[0], "value": ETH_TO_FEE }) markets = miso_helper.getMarkets() print("markets:", markets)
def post_deploy_setup(self, deploy=True): """ Distribute digg to geyser and allow strategy to take """ super().post_deploy_setup(deploy=deploy) # Track our digg system within badger system for convenience. self.badger.add_existing_digg(self.digg) if not deploy: return digg = self.digg.token # Transfer initial emissions to DiggFaucet amount = digg_config_test.geyserParams.unlockSchedules.digg[0].amount digg.transfer(self.rewards, amount, {"from": self.deployer}) self.rewards.notifyRewardAmount( chain.time(), days(7), digg.fragmentsToShares(amount), {"from": self.deployer}, ) self.rewards.grantRole(PAUSER_ROLE, self.keeper, {"from": self.deployer}) self.rewards.grantRole(UNPAUSER_ROLE, self.guardian, {"from": self.deployer}) # Make strategy the recipient of the DIGG faucet self.rewards.initializeRecipient(self.strategy, {"from": self.deployer}) if self.strategy.paused(): self.strategy.unpause({"from": self.governance})
def test_create_crowdsale_data(Crowdsale, auction_factory, fixed_token_cal, crowdsale_template): assert fixed_token_cal.balanceOf(accounts[0]) == AUCTION_TOKENS start_time = chain.time() + 10 end_time = start_time + CROWDSALE_TIME operator = accounts[0] wallet = accounts[1] template_id = auction_factory.getTemplateId(crowdsale_template) fixed_token_cal.approve(auction_factory, CROWDSALE_TOKENS, {"from": accounts[0]}) _data = crowdsale_template.getCrowdsaleInitData( auction_factory, fixed_token_cal, ETH_ADDRESS, CROWDSALE_TOKENS, start_time, end_time, CROWDSALE_RATE, CROWDSALE_GOAL, operator, ZERO_ADDRESS, wallet, {"from": accounts[0]}) new_crowdsale = auction_factory.createMarket(template_id, fixed_token_cal, CROWDSALE_TOKENS, wallet, _data).return_value new_crowdsale = Crowdsale.at(new_crowdsale) chain.sleep(20) token_buyer = accounts[1] eth_to_transfer = 5 * TENPOW18 tx = new_crowdsale.buyTokensEth(token_buyer, True, { "value": eth_to_transfer, "from": token_buyer }) assert 'TokensPurchased' in tx.events
def test_fails_on_excess_eth_usdc_price_change(interface, whale, steth_token, vault_user, ust_recipient, liquidator, mock_vault, feed_usdc_eth, helpers): router = interface.UniswapV3Router(UNISWAP_ROUTER_V3) factory = interface.UniswapV3Factory(router.factory()) pool = interface.UniswapV3Pool(factory.getPool(USDC_TOKEN, WETH_TOKEN, UNISWAP_USDC_POOL_3_FEE)) feed_price = helpers.get_price(feed_usdc_eth, True) print("chainlink eth->usdc price", feed_price) deadline = chain.time() + 3600 liquidity_amount = 10_000 * 10 ** 18 router.exactInputSingle( ( WETH_TOKEN, USDC_TOKEN, UNISWAP_USDC_POOL_3_FEE, whale, # recipient deadline, # deadline liquidity_amount, # amount_in, 0, # amount_out_min, 0, # sqrtPriceLimitX96 ), {"from": whale, "amount": liquidity_amount}, ) sqrtPriceX96 = pool.slot0()[0] pool_price = (10 ** WETH_DECIMALS) / (10 ** USDC_DECIMALS) * (2 ** 192 / sqrtPriceX96 ** 2) print("pool eth->usdc price", pool_price) assert feed_price * (100 - MAX_ETH_USDC_PRICE_DIFF_PERCENT) / 100 >= pool_price steth_amount = 10 ** 18 steth_token.transfer(liquidator, steth_amount, {"from": vault_user}) with reverts(): liquidator.liquidate(ust_recipient, {"from": mock_vault})
def crowdsale_3(Crowdsale, mintable_token, pool_liquidity): crowdsale = Crowdsale.deploy({"from": accounts[0]}) mintable_token.mint(accounts[0], AUCTION_TOKENS, {"from": accounts[0]}) assert mintable_token.balanceOf(accounts[0]) == AUCTION_TOKENS start_time = chain.time() + 10 end_time = start_time + CROWDSALE_TIME wallet = accounts[4] operator = pool_liquidity mintable_token.approve(crowdsale, AUCTION_TOKENS, {"from": accounts[0]}) crowdsale.initCrowdsale( accounts[0], mintable_token, ETH_ADDRESS, CROWDSALE_TOKENS, start_time, end_time, CROWDSALE_RATE, CROWDSALE_GOAL, operator, ZERO_ADDRESS, wallet, {"from": accounts[0]} ) assert mintable_token.balanceOf(crowdsale) == AUCTION_TOKENS chain.sleep(10) return crowdsale
def test_perf_fee(vault, strategist, pool, user, strat_simp_gwap, keeper, mock_router, delegate, registry): registry.setFeeTo(delegate, {'from': delegate}) strat_simp_gwap.setMaxTickDiff(vault, 2**23 - 2, {"from": strategist}) vault.setPerformanceFee(1000, {'from': strategist}) chain.sleep(300) strat_simp_gwap.rebalance(vault, pool.pool.slot0().dict()["tick"], {"from": keeper}) vault.deposit( 1e30, 1e30, 0, 0, user, chain.time() + 60, {"from": user}, ) lower, upper = vault.mainPosition() lower = int(1.0001**(lower / 2) * (1 << 96)) upper = int(1.0001**(upper / 2) * (1 << 96)) assert vault.balanceOf(delegate) == 0 for _ in range(5): mock_router.swapLimit(pool.pool, True, 1e30, lower, {'from': user}) mock_router.swapLimit(pool.pool, False, 1e30, upper, {'from': user}) strat_simp_gwap.rebalance(vault, pool.pool.slot0().dict()["tick"], {"from": keeper}) assert vault.balanceOf(delegate) > 0