def test_eth_to_usd(Settler, alice, swap, sUSD, sETH, curve_susd, curve_seth, usd_idx): final = MintableForkToken(curve_susd.coins(usd_idx)) tx = swap.swap_into_synth(ETH_ADDRESS, sUSD, alice.balance(), 0, { "from": alice, "value": alice.balance() }) token_id = tx.events["Transfer"][-1]["token_id"] chain.mine(timedelta=600) amount = swap.token_info(token_id)["underlying_balance"] swap.swap_from_synth(token_id, final, amount, 0, {"from": alice}) settler = Settler.at(hex(token_id)) for coin in (sETH, sUSD): assert coin.balanceOf(swap) == 0 assert coin.balanceOf(settler) == 0 assert coin.balanceOf(alice) == 0 assert swap.balance() == 0 assert settler.balance() == 0 assert alice.balance() == 0 assert final.balanceOf(swap) == 0 assert final.balanceOf(settler) == 0 assert final.balanceOf(alice) > 0 assert swap.balanceOf(alice) == 0
def test_eth_to_btc(Settler, alice, swap, sBTC, sETH, curve_sbtc, curve_seth, btc_idx): final = MintableForkToken(curve_sbtc.coins(btc_idx)) tx = swap.swap_into_synth(ETH_ADDRESS, sBTC, alice.balance(), 0, { 'from': alice, 'value': alice.balance() }) token_id = tx.events['Transfer'][-1]['token_id'] chain.mine(timedelta=600) amount = swap.token_info(token_id)['underlying_balance'] swap.swap_from_synth(token_id, final, amount, 0, {'from': alice}) settler = Settler.at(hex(token_id)) for coin in (sETH, sBTC): assert coin.balanceOf(swap) == 0 assert coin.balanceOf(settler) == 0 assert coin.balanceOf(alice) == 0 assert swap.balance() == 0 assert settler.balance() == 0 assert alice.balance() == 0 assert final.balanceOf(swap) == 0 assert final.balanceOf(settler) == 0 assert final.balanceOf(alice) > 0 assert swap.balanceOf(alice) == 0
def test_btc_swaps(alice, bob, swap_btc, factory, coin): # add liquidity wrapped_coins = [coin, MintableForkToken(swap_btc.coins(1))] underlying_coins = [coin] + [ MintableForkToken(i) for i in factory.get_underlying_coins(swap_btc)[1:4] ] amounts = [100 * 10**i.decimals() for i in wrapped_coins] for coin, amount in zip(wrapped_coins, amounts): coin._mint_for_testing(alice, amount) coin.approve(swap_btc, 2**256 - 1, {'from': alice}) swap_btc.add_liquidity(amounts, 0, {'from': alice}) chain.sleep(3600) # perform swaps between each coin for send, recv in itertools.permutations(range(2), 2): amount = 10**wrapped_coins[send].decimals() wrapped_coins[send]._mint_for_testing(bob, amount, {'from': bob}) wrapped_coins[send].approve(swap_btc, amount, {'from': bob}) swap_btc.exchange(send, recv, amount, 0, {'from': bob}) chain.sleep(3600) # perform swaps between each underlying coin for send, recv in itertools.permutations(range(4), 2): amount = 10**underlying_coins[send].decimals() underlying_coins[send]._mint_for_testing(bob, amount, {'from': bob}) underlying_coins[send].approve(swap_btc, amount, {'from': bob}) swap_btc.exchange_underlying(send, recv, amount, 0, {'from': bob}) chain.sleep(3600) # remove liquidity balanced swap_btc.remove_liquidity(10**18, [0, 0], {'from': alice}) chain.sleep(3600) # remove liquidity imbalanced for idx in range(2): amounts = [10**wrapped_coins[i].decimals() for i in range(2)] amounts[idx] = 0 swap_btc.remove_liquidity_imbalance(amounts, 2**256 - 1, {'from': alice}) chain.sleep(3600) for idx in range(2): swap_btc.remove_liquidity_one_coin(10**wrapped_coins[idx].decimals(), idx, 0, {'from': alice}) chain.sleep(3600) before_withdraw = wrapped_coins[1].balanceOf( "0xaa42C0CD9645A58dfeB699cCAeFBD30f19B1ff81") swap_btc.withdraw_admin_fees({'from': alice}) assert wrapped_coins[1].balanceOf( "0xaa42C0CD9645A58dfeB699cCAeFBD30f19B1ff81") > before_withdraw
def test_ethplorer_error(alice, invalid_ethplorer_key): brownie_tokens.forked._token_holders.clear() ethplorer_error = {"code": 1, "message": "Invalid API key"} token = MintableForkToken(token_address_default) with pytest.raises(BrownieTokensError, match=f"Ethplorer returned error: {ethplorer_error}."): token._mint_for_testing(alice, 10**6)
def underlying_coins(coin, is_rebase, rebase_coin): BASE_COINS = [ "0x6B175474E89094C44Da98b954EedeAC495271d0F", # DAI "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", # USDC "0xdAC17F958D2ee523a2206206994597C13D831ec7", # USDT ] if is_rebase: yield [rebase_coin] + [MintableForkToken(i) for i in BASE_COINS] else: yield [coin] + [MintableForkToken(i) for i in BASE_COINS]
def _mint(self, acct, token, amount): token = MintableForkToken(token) amount = int(amount * 10**token.decimals()) if not token.allowance(acct, self.swap): token.approve(self.swap, 2**256 - 1, {"from": acct}) balance = token.balanceOf(acct) if balance < amount: token._mint_for_testing(acct, amount - balance) return amount
def test_btc_to_eth(Settler, alice, bob, swap, sBTC, sETH, curve_sbtc, curve_seth, btc_idx): initial = MintableForkToken(curve_sbtc.coins(btc_idx)) amount = 5 * 10**initial.decimals() initial._mint_for_testing(alice, amount) initial.approve(swap, 2**256 - 1, {'from': alice}) alice.transfer(bob, alice.balance()) tx = swap.swap_into_synth(initial, sETH, amount, 0, {'from': alice}) token_id = tx.events['Transfer'][-1]['token_id'] chain.mine(timedelta=600) amount = swap.token_info(token_id)['underlying_balance'] swap.swap_from_synth(token_id, ETH_ADDRESS, amount, 0, {'from': alice}) settler = Settler.at(hex(token_id)) for coin in (initial, sETH, sBTC): assert coin.balanceOf(swap) == 0 assert coin.balanceOf(settler) == 0 assert coin.balanceOf(alice) == 0 assert swap.balance() == 0 assert settler.balance() == 0 assert alice.balance() > 0 assert swap.balanceOf(alice) == 0
def test_usd_to_eth(Settler, alice, bob, swap, sUSD, sETH, curve_susd, curve_seth, usd_idx): initial = MintableForkToken(curve_susd.coins(usd_idx)) amount = 100_000 * 10**initial.decimals() initial._mint_for_testing(alice, amount) initial.approve(swap, 2**256 - 1, {"from": alice}) alice.transfer(bob, alice.balance()) tx = swap.swap_into_synth(initial, sETH, amount, 0, {"from": alice}) token_id = tx.events["Transfer"][-1]["token_id"] chain.mine(timedelta=600) amount = swap.token_info(token_id)["underlying_balance"] swap.swap_from_synth(token_id, ETH_ADDRESS, amount, 0, {"from": alice}) settler = Settler.at(hex(token_id)) for coin in (initial, sETH, sUSD): assert coin.balanceOf(swap) == 0 assert coin.balanceOf(settler) == 0 assert coin.balanceOf(alice) == 0 assert swap.balance() == 0 assert settler.balance() == 0 assert alice.balance() > 0 assert swap.balanceOf(alice) == 0
def run_arb(amt): tri = Contract("tricrypto") coins = [] for c in range(3): coins.append(MintableForkToken(tri.coins(c))) fqamt = amt * 10 ** coins[0].decimals() coins[0]._mint_for_testing(accounts[0], fqamt) ape_strat_2(coins, 0, 2, accounts[0])
def tripool_funded(registry, alice, tripool): dai_addr = registry.get_coins(tripool)[0] dai = MintableForkToken(dai_addr) amount = 100000 * 10 ** dai.decimals() dai.approve(tripool, amount, {"from": alice}) dai._mint_for_testing(alice, amount) amounts = [amount, 0, 0] tripool.add_liquidity(amounts, 0, {"from": alice}) return tripool
def base_pool(): pool = Contract("0xbEbc44782C7dB0a1A60Cb6fe97d0b483032FF1C7") # ensure the base pool is balanced so our tests are deterministic max_balance = max([pool.balances(0), pool.balances(1) * 10**12, pool.balances(2) * 10**12]) ideal_balances = [max_balance, max_balance // 10**12, max_balance // 10**12] for i, amount in enumerate(ideal_balances): balance = pool.balances(i) if balance < amount: MintableForkToken(pool.coins(i))._mint_for_testing(pool, amount - balance) pool.donate_admin_fees({'from': pool.owner()}) yield pool
def test_zap_gas(DepositZapBTC, alice, bob, swap_btc, factory, coin): zap = DepositZapBTC.deploy({'from': alice}) underlying_coins = [coin] + [ MintableForkToken(i) for i in factory.get_underlying_coins(swap_btc)[1:4] ] amounts = [100 * 10**i.decimals() for i in underlying_coins] for coin, amount in zip(underlying_coins, amounts): coin._mint_for_testing(alice, amount) coin.approve(zap, 2**256 - 1, {'from': alice}) # add liquidity balanced zap.add_liquidity(swap_btc, [i // 2 for i in amounts], 0, {'from': alice}) chain.sleep(3600) # add liquidity imbalanced for idx in range(4): amounts = [10**i.decimals() for i in underlying_coins] amounts[idx] = 0 zap.add_liquidity(swap_btc, amounts, 0, {'from': alice}) chain.sleep(3600) # remove liquidity balanced swap_btc.approve(zap, 2**256 - 1, {'from': alice}) zap.remove_liquidity(swap_btc, 10**18, [0, 0, 0, 0], {'from': alice}) chain.sleep(3600) amounts = [10**i.decimals() for i in underlying_coins] zap.remove_liquidity_imbalance(swap_btc, amounts, swap_btc.balanceOf(alice), {'from': alice}) chain.sleep(3600) # remove liquidity imbalanced for idx in range(4): amounts = [10**i.decimals() for i in underlying_coins] amounts[idx] = 0 zap.remove_liquidity_imbalance(swap_btc, amounts, swap_btc.balanceOf(alice), {'from': alice}) chain.sleep(3600) for idx in range(4): zap.remove_liquidity_one_coin(swap_btc, 10**underlying_coins[idx].decimals(), idx, 0, {'from': alice}) chain.sleep(3600)
def add_tripool_liquidity(): dai_addr = "0x6B175474E89094C44Da98b954EedeAC495271d0F" usdc_addr = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" amount = 100_000 * 10**18 dai = MintableForkToken(dai_addr) dai._mint_for_testing(whale, amount) pool_addr = registry.find_pool_for_coins(dai_addr, usdc_addr) pool = Contract(pool_addr) dai.approve(pool_addr, amount, {'from': whale}) pool.add_liquidity([amount, 0, 0], 0, {'from': whale}) return pool
def check_arb(initial_val=40000): ninja = accounts[0] tri = Contract("tricrypto") coins = [] for c in range(3): coins.append(MintableForkToken(tri.coins(c))) amount = initial_val * 10 ** coins[0].decimals() c1 = 0 c2 = 2 coins[c1]._mint_for_testing(ninja, amount) chain.snapshot() # One Direction _val = ape_strat_1(coins, c1, c2, ninja) print(f"Difference: {_val - initial_val:,.2f}") chain.revert() _val = ape_strat_2(coins, c1, c2, ninja) print(f"Difference: {_val - initial_val:,.2f}") chain.revert()
def main(): dai_addr = "0x6B175474E89094C44Da98b954EedeAC495271d0F" usdc_addr = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" registry_addr = "0x7D86446dDb609eD0F5f8684AcF30380a356b2B4c" amount = 100_000 * 10 ** 18 dai = MintableForkToken(dai_addr) dai._mint_for_testing(accounts[0], amount) registry = Contract(registry_addr) pool_addr = registry.find_pool_for_coins( dai_addr, usdc_addr) pool = Contract(pool_addr) dai.approve(pool_addr, amount, {'from': accounts[0]}) pool.add_liquidity( [amount, 0, 0], 0, {'from': accounts[0]})
def WBTC(): yield MintableForkToken("0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599")
def dai(alice): dai = MintableForkToken("dai") dai._mint_for_testing(alice, 5_000 * 10**dai.decimals()) return dai
def sUSD(): yield MintableForkToken("0x57ab1ec28d129707052df4df418d58a2d46d5f51")
def test_usd_to_btc(Settler, alice, swap, sUSD, sBTC, curve_susd, curve_sbtc, usd_idx, btc_idx): initial = MintableForkToken(curve_susd.coins(usd_idx)) final = MintableForkToken(curve_sbtc.coins(btc_idx)) amount = 1_000_000 * 10**initial.decimals() initial._mint_for_testing(alice, amount) initial.approve(swap, 2**256 - 1, {"from": alice}) tx = swap.swap_into_synth(initial, sBTC, amount, 0, {"from": alice}) token_id = tx.events["Transfer"][-1]["token_id"] chain.mine(timedelta=600) amount = swap.token_info(token_id)["underlying_balance"] swap.swap_from_synth(token_id, final, amount, 0, {"from": alice}) settler = Settler.at(hex(token_id)) for coin in (initial, sBTC, sUSD): assert coin.balanceOf(swap) == 0 assert coin.balanceOf(settler) == 0 assert coin.balanceOf(alice) == 0 assert final.balanceOf(swap) == 0 assert final.balanceOf(settler) == 0 assert final.balanceOf(alice) > 0 assert swap.balanceOf(alice) == 0
def sBTC(): yield MintableForkToken("0xfe18be6b3bd88a2d2a7f928d00292e7a9963cfc6")
def ERC20(address: str) -> MintableForkToken: return MintableForkToken(address)
def sETH(): yield MintableForkToken("0x5e74C9036fb86BD7eCdcb084a0673EFc32eA31cb")
def test_skip_list(alice): token = MintableForkToken(token_address_default) # Fetch top holders token._mint_for_testing(alice, Wei(0)) holders = [_token_holders[token.address][i] for i in [0, 1, 10]] initial_balances = [token.balanceOf(holder) for holder in holders] # Should remove addresses from current lists # ZERO_ADDRESS to check address that is not in _token_holders skip_holders(*holders, ZERO_ADDRESS) token._mint_for_testing(alice, 10**6) for holder, initial_balance in zip(holders, initial_balances): assert token.balanceOf(holder) == initial_balance # Should not include addresses that were set to skip before _token_holders.clear() token._mint_for_testing(alice, 10**6) for holder, initial_balance in zip(holders, initial_balances): assert token.balanceOf(holder) == initial_balance
def weth(): return MintableForkToken('weth')
def tether(): return MintableForkToken('tether')
def base_lp_token(): yield MintableForkToken("0x6c3F90f043a72FA612cbac8115EE7e52BDe6E490")
from brownie import * from brownie_tokens import MintableForkToken tri = Contract("tricrypto") tri_lp = Contract("tricrypto_lp") tri_rewards = Contract("tricrypto_rewards") test_addr = accounts[0] coin_id = 0 coin = MintableForkToken(tri.coins(coin_id)) # Rapidly deposit to Curve TriCrypto to test effect on price def main(): print("\n==Beginning==\n") current_state() nuke() print("\n==After Nuke==\n") current_state() reverse_nuke() print("\n==Reverse the Nuke==\n") current_state() portfolio_state(accounts[0]) # Current state of TriCrypto def current_state(): balances = [] total_balance = 0 print("Current state of TriCrypto")
def usdc(alice, dai): usdc = MintableForkToken("usdc") dai.approve(Contract("3pool"), dai.balanceOf(alice), {"from": alice}) Contract("3pool").exchange(0, 1, dai.balanceOf(alice), 0, {"from": alice}) return usdc
def ERC20(address: str) -> MintableForkToken: return MintableForkToken(Contract.from_explorer(address))
def print_money(addr, amount, alias): coin = MintableForkToken(alias) coin._mint_for_testing(addr, amount * 10**coin.decimals()) return coin