Balancer Reth Eth

amm_strat_report.ipynb

balance_stats.csv

deposit_stats.csv

strategy_harness.py

# Tilt Tester

from world import *
import random

WSTETH_WHALE = "0x176f3dab24a159341c0509bb36b833e7fdd0a132"
WETH_WHALE = "0x8EB8a3b98659Cce290402893d0123abb75E3ab28"
RETH_WHALE = "0x714301eB35fE043FAa547976ce15BcE57BD53144"

class BalancerRethEth:
    def __init__(self):
        strat_address = "0xB262b69d1dB3dc092C73384B8553DA3d00e93682"
        pool_address = "0x1E19CF2D73a72Ef1332C882F20534B6519Be0276"
        self.strat = load_contract("morpho_strat", strat_address)
        self.pool = load_contract("balancer_metastablepool", pool_address)
        self.name = "Balancer Steth-Eth Metastable"
        self.vault_core = oeth_vault_core
        self.vault_admin = oeth_vault_admin
        self.base_size = 8000

        self._balancer_vault = load_contract("balancer_vault", self.pool.getVault())
        self._pool_pid = "0x1e19cf2d73a72ef1332c882f20534b6519be0276000200000000000000000112"
        self._pool_tokens = self.pool_balances().keys()

        reth.approve(self._balancer_vault, 1e70, {'from': RETH_WHALE})
        weth.approve(self._balancer_vault, 1e70, {'from': WETH_WHALE})

    def pool_balances(self):
        balances =  self._balancer_vault.getPoolTokens(self._pool_pid)[0:2] 
        return dict(zip(balances[0], balances[1]))

    def tilt_pool(self, size):
        amount = abs(size) * self.base_size * int(1e18)
        if size == 0:
            pass
        elif size > 0:
            self._balancer_vault.swap((self._pool_pid, 0,  WETH, RETH, amount, ""), (WETH_WHALE, False, WETH_WHALE, False), 1, chain.time()+100, {"from": WETH_WHALE})
        else:
            self._balancer_vault.swap((self._pool_pid, 0, RETH, WETH, amount, ""), (RETH_WHALE, False, RETH_WHALE, False), 1, chain.time()+100, {"from": RETH_WHALE})
            
    def pool_create_mix(self, tilt=0.5, size=1):
        return {
            RETH: int(size * self.base_size * (int(1e18)-(int(1e18) * tilt))),
            WETH: int(size * self.base_size * int(1e18) * tilt),
        }

harness = BalancerRethEth()


# Run setup
harness.vault_admin.withdrawAllFromStrategies({'from':STRATEGIST})


# Test Deposits

deposit_stats = []
for initial_tilt in [0.0, -1, -3,  1, 3]:
    for deposit_x in range (0, 61, 1):
        with TemporaryFork():
            stat = {}

            deposit_mix = deposit_x / 60

            stat['action'] = 'deposit'
            stat['action_mix'] = deposit_mix

            initial_deposit = harness.pool_create_mix(tilt=0.5, size=1.5)
            harness.vault_admin.depositToStrategy(harness.strat, list(initial_deposit.keys()), list(initial_deposit.values()), {'from':STRATEGIST})

            stat['pre_vault'] = harness.vault_core.totalValue()
            pb = list(harness.pool_balances().values())
            stat['pre_pool_0'] = pb[0]
            stat['pre_pool_1'] = pb[1]

            harness.tilt_pool(initial_tilt)


            stat['before_vault'] = harness.vault_core.totalValue()
            pb = list(harness.pool_balances().values())
            stat['before_pool_0'] = pb[0]
            stat['before_pool_1'] = pb[1]
            
            deposit = harness.pool_create_mix(deposit_mix, size=1)
            harness.vault_admin.depositToStrategy(harness.strat, list(deposit.keys()), list(deposit.values()), {'from':STRATEGIST})

            stat['after_vault'] = harness.vault_core.totalValue()
            pb = list(harness.pool_balances().values())
            stat['after_pool_0'] = pb[0]
            stat['after_pool_1'] = pb[1]

            deposit_stats.append(stat)

pd.DataFrame.from_records(deposit_stats).to_csv("deposit_stats.csv")


# Test Balances

balance_stats = []
for initial_tilt in [0.0, -1, -3,  1, 3]:
    for deposit_x in range (0, 21, 1):
        with TemporaryFork():
            stat = {}

            test_tilt = deposit_x / 10 - 1 

            stat['action'] = 'balance'
            stat['action_mix'] = test_tilt

            initial_deposit = harness.pool_create_mix(tilt=0.5, size=1.5)
            harness.vault_admin.depositToStrategy(harness.strat, list(initial_deposit.keys()), list(initial_deposit.values()), {'from':STRATEGIST})

            stat['pre_vault'] = harness.vault_core.totalValue()
            pb = list(harness.pool_balances().values())
            stat['pre_pool_0'] = pb[0]
            stat['pre_pool_1'] = pb[1]

            harness.tilt_pool(initial_tilt)


            stat['before_vault'] = harness.vault_core.totalValue()
            pb = list(harness.pool_balances().values())
            stat['before_pool_0'] = pb[0]
            stat['before_pool_1'] = pb[1]


            harness.tilt_pool(initial_tilt)

            stat['after_vault'] = harness.vault_core.totalValue()
            pb = list(harness.pool_balances().values())
            stat['after_pool_0'] = pb[0]
            stat['after_pool_1'] = pb[1]

            balance_stats.append(stat)

pd.DataFrame.from_records(balance_stats).to_csv("balance_stats.csv")


# Test Withdraws

withdraw_stats = []
for initial_tilt in [0.0, -1, -3,  1, 3]:
    for deposit_x in range (0, 21, 1):
        with TemporaryFork():
            stat = {}

            deposit_mix = deposit_x / 20

            stat['action'] = 'withdraw'
            stat['action_mix'] = deposit_mix

            initial_deposit = harness.pool_create_mix(tilt=0.5, size=1.5)
            harness.vault_admin.depositToStrategy(harness.strat, list(initial_deposit.keys()), list(initial_deposit.values()), {'from':STRATEGIST})

            stat['pre_vault'] = harness.vault_core.totalValue()
            pb = list(harness.pool_balances().values())
            stat['pre_pool_0'] = pb[0]
            stat['pre_pool_1'] = pb[1]

            harness.tilt_pool(initial_tilt)


            stat['before_vault'] = harness.vault_core.totalValue()
            pb = list(harness.pool_balances().values())
            stat['before_pool_0'] = pb[0]
            stat['before_pool_1'] = pb[1]
            
            withdraw = harness.pool_create_mix(deposit_mix, size=0.4)
            harness.vault_admin.withdrawFromStrategy(harness.strat, list(withdraw.keys()), list(withdraw.values()), {'from':STRATEGIST})

            stat['after_vault'] = harness.vault_core.totalValue()
            pb = list(harness.pool_balances().values())
            stat['after_pool_0'] = pb[0]
            stat['after_pool_1'] = pb[1]

            withdraw_stats.append(stat)

pd.DataFrame.from_records(withdraw_stats).to_csv("withdraw_stats.csv")


# Test WithdrawAll

withdrawall_stats = []
for initial_tilt in range (0, 101, 1):
        with TemporaryFork():
            stat = {}

            initial_tilt = (initial_tilt / 100 - 0.5) * 4

            stat['action'] = 'withdrawall'
            stat['action_mix'] = initial_tilt

            initial_deposit = harness.pool_create_mix(tilt=0.5, size=1.5)
            harness.vault_admin.depositToStrategy(harness.strat, list(initial_deposit.keys()), list(initial_deposit.values()), {'from':STRATEGIST})

            stat['pre_vault'] = harness.vault_core.totalValue()
            pb = list(harness.pool_balances().values())
            stat['pre_pool_0'] = pb[0]
            stat['pre_pool_1'] = pb[1]

            harness.tilt_pool(initial_tilt)


            stat['before_vault'] = harness.vault_core.totalValue()
            pb = list(harness.pool_balances().values())
            stat['before_pool_0'] = pb[0]
            stat['before_pool_1'] = pb[1]
            
            harness.vault_admin.withdrawAllFromStrategy(harness.strat, {'from':STRATEGIST})

            stat['after_vault'] = harness.vault_core.totalValue()
            pb = list(harness.pool_balances().values())
            stat['after_pool_0'] = pb[0]
            stat['after_pool_1'] = pb[1]

            withdrawall_stats.append(stat)

pd.DataFrame.from_records(withdrawall_stats).to_csv("withdrawall_stats.csv")

withdraw_stats.csv

withdrawall_stats.csv