# Section F: Mathematical Models for Various Components

## How and how much will I get Slashed as a Node?

Slashing would be carried out after the completion of each epoch. Nodes may get slashed for Double Signing, Liveliness Faults, and Safety Faults as detailed below:

* **Double Signing**
  * A validator is considered dishonest if they sign two different blocks at the same height in the blockchain. This is a clear violation of the protocol rules, as a validator should only produce or endorse one block per slot.
  * Double signing can be detected by monitoring the network for blocks that have the same height but different block hashes and are both signed by the same validator.

* **Liveliness Faults**
  * If a validator repeatedly fails to be online and participate in the consensus process (i.e., they miss too many votes), they could be penalized. This ensures that validators have an incentive to maintain a reliable and consistent online presence.
  * Liveliness faults can be detected by monitoring validators' participation in the network consensus process and noting when a validator is offline or unresponsive for an unacceptable period of time.

* **Safety Faults**
  * Validators should only vote for one version of the history. If a validator votes for conflicting versions of the blockchain history (e.g., during a network partition), it's a safety fault.
  * Safety faults can be detected by monitoring for validators casting votes for conflicting versions of the blockchain history.

The slashing penalty is determined based on

```jsx
Slashing_Penalty = Offense_Severity*XScore_Penalty*Slashing_Dynamics*(Stake_Value/Total_Staked_Value)
```

where

*Offense\_Severity* represents the severity of the offense committed by the validator.

*XScore\_Penalty* accounts for the validator's XScore which reflects their performance, reliability, and adherence to the rules of the network. A higher XScore indicates a better-behaved validator, resulting in a lower slashing penalty.

*Slashing\_Dynamic*s represents the mechanism to discourage malicious behavior based on overall network dynamics and inflation rate.

*Stake\_Value* is the total amount of tokens staked by the offending validator.

*Total\_Staked\_Value* is the sum of all tokens staked in the entire network for the 500 cubes.

```jsx
Slashed_Value = min (Slashing_Penalty, Slashing_Threshold)
```

where

*Slashed\_Value* is the actual value deducted as the penalty from the *Staked\_Value*.

*Slashing\_Threshold* is the cap on the slashing penalty to prevent excessive penalties that could harm the network's stability.

*Slashed\_Value* would be deducted after *Slashing\_Delay* time period.

## Rewards to run Full Validator Node.

```jsx
Reward_FVN = (Staked_Value/Total_Staked_Value)*FVN_Reward_Dynamics*XScore_Reward
```

where

*Stake\_Value* is the total amount of tokens staked by the offending validator.

*Total\_Staked\_Value* is the sum of all tokens staked in the entire network for the 500 cubes.

*FVN\_Reward\_Dynamics* accounts for the overall dynamics of the reward system, including inflation rates, block rewards, and any other mechanisms that influence the distribution of rewards.

*XScore\_Reward* is a factor that reflects the validator's XScore, which indicates their performance, reliability, and adherence to the network rules. Validators with higher XScores would receive greater rewards.

Rewards would be granted after *FVN\_Rewards\_Interval.*

## Rewards to run Event Listener Node.

```jsx
Reward_ELN = (Staked_Value/Total_Staked_Value)*ELN_Reward_Dynamics*StakeScore_Reward
```

where

*Stake\_Value* is the total amount of tokens staked by the offending validator.

*Total\_Staked\_Value* is the sum of all tokens staked in the entire network for the 500 cubes.

*ELN\_Reward\_Dynamics* accounts for the overall dynamics based on chains connected and events validated by the ELN.

*StakeScore\_Reward* is a factor that reflects the validator's StakeScore, which indicates their commitment to the network.

Rewards would be granted after *ELN\_Rewards\_Interval.*

## Rewards to delegate stake into the Protocol Liquidity Pool.

```jsx
Rewards_Delegated = (Stake_Delegated / Total_Liquidity_Pool_Value)*Reward_Liquidity_Pool + (Protocol_Fees*Stake_Delegated)
```

where

*Stake\_Delegated* represents the total amount of tokens staked or delegated by a participant into the liquidity pool.

*Total\_Liquidity\_Pool\_Value* is the sum of all tokens staked in the entire liquidity pool. It provides the proportion of the participant's stake compared to the total staked amount.

*Reward\_Liquidity\_Pool* represents the portion of the protocol's revenue that is allocated for rewards to participants in the liquidity pool.

*Protocol\_Fees* represents the fees charged on each transaction within the liquidity pool. The protocol fees contribute to the reward pool.

## How much Rewards can I earn?

Based on the staked tokens for either Full Validator Nodes or Event Listener Nodes or delegation in Liquidity Pools, one can earn rewards accordingly. Exact numbers are never provided and are dependent on the time and the activity on the network.