
%config InlineBackend.figure_format = 'svg'

import os, sys
sys.path.insert(1, os.path.realpath(os.path.pardir))

from typing import Sequence, Dict

from abm1559.utils import (
    constants,
    basefee_from_csv_history,
    get_basefee_bounds,
    flatten
)
constants["SIMPLE_TRANSACTION_GAS"] = 210000

from abm1559.txpool import TxPool

from abm1559.users import (
    User1559,
    AffineUser,
    User
)

from abm1559.config import rng

from abm1559.txs import Transaction, Tx1559, TxLegacy

from abm1559.userpool import UserPool

from abm1559.chain import (
    Chain,
    Block1559,
    Block
)

from abm1559.simulator import (
    spawn_poisson_heterogeneous_demand,
    update_basefee,
    generate_gbm,
)

import matplotlib.pyplot as plt
import pandas as pd
pd.set_option('display.max_rows', 1000)
import numpy as np
import time
import seaborn as sns
from tqdm import tqdm


def normalize_from_legacy(legacy: TxLegacy) -> Tx1559:
    """
    Normalized according to
    https://github.com/ethereum/EIPs/blob/541c8be92fe759aa602b7d06a088ab1a139e37ce/EIPS/eip-1559.md
    """
    normalized_params = {
        "max_fee": legacy.gas_price(),
        "gas_premium": legacy.gas_price(),
        "start_block": legacy.start_block,
    }
    return Tx1559(
        sender=legacy.sender,
        gas_used=constants["SIMPLE_TRANSACTION_GAS"],
        tx_params=normalized_params
    )


MIN_ACCEPTABLE_TIP = 1 * (10 ** 9)
ORACLE_SLOW = "slow"
ORACLE_MEDIUM = "medium"
ORACLE_FAST = "fast"

class LegacyBidder(AffineUser):
    def __init__(self, wakeup_block, **kwargs):
        super().__init__(wakeup_block, cost_per_unit = 0, **kwargs)
        self.value = (1 + self.rng.pareto(2) * 20) * (10 ** 9)

    def percentile(self):
        raise Exception("Not implemented, try using a subclass.")

    def query_oracle(self, env: dict):
        fee_oracles = env["fee_oracles"]
        return fee_oracles[self.oracle()]

    def decide_parameters(self, env: dict):
        gas_price = self.query_oracle(env)
        
        if self.oracle() == ORACLE_SLOW:
            scaling = 0.5
        elif self.oracle() == ORACLE_MEDIUM:
            scaling = 0.75
        else:
            scaling = 0.9
        
        # We add a normal error scaled by the user type
        gas_price += scaling * self.rng.normal() * (10 ** 9)
        
        return {
            "gas_price": int(max(gas_price, MIN_ACCEPTABLE_TIP)), # in wei
            "start_block": self.wakeup_block,
        }
    
    # This function is the main user entry point 
    def create_transaction(self, env: dict):
        tx_params = self.decide_parameters(env)
        
        # If gas price is higher than 1.2 * my value, I balk
        if tx_params["gas_price"] >= 1.2 * self.value:
            return None
        
        tx_params["gas_price"] = min(self.value, tx_params["gas_price"])
                
        tx = TxLegacy(
            sender = self.pub_key,
            gas_used=constants["SIMPLE_TRANSACTION_GAS"],
            tx_params = tx_params,
        )
        return tx


rng = np.random.default_rng(4)
pd.DataFrame({ "value": rng.pareto(2, 1000) * 20 }).hist(log=True, bins = 100)

array([[<AxesSubplot:title={'center':'value'}>]], dtype=object)


class LegacyBidderSlow(LegacyBidder):
    def oracle(self):
        return ORACLE_SLOW
    
    def export(self):
        return {
            **super().export(),
            "user_type": "user_slow",
        }

class LegacyBidderMedium(LegacyBidder):
    def oracle(self):
        return ORACLE_MEDIUM
    
    def export(self):
        return {
            **super().export(),
            "user_type": "user_medium",
        }

class LegacyBidderFast(LegacyBidder):
    def oracle(self):
        return ORACLE_FAST
    
    def export(self):
        return {
            **super().export(),
            "user_type": "user_fast",
        }


def update_oracles(env: dict, block_target: int) -> None:
    blocks_window = len(env["recent_blocks"])
    fees = flatten([[tx.gas_price({ "basefee": block.basefee }) for tx in block.txs] for block in env["recent_blocks"]])
    fees += [0.0] * (blocks_window * block_target - len(fees))

    env["fee_oracles"] = {
        ORACLE_SLOW: np.percentile(fees, 50) if len(fees) > 0 else 0,
        ORACLE_MEDIUM: np.percentile(fees, 75) if len(fees) > 0 else 0,
        ORACLE_FAST: np.percentile(fees, 90) if len(fees) > 0 else 0
    }


class BiddingBot(AffineUser):
    def __init__(self, wakeup_block, **kwargs):
        super().__init__(wakeup_block, cost_per_unit = 0, **kwargs)
        self.value = (1 + self.rng.pareto(2) * 40) * (10 ** 9)

    def percentile(self):
        raise Exception("Not implemented, try using a subclass.")

    def decide_parameters(self, env: dict):
        oracle_price = env["fee_oracles"][ORACLE_FAST]
        gas_price = oracle_price + self.rng.random() * (self.value - oracle_price)
        return {
            "gas_price": int(gas_price), # in wei
            "start_block": self.wakeup_block,
        }
    
    # This function is the main user entry point 
    def create_transaction(self, env: dict):
        tx_params = self.decide_parameters(env)
                
        expected_payoff = self.value - tx_params["gas_price"]
        if expected_payoff <= 0:
            return None
        
        tx = TxLegacy(
            sender = self.pub_key,
            gas_used=constants["SIMPLE_TRANSACTION_GAS"],
            tx_params = tx_params,
        )
        return tx
    
    def export(self):
        return {
            **super().export(),
            "user_type": "bidding_bot",
        }


MAX_TRANSACTIONS_IN_POOL = 2000

class MixedTxPool(TxPool):
    
    def add_txs(self, txs: Sequence[Transaction], env: dict) -> Sequence[Transaction]:
        for tx in txs:
            if type(tx) is TxLegacy:
                tx = normalize_from_legacy(tx)
            self.txs[tx.tx_hash] = tx
                    
        if self.pool_length() > MAX_TRANSACTIONS_IN_POOL:
            sorted_txs = sorted(self.txs.values(), key = lambda tx: -tx.tip(env))
            self.empty_pool()
            self.add_txs(sorted_txs[0:MAX_TRANSACTIONS_IN_POOL], env)
            return sorted_txs[MAX_TRANSACTIONS_IN_POOL:]
        
        return []
    
    def select_transactions(self, env, user_pool=None, rng=rng) -> Sequence[Transaction]:
        # Miner side
        max_tx_in_block = int(constants["MAX_GAS_EIP1559"] / constants["SIMPLE_TRANSACTION_GAS"])

        valid_txs = [tx for tx in self.txs.values() if tx.is_valid(env) and tx.tip(env) >= MIN_ACCEPTABLE_TIP]
        rng.shuffle(valid_txs)

        sorted_valid_demand = sorted(
            valid_txs,
            key = lambda tx: -tx.tip(env)
        )
        selected_txs = sorted_valid_demand[0:max_tx_in_block]

        return selected_txs


def get_market_price(users: Sequence[User], txs: Sequence[Transaction], env: dict, target: int) -> float:
    values = sorted(
        [user.value for user in users] + [tx.gas_price(env) for tx in txs],
        key = lambda v: -v
    )
    return values[target] if target < len(values) else 0


def simulate(demand_scenario, shares_scenario, extra_metrics = None, rng = rng):
    # Instantiate a couple of things
    txpool = MixedTxPool()
    chain = Chain()
    metrics = []
    user_pool = UserPool()
    blocks_window = 30
    start_time = time.time()
    block_target = int(constants["MAX_GAS_EIP1559"] / constants["SIMPLE_TRANSACTION_GAS"] / 2.0)
    
    # `env` is the "environment" of the simulation
    env = {
        # we start with the historic basefee based on previous txs
        "basefee": constants["INITIAL_BASEFEE"],
        # "basefee": initial_historic_basefee,
        "current_block": None,
        "min_premium": 2 * (10 ** 9),
        "recent_blocks": [],
        "fee_oracles": {
            ORACLE_SLOW: 2 * (10 ** 9),
            ORACLE_MEDIUM: 2 * (10 ** 9),
            ORACLE_FAST: 2 * (10 ** 9)
        }
    }

    for t in tqdm(range(len(demand_scenario))):
        # Sets current block
        env["current_block"] = t
        
        # Reset the random number generator with new seed to generate users with same values across runs
        rng = np.random.default_rng(t)
        
        ### SIMULATION ###

        # We return some demand which on expectation yields `demand_scenario[t]` new users per round
        users = spawn_poisson_heterogeneous_demand(t, demand_scenario[t], shares_scenario[t], rng=rng)
        
        # Record the market price given the current snapshot
        market_price = get_market_price(
            users,
            txpool.txs.values(),
            env,
            block_target
        )

        # Add new users to the pool
        # We query each new user with the current basefee value
        # Users either return a transaction or None if they prefer to balk
        decided_txs = user_pool.decide_transactions(users, env)

        # New transactions are added to the transaction pool
        # `evicted_txs` holds the transactions removed from the pool for lack of space
        evicted_txs = txpool.add_txs(decided_txs, env)

        # The best valid transactions are taken out of the pool for inclusion
        selected_txs = txpool.select_transactions(env)
        txpool.remove_txs([tx.tx_hash for tx in selected_txs])

        # We create a block with these transactions
        block = Block1559(
            txs = selected_txs, parent_hash = chain.current_head,
            height = t, basefee = env["basefee"]
        )
        env["recent_blocks"] = env["recent_blocks"][-(blocks_window-1):] + [block]
        
        # Record the min premium in the block
        env["min_premium"] = block.min_premium()
        
        # The block is added to the chain
        chain.add_block(block)
        
        ### METRICS ###
                
        row_metrics = {
            "block": t,
            "users": len(users),
            "decided_txs": len(decided_txs),
            "included_txs": len(selected_txs),
            "basefee": env["basefee"] / (10 ** 9), # to Gwei
            "slow_oracle": env["fee_oracles"][ORACLE_SLOW] / (10 ** 9), # to Gwei
            "medium_oracle": env["fee_oracles"][ORACLE_MEDIUM] / (10 ** 9), # to Gwei
            "fast_oracle": env["fee_oracles"][ORACLE_FAST] / (10 ** 9), # to Gwei
            "market_price": market_price  / (10 ** 9), # to Gwei
            "blk_min_premium": block.min_premium() / (10 ** 9), # to Gwei
            "blk_max_premium": block.max_premium() / (10 ** 9), # to Gwei
            "blk_min_tip": block.min_tip(env) / (10 ** 9), # to Gwei
            "blk_max_tip": block.max_tip(env) / (10 ** 9), # to Gwei
        }
        
        if not extra_metrics is None:
            row_metrics = {
                **row_metrics,
                **extra_metrics(env, users, user_pool, txpool),
            }
        
        metrics.append(row_metrics)

        ### ORACLES ###
        
        update_oracles(env, block_target)
        
        # Finally, basefee is updated and a new round starts
        env["basefee"] = update_basefee(block, env["basefee"])

    return (pd.DataFrame(metrics), user_pool, chain)


blocks = 6000

rng = np.random.default_rng(4)
sigma = 0.05
mu = 0.5 * sigma**2
gbm = list(generate_gbm(200, blocks, paths=1, mu=mu, sigma=sigma, rng=rng).flatten())

# Plot demand
f, ax = plt.subplots()
plt.title('Demand size over time', color='black')
plt.plot(range(blocks), gbm)
ax.set_xlabel("Block height")
ax.set_ylabel("Number of new users")
plt.show()


def extra_metrics_fpa(env, users, user_pool, txpool):
    pool_legacy_users = len(
        [tx for tx in txpool.txs.values() if isinstance(user_pool.users[tx.sender], LegacyBidder)])

    return {
        "legacy": len([user for user in users if isinstance(user, LegacyBidder)]),
        "pool_legacy": pool_legacy_users
    }

# Number of new users per time step
demand_scenario = [gbm[t] for t in range(6000)]

# Shares of new users per time step
shares_scenario_fpa = [{
    LegacyBidderSlow: 0.50,
    LegacyBidderMedium: 0.30,
    LegacyBidderFast: 0.15,
    BiddingBot: 0.05,
} for t in range(blocks)]


(df, user_pool, chain) = simulate(demand_scenario, shares_scenario_fpa, extra_metrics_fpa)

100%|██████████| 6000/6000 [06:47<00:00, 14.73it/s]


ax = df.plot("block", ["basefee", "market_price", "slow_oracle", "medium_oracle", "fast_oracle"])
ax.set_xlabel("Block height")
ax.set_ylabel("Gas price (Gwei)")

Text(0, 0.5, 'Gas price (Gwei)')


ax = df[(df.block >= 400) & (df.block < 1750)].plot("block", ["basefee", "market_price", "slow_oracle", "medium_oracle", "fast_oracle"])
ax.set_xlabel("Block height")
ax.set_ylabel("Gas price (Gwei)")

Text(0, 0.5, 'Gas price (Gwei)')


ax = df[(df.block >= 400) & (df.block < 1750)].plot("block", ["pool_legacy"])
ax.set_xlabel("Block height")
ax.set_ylabel("Users in pool")

Text(0, 0.5, 'Users in pool')


ax = df[(df.block >= 4500) & (df.block < 5500)].plot(
    "block", ["basefee", "market_price", "slow_oracle", "medium_oracle", "fast_oracle"]
)
ax.set_xlabel("Block height")
ax.set_ylabel("Gas price (Gwei)")

Text(0, 0.5, 'Gas price (Gwei)')


# Obtain the pool of users (all users spawned by the simulation)
user_pool_df = user_pool.export().rename(columns={ "pub_key": "sender" })

# Export the trace of the chain, all transactions included in blocks
chain_df = chain.export()

# Join the two to associate transactions with their senders
user_txs_df = chain_df.join(user_pool_df.set_index("sender"), on="sender")


txs_per_user_type = user_txs_df.groupby(
    ["block_height", "user_type"]
).agg(
    { "user_type": len }
).unstack(level=-1).reset_index()
txs_per_user_type["user_type"] = txs_per_user_type["user_type"].fillna(0)
txs_per_user_type.columns = [
    "block_height", "bidding_bot", "user_fast", "user_medium", "user_slow"
]
txs_per_user_type["total"] = txs_per_user_type.apply(
    lambda row: row.bidding_bot + row.user_fast + row.user_medium + row.user_slow,
    axis = 1
)
txs_per_user_type["percentage_bots"] = txs_per_user_type.apply(
    lambda row: row.bidding_bot / row.total * 100,
    axis = 1
)
txs_per_user_type["fast_oracle"] = df["fast_oracle"]
txs_per_user_type["medium_oracle"] = df["medium_oracle"]
txs_per_user_type["oracle_diff"] = txs_per_user_type["fast_oracle"] - txs_per_user_type["medium_oracle"]
ax = txs_per_user_type.iloc[range(4800, 5420)].plot("block_height", ["oracle_diff", "percentage_bots"])
ax.set_xlabel("Block height")
ax.set_ylabel("Gas price difference (Gwei) / Percentage of bots")

Text(0, 0.5, 'Gas price difference (Gwei) / Percentage of bots')


class OptimisticUser(User1559):
    def __init__(self, wakeup_block, **kwargs):
        super().__init__(wakeup_block, cost_per_unit = 0, **kwargs)
        self.value = (1 + self.rng.pareto(2) * 20) * (10 ** 9)
        
    def create_transaction(self, env):
        tx = super().create_transaction(env)
        if not tx is None:
            tx.gas_used = constants["SIMPLE_TRANSACTION_GAS"]
        return tx

class StrategicUser(User1559):
    """
    A strategic affine user sending 1559 transactions.

    - Expects to be included in the next block
    - Prefers not to participate if its expected payoff is negative
    - Strategic gas_premium
    """

    epsilon = 0.1 # how much the user overbids by

    def __init__(self, wakeup_block, **kwargs):
        super().__init__(wakeup_block, cost_per_unit = 0, **kwargs)
        self.value = (1 + self.rng.pareto(2) * 20) * (10 ** 9)

    def decide_parameters(self, env):
        if env["min_premium"] is None:
            min_premium = 1 * (10 ** 9)
        else:
            min_premium = env["min_premium"]

        gas_premium = min_premium + self.epsilon * (10 ** 9)
        max_fee = self.value

        return {
            "max_fee": max_fee, # in wei
            "gas_premium": gas_premium, # in wei
            "start_block": self.wakeup_block
        }
    
    def create_transaction(self, env):
        tx = super().create_transaction(env)
        if not tx is None:
            tx.gas_used = constants["SIMPLE_TRANSACTION_GAS"]
        return tx

    def export(self):
        return {
            **super().export(),
            "user_type": "strategic_user_1559",
        }

    def __str__(self):
        return f"1559 strategic affine user with value {self.value} and cost {self.cost_per_unit}"


def extra_metrics_1559(env, users, user_pool, txpool):
    pool_strat_users = len(
            [tx for tx in txpool.txs.values() if type(user_pool.users[tx.sender]) is StrategicUser])
    pool_nonstrat_users = len(
            [tx for tx in txpool.txs.values() if type(user_pool.users[tx.sender]) is OptimisticUser])
    return {
        "strategic": len([user for user in users if type(user) is StrategicUser]),
        "nonstategic": len([user for user in users if type(user) is OptimisticUser]),
        "pool_strategic": pool_strat_users,
        "pool_nonstrat": pool_nonstrat_users,
    }

# Number of new users per time step
demand_scenario = [gbm[t] for t in range(6000)]

# Shares of new users per time step
shares_scenario_1559 = [{
    StrategicUser: 0.50,
    OptimisticUser: 0.50,
} for t in range(blocks)]


(df_1559, user_pool_1559, chain_1559) = simulate(demand_scenario, shares_scenario_1559, extra_metrics_1559)

100%|██████████| 6000/6000 [14:10<00:00,  7.06it/s]


ax = df_1559.plot("block", ["basefee", "market_price", "slow_oracle", "medium_oracle", "fast_oracle"])
ax.set_xlabel("Block height")
ax.set_ylabel("Gas price (Gwei)")

Text(0, 0.5, 'Gas price (Gwei)')


ax = df_1559[(df_1559.block >= 400) & (df_1559.block < 1800)].plot("block", ["basefee", "market_price", "slow_oracle", "medium_oracle", "fast_oracle"])
ax.set_xlabel("Block height")
ax.set_ylabel("Gas price (Gwei)")

Text(0, 0.5, 'Gas price (Gwei)')


rmse_1559 = np.linalg.norm(df_1559["fast_oracle"] - df_1559["market_price"])
rmse_fpa = np.linalg.norm(df["fast_oracle"] - df["market_price"])
mbe_1559 = np.mean(df_1559["fast_oracle"] - df_1559["market_price"])
mbe_fpa = np.mean(df["fast_oracle"] - df["market_price"])

pd.DataFrame({
    "Scenario": ["All legacy users", "All 1559 users"],
    "RMSE": [rmse_fpa, rmse_1559],
    "MBE": [mbe_fpa, mbe_1559]
})


def extra_metrics_mixed(env, users, user_pool, txpool):
    return {
        **extra_metrics_fpa(env, users, user_pool, txpool),
        **extra_metrics_1559(env, users, user_pool, txpool),
    }

# Number of new users per time step
demand_scenario = [gbm[t] for t in range(6000)]

share_1559 = 0.5

# Shares of new users per time step
shares_scenario_mixed = [{
    **{ key: (1-share_1559) * share for key, share in shares_scenario_fpa[0].items() },
    **{ key: share_1559 * share for key, share in shares_scenario_1559[0].items() },
} for t in range(blocks)]


(df_mixed, user_pool_mixed, chain_mixed) = simulate(demand_scenario, shares_scenario_mixed, extra_metrics_mixed)

100%|██████████| 6000/6000 [10:59<00:00,  9.09it/s]


ax = df_mixed.plot("block", ["basefee", "market_price", "slow_oracle", "medium_oracle", "fast_oracle"])
ax.set_xlabel("Block height")
ax.set_ylabel("Gas price (Gwei)")

Text(0, 0.5, 'Gas price (Gwei)')


rmse_mixed = np.linalg.norm(df_mixed["fast_oracle"] - df_mixed["market_price"])
mbe_mixed = np.mean(df_mixed["fast_oracle"] - df_mixed["market_price"])

pd.DataFrame({
    "Scenario": ["All legacy users", "Legacy and 1559 users", "All 1559 users"],
    "RMSE": [rmse_fpa, rmse_mixed, rmse_1559],
    "MBE": [mbe_fpa, mbe_mixed, mbe_1559]
})


# Obtain the pool of users (all users spawned by the simulation)
user_pool_mixed_df = user_pool_mixed.export().rename(columns={ "pub_key": "sender" })

# Export the trace of the chain, all transactions included in blocks
chain_mixed_df = chain_mixed.export()

# Join the two to associate transactions with their senders
user_txs_mixed_df = chain_mixed_df.join(user_pool_mixed_df.set_index("sender"), on="sender")


user_txs_mixed_df["gas_price"] = user_txs_mixed_df.apply(
    lambda row: row.tx.gas_price({ "basefee": row.basefee * (10 ** 9) }) / (10 ** 9),
    axis=1
)
user_txs_mixed_df["waiting_time"] = user_txs_mixed_df["block_height"] - user_txs_mixed_df["wakeup_block"]


counts_df = user_txs_mixed_df[["block_height", "user_type", "basefee"]].groupby(
    ["block_height", "user_type"]
).count().unstack().fillna(0)
counts_df["total"] = sum([counts_df.iloc[:,i] for i in range(6)])
for i in range(6):
    counts_df.iloc[:,i] = counts_df.iloc[:,i] / counts_df["total"] * 100
expected_percent = [2.5, 25, 25, 7.5, 15, 25]
for i in range(6):
    counts_df.iloc[:,i] = counts_df.iloc[:,i] - expected_percent[i]
    
f = plt.figure()
plt.title('Inclusion difference relative to expectation', color='black')
counts_df.iloc[:,0:6].rolling(window=200).mean().plot(ax=f.gca())
plt.legend(loc='center left', bbox_to_anchor=(1, 0.5))
plt.show()


f = plt.figure()

plt.title('Gas price per spawned group', color='black')
user_txs_mixed_df[
    (user_txs_mixed_df.wakeup_block <= 1000)
][["wakeup_block", "user_type", "gas_price"]].groupby(
    ["wakeup_block", "user_type"]
).mean().unstack().fillna(0).rolling(window=100).mean().plot(ax=f.gca())
plt.legend(loc='center left', bbox_to_anchor=(1, 0.5))
plt.show()


f = plt.figure()

plt.title('Waiting time per wave', color='black')
user_txs_mixed_df[
    (user_txs_mixed_df.wakeup_block <= 1000)
][["wakeup_block", "user_type", "waiting_time"]].groupby(
    ["wakeup_block", "user_type"]
).mean().unstack().fillna(0).rolling(window=100).mean().plot(ax=f.gca())
plt.legend(loc='center left', bbox_to_anchor=(1, 0.5))
plt.show()


# Number of new users per time step
demand_scenario = [gbm[t] for t in range(6000)]
rmses = []

for share_1559 in np.arange(0, 1, 0.1):
    # Shares of new users per time step
    shares_scenario_mixed = [{
        **{ key: (1-share_1559) * share for key, share in shares_scenario_fpa[0].items() },
        **{ key: share_1559 * share for key, share in shares_scenario_1559[0].items() },
    } for t in range(blocks)]

    (df_mixed, user_pool_mixed, chain_mixed) = simulate(demand_scenario, shares_scenario_mixed)
    
    rmse_mixed = np.linalg.norm(df_mixed["fast_oracle"] - df_mixed["market_price"])
    rmses += [rmse_mixed]

100%|██████████| 6000/6000 [34:36<00:00,  2.89it/s]    
100%|██████████| 6000/6000 [27:20<00:00,  3.66it/s]    
100%|██████████| 6000/6000 [27:26<00:00,  3.65it/s]    
100%|██████████| 6000/6000 [27:51<00:00,  3.59it/s]    
100%|██████████| 6000/6000 [21:18<00:00,  4.69it/s]    
100%|██████████| 6000/6000 [19:29<00:00,  5.13it/s]   
100%|██████████| 6000/6000 [22:44<00:00,  4.40it/s]   
100%|██████████| 6000/6000 [09:56<00:00, 10.06it/s] 
100%|██████████| 6000/6000 [18:12<00:00,  5.49it/s]    
100%|██████████| 6000/6000 [18:24<00:00,  5.43it/s]


pd.DataFrame({
    "share_1559": np.arange(0, 1, 0.1),
    "rmse": rmses
}).plot("share_1559", "rmse")

<AxesSubplot:xlabel='share_1559'>

User	Share
(1559) Optimistic	25%
(1559) Strategic	25%
(FPA) Slow oracle follower	25%
(FPA) Medium oracle follower	15%
(FPA) Fast oracle follower	7.5%
(FPA) Bidding bot	2.5%

TL;DR¶

Simulation components¶

Legacy tooling for EIP 1559 environment¶

Legacy users¶

Price oracles¶

Bidding bots¶

Transaction and user pools¶

The market price¶

The main simulation loop¶

Boundary cases: all legacy and all 1559 users¶

Generating the demand¶

Scenario 1: All legacy users¶

Atrocity exhibition I: Sticky oracles¶

Atrocity exhibition II: Bubbly oracles¶

Scenario 2: All 1559 users¶

Final boss: Legacy and 1559 users¶

Inclusion statistics for user types¶

(Bonus) How much improvement do 1559 users bring?¶

	Scenario	RMSE	MBE
0	All legacy users	2809.718728	20.846171
1	All 1559 users	1321.795814	3.982462