How to adjust parameters in the simulation

Most of the time, the simulations generated with the Basic editor are almost what we need for our project, but we want some further adjustments. Some instances where this might be the case are:

• We want to add some different hypothetical scenarios for the users to test (e.g. base scenario, pessimistic, and optimistic)

• We want to adapt some incentive schedule to a formula more complex than what is available in the Basic editor, for instance one that depends on a given protocol performance parameter, and not just time.

• We want to change protocol fee distribution percentages over time.

These are the easiest changes and can be done by modifying only some “Input parameters” and “Simulation equations”. Here are examples of the steps to follow:

Example: Add scenarios with different hypotheses

For this example, we want to add a selector available to the results dashboard end-users where they can change between different hypothetical scenarios for the future growth of the protocol. We would do the following:

1. Find each time-dependent parameter representing a growth hypothesis of the protocol. Usually there is one for each value proposition defined (for example TDP_VP_1_GROWTH_PARAM)

2. Create one time-dependent parameters for each growth scenario we want to consider for the selector

3. Generate the selector in “Input parameters” with the different options desired (e.g. “Low adoption”, “Mid adoption”, and “High adoption”)

4. Find in the “Simulation equation” the references to the original time dependent parameter and replace them with the selector.

For example: TDP_vp_1_growth_param should be replaced with SE_preset_scenarios.case("High adoption": TDP_vp_1_growth_param_high, "Mid adoption": TDP_vp_1_growth_param_mid, "Low adoption": TDP_vp_1_growth_param_low).

Then, add the selector to the inputs available to the user through the “Sidebar Configuration” section.

Example: Adjust an incentive release schedule

For this example, we want to adjust the release schedule of a token incentive. Following the recommended workflow, we generated the starting point for this simulation through the Basic editor, which included an Incentives Reserve and a linear incentive release schedule. When we converted the simulation to the Advanced editor mode, this got interpreted as an “Incentives Reserve” agent to hold the token incentives and a “Incentives Reserve distribution” flow to release them. In order to adjust it to our precise definition:

1. Identify the agent that holds the tokens for that incentive, in the “Agents and Token Flows” section.

2. In the “Token Exchange Flows” table of the same section, identify the token flow that distributes those tokens to their recipients. It will have the previously identified agent as its “Source”.

3. Find the equation corresponding to the value of the token flow in the “Simulation Equations” section and substitute with the appropriate formula.

In the example shown in the images, the original amount of tokens distributed as incentives is all of the amount vested at each timestep (which means that in the Basic editor we selected “distribute as it vests”).

If instead we want to distribute rewards each year at a rate that decreases over time, we would change the formula to:

(1 - SP_yearly_rewards_decay_percent / 100)^(time.years // 1) * time_step.years * SP_initial_tokens_incentives

In this formula, every year there is a decay of SP_yearly_rewards_decay_percent relative to the original amount of tokens given SP_initial_tokens_incentives.

We can also introduce a threshold to ensure the tokens given are not greater than the tokens that the reserve has:

MIN(A_incentives_reserve_1.total_tokens.previous, (1 - SP_yearly_rewards_decay_percent / 100)^(time.years // 1) * time_step.years * SP_initial_tokens_incentives)

This is our new “F_INCENTIVE_1”.

We will also need to add the static parameters SP_yearly_rewards_decay_percent and SP_initial_tokens_incentives that we introduced in the formula to the “Input Parameters” section, and assign them default values.