---
# System prepended metadata

title: The Decracy ID Layer

---

# The Decracy ID Layer

## Intro

The Decracy ID Layer(DIL) is a multilayer system that enables a democratic participation in the system. It is designed to give to biometrically identified individuals the opportunity to validate the network activity without staking any token, while not identified individuals are allowed only to stake to validate after a maturity time. The system spreads the rewards in 85% for X-ID and 15% for the proof stake part of the network, with that it stays true to the true intention of the system that is that the majority is X-ID validated and represents the vision of true democracy were one person equals one vote.

### The X-ID Nodes

The X-ID nodes are participants that have biometrically identified to the system and can validate network activity without the need of stake, while also earning fees. As Decracy would like to be a proof of X-ID nodes the rewards also represent that. X-ID validators are still required to be active participants of the network, running healthy nodes that don't act maliciously or against the network. Every node in the system has a reputation system that is morphed from the behavior of each node.



```rust
pub struct XID {
    /// This is the X-ID main Address and will not be used 
    /// for any other reason on the network other than 
    /// the validation of the network activity
    x_key_pair: Keypair,
    /// x_sig is the signature of the encrypted biometrical data 
    x_sig: Signature,
    /// A collection of addresses that the user can use 
    /// to make transactions, balances are included in the addresses
    addresses: Vec<Address>,
    /// nonce is the complete account nonce and will make sure
    /// that the account is properly creating new transactions
    nonce: u128,
    /// reputation represents the xID reputation
    reputation: Reputation,
}
```

### The Reputation System

The Decracy reputation system represents a global reputation system within the validators of the network. It is a very important aspect of the systems security as also a representation of the actions of the validator. Reputation can be gained and can be lost. All validators are starting with 100 reputation after the maturity time that the need to fill to be able to validate. Reputation is lost due to malicious activity and represents also a slashing factor on the slashing of the validators rewards.

```rust
pub struct Reputation {
    /// rep prepresents the reputation value 0 to 100
    rep: u16,
}
```

### The Reward System

The constant block reward emission is rewarded by [Amount]% to the X-ID validators and [Amount]% to the staking participants of the network. The staking mechanism is based on a periodically sloted system that allows everyone in the system to eventually stake. Slots are made available in epochs of staking and are relative to the X-ID validator count. To be a valid participant on the rewarding validators need to be present and participate in 95% of the event block propagation within the epoch.

### The Network Rules

The network rules represent a collection of decisions made by the team so that the system can stay autonomous and democratic. The rules are the back bone of the system and as in any democratic system are enforced by the majority to keep the participation honest and the network safe. Any action against the rules will be handled as malicious and depending of the action the reputation of the validator will get decreased, meaning that the reward of the validator will also get slashed accordingly.

```rust
/// STARTING_REPUTATION represents the starting reputation of all node
pub const STARTING_REPUTATION: u16 = 75;

/// MIN_GAS_LIMIT represents the smallest gas allowed
pub const MIN_GAS_LIMIT: u64 = 5000;

/// STAKING_EPOCH represents the time that a staking epoch will last
pub const STAKING_EPOCH: Duration = 90 * Days;

/// MIN_STAKING_SLOTS represents the smallest amount of slots 
pub const MIN_STAKING_SLOTS: u32 = 100;

/// MIN_PEERS represent the minimum peers that a node has to have before 
/// taking any actions on the network
pub const MIN_PEERS: u32 = 5;

/// MAX_LATENCY represents the maximum latency that a peer can have 
/// before it needs to disconect and reconnect.
pub const MAX_LATENCY: u16 = 10000;
```

### Bootstrapping the system

The system will bootstrap the network with a set of 10 validators.
Those validators will be X-ID validators that are going to be not collecting rewards and will remain there as pillars for new incoming validators that need to sync.

### Token Ecomomics

* 1 DCA = 100.000.000 Nano
* Number of decimal points = 8
* Event Block Reward = [Amount]
* Yearly Inflation = [Amount]

### Slashing Rules 

* Failed to pass the latency check for 5 re-connections -> 10
* Node spams for 5 re-connections -> 20
* Deleting smart contracts file -> 50
* Not having the proper file signatures -> 25
* Node not participating on the 95% of the epoch -> 25 
* Node not having 3 in a row transactions accepted -> 10