# 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 ```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 ```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 ```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 ```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 ```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 ```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() ``` ```` --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://docs.phron.ai/tokenomics/appendix-a-simulation-code-example.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.