Appendix A Simulation Code Example
The following is the code written in Python to generate the simulations used in the document above.
Simulated Transactions Per Second (TPS) Over 24 Hours
```python
import numpy as np
import matplotlib . pyplot as plt
base_tps_phronzero = 100000
base_tps_phronlayer1 = 50000
time_hours = np. arange (0, 24, 1)
network_load_factor_phronzero = 0.5 * np. sin (np .pi * time_hours / 12 - np.pi /2) + 1
network_load_factor_phronlayer1 = 0.5 * np.sin(np .pi * time_hours / 12 - np .pi /2) + 1.5
effective_tps_phronzero = base_tps_phronzero * network_load_factor_phronzero
effective_tps_phronlayer1 = base_tps_phronlayer1 * network_load_factor_phronlayer1
plt.figure ( figsize =(14 , 7))
plt.plot ( time_hours , effective_tps_phronzero , label ='PhronZero TPS', marker ='o')
plt.plot ( time_hours , effective_tps_phronlayer1 , label ='Phron Layer 1 TPS', marker ='x')
plt.title ('Simulated Transactions Per Second ( TPS) Over 24 Hours ')
plt.xlabel ('Time ( Hours )')
plt.ylabel (' Transactions Per Second ( TPS )')
plt.legend ()
plt.grid ( True )
plt.xticks ( time_hours )
plt.ylim (0, max ( effective_tps_phronzero ) + 50000)
plt.show ()
# \ end { verbatim *}
# \ subsection { Simulated Dynamic Gas Fee }
# \ begin { verbatim *}
def calculate_dynamic_gas_fee ( base_fee , tip , epsilon , p_target , p_current , delta_c ,
delta_n ):
"""
Calculate the dynamic gas fee for a transaction based on the provided parameters .
: param base_fee : Base fee of the transaction
: param tip : Optional tip to miners / validators
: param epsilon : Sensitivity parameter for token price stabilization
: param p_target : Target token price
: param p_current : Current token price
: param delta_c : Rate of change in transaction complexity
: param delta_n : Rate of change in network congestion
: return : Calculated dynamic gas fee
"""
price_adjustment = epsilon * ( p_target - p_current ) / p_current
gas_fee = ( base_fee + tip + price_adjustment ) * ( delta_c + delta_n )
return gas_fee
base_fee = 10
tip = 1
epsilon = 0.1
p_target = 1
p_current = 0.65
delta_c = 1
delta_n = 1
```Gas Fees for Storage Biased L1 with Secondary dApp Support
```python
# Simulate dynamic gas fees over time for a single dApp type
time = np. arange(0, 10, 0.1)
gas_fees = [calculate_dynamic_gas_fee ( base_fee , tip , epsilon , p_target , p_current + t, delta_c , delta_n ) for t in time]
plt.figure( figsize =(10 , 6))
plt.plot(time , gas_fees , label ='Dynamic Gas Fee Over Time')
plt.title('Simulated Dynamic Gas Fee')
plt.xlabel('Time')
plt.ylabel('Gas Fee')
plt.legend()
plt.grid(True)
plt.show()
```Simulated Gas Fees
```python
import numpy as np
import matplotlib . pyplot as plt
# Setup
t = np. linspace (0, 2 * np.pi , 400)
BaseRate = 10
StorageRate = 0.05
N = 0.5 * np. sin (t) + 1.5 # Network congestion
# Parameters for complexity (C)
A, B, V, M, S = 1.5 , 1, 2, 1.5 , 0.8
omega , eta , kappa , alpha , R,T= 2, 0.05 , 1, 0.1 , 5, 50
i = np. arange (1, int (np. max (t) / T) + 1) * T
# Gaming dApp
C_gaming = A * np.sin( omega * t) + B
D_gaming = np. zeros_like (t)
G_gaming = BaseRate * (1 + C_gaming + N) + StorageRate * D_gaming
# DEX
C_dex = V * np. log (1 + eta * t) + M * np. sin ( kappa * t)
D_dex = np. zeros_like (t)
G_dex = BaseRate * (1 + C_dex + N) + StorageRate * D_dex
# Storage dApp
C_storage = np. full_like (t, S)
D_storage = R * np.sum ([ np. exp(- alpha * (t - iT) **2) for iT in i], axis =0)
G_storage = BaseRate * (1 + C_storage + N) + StorageRate * D_storage
# Plotting
plt.figure( figsize =(12 , 8))
plt.plot(t, G_gaming , label ='Gaming dApp')
plt.plot(t, G_dex , label ='DEX')
plt.plot(t, G_storage , label ='Storage dApp', linestyle ='--')
plt.title('Simulated Gas Fees')
plt.xlabel('Time (in cycles )')
plt.ylabel('Gas Fee (in gui unit )')
plt.legend()
plt.grid(True)
plt.show()
```Gas Fees for Storage Biased L1 with Secondary dApp Support
```python
import numpy as np
import matplotlib.pyplot as plt
# Setup
t = np. linspace (0, 2 * np.pi , 400)
BaseRate = 10
N = 0.5 * np. sin (t) + 1.5 # Simulated network congestion
C_gaming_primary = 1.5 * np. sin (2 * np .pi * t / max(t))
C_dex_secondary = 0.3 * np. sin (4 * np .pi * t / max(t)) # Reduced influence
C_storage_secondary = 0.2 * np. sin (4 * np .pi * t / max (t)) # Reduced influence
G_gaming = BaseRate * (1 + C_gaming_primary + N)
G_dex = BaseRate * (1 + C_dex_secondary + N)
G_storage = BaseRate * (1 + C_storage_secondary + N)
plt.figure ( figsize =(12 , 8))
plt.plot (t, G_gaming , label ='Gaming dApp - Primary ', color ='blue')
plt.plot (t, G_dex , label ='DEX dApp - Secondary ', color ='orange', linestyle ='--')
plt.plot (t, G_storage , label ='Storage dApp - Secondary ', color ='green', linestyle =':')
plt.title ('Gas Fees for Gaming Biased L1 with Secondary dApp Support ')
plt.xlabel ('Time (in cycles )')
plt.ylabel ('Gas Fee (in gwei )')
plt.legend ()
plt.grid ( True )
plt.show ()
plt.figure ( figsize =(12 , 8))
G_dex_primary = BaseRate * (1 + 2.0 * (np. sin (4 * np .pi * t / max (t)) **2) + N)
G_gaming_supportive = BaseRate * (1 + 0.3 * np.sin (2 * np .pi * t / max (t)) + N)
# Increased presence from Gaming
G_storage_supportive = BaseRate * (1 + 0.2 * np.sin (4 * np .pi * t / max (t)) + N)
plt.plot (t, G_dex_primary , label ='DEX dApp - Primary', color ='orange')
plt.plot (t, G_gaming_supportive , label ='Gaming dApp - Supportive', color ='blue',linestyle ='--')
plt.plot (t, G_storage_supportive , label ='Storage dApp - Supportive', color ='green',
linestyle =':')
plt.title ('Gas Fees for DEX Biased L1 with Secondary dApp Support')
plt.xlabel ('Time (in cycles )')
plt.ylabel ('Gas Fee (in gwei )')
plt.legend ()
plt.grid ( True )
plt.show ()
plt.figure ( figsize =(12 , 8))
G_storage_primary = BaseRate * (1 + 0.8 * np. sum ([ np.exp ( -0.1 * (t - iT) **2) for iT in np. arange (1, int (np. max (t) / 50) + 1) * 50] , axis =0) + N)
G_gaming_supportive = BaseRate * (1 + 0.3 * np.sin (2 * np .pi * t / max (t)) + N)
# Slightly increased presence from Gaming
G_dex_supportive = BaseRate * (1 + 0.2 * np. sin (4 * np .pi * t / max (t)) + N)
plt.plot (t, G_storage_primary , label ='Storage dApp - Primary', color ='green')
plt.plot (t, G_gaming_supportive , label ='Gaming dApp - Supportive', color ='blue', linestyle ='--')
plt.plot (t, G_dex_supportive , label ='DEX dApp - Supportive', color ='orange', linestyle =':')
plt.title ('Gas Fees for Storage Biased L1 with Secondary dApp Support')
plt.xlabel ('Time (in cycles )')
plt.ylabel ('Gas Fee (in gwei )')
plt.legend ()
plt.grid ( True )
plt.show ()
```Transaction Throughput for Layer 1 Projects and Total Usage on Layer 0 Network
```python
import numpy as np
import matplotlib.pyplot as plt
# Simulation parameters
SIMULATION_DURATION = 100 # Total time for simulation in seconds
LAYER_0_TPS = 31000 # Layer 0's maximum tps
NUM_PROJECTS = 3 # Number of Layer 1 projects
# Assume an even distribution of Layer 0's TPS across Layer 1 projects
tps_distribution = LAYER_0_TPS / NUM_PROJECTS
# Simulating transaction throughput for each Layer 1 project over time
time_steps = np. linspace (0, SIMULATION_DURATION , SIMULATION_DURATION )
throughput_data = {}
# Total throughput at each time step
total_throughput = np. zeros ( SIMULATION_DURATION )
# Create throughput data for each project and calculate total throughput
for i in range ( NUM_PROJECTS ):
# Randomly vary the tps for each project to simulate fluctuating network conditions
tps_variation = np. random.normal (0, 1000 , SIMULATION_DURATION )
throughput_data [f'Project {i +1}'] = tps_distribution + tps_variation
total_throughput += throughput_data [f'Project {i +1}']
# Plotting the multi - line chart for individual projects
plt.figure ( figsize =(14 , 7))
for project , tps in throughput_data.items ():
plt.plot ( time_steps , tps , label = project )
# Adding the total usage curve
plt.plot ( time_steps , total_throughput , label ='Total Usage', color ='black', linewidth =2, linestyle ='--')
# Chart configurations
plt.title (' Transaction Throughput for Layer 1 Projects and Total Usage on Layer 0 Network')
plt.xlabel ('Time ( seconds )')
plt.ylabel (' Transactions per Second ( tps )')
plt.legend ()
plt.grid ( True )
plt.show ()
```The Annual Percentage Rate (APR)
```python
import numpy as np
import matplotlib . pyplot as plt
def apr_function (x):
base = 15 * 10**15
apr_decimal = -np. log10 (x / 2000 + 0.0001) / np. log10 ( base ) - 0.1
return apr_decimal * 100
x_values = np. linspace (0, 20, 400) # Assuming the time range is 0 to 20 years for illustration
y_values = apr_function ( x_values )
# Plotting the function
plt.figure( figsize =(10 , 5))
plt.plot( x_values , y_values , label ='APR over time')
plt.title('APR as a function of Time ( Percentage )')
plt.xlabel('Time ( years )')
plt.ylabel('APR (%)')
plt.legend()
plt.grid( True )
plt.show()
```