Enum TrackedShardsConfig

pub enum TrackedShardsConfig {
    NoShards,
    Shards(Vec<ShardUId>),
    AllShards,
    ShadowValidator(AccountId),
    Schedule(Vec<Vec<ShardId>>),
    Accounts(Vec<AccountId>),
}

Describes the expected behavior of the node regarding shard tracking. If the node is an active validator, it will also track the shards it is responsible for as a validator.

JSON schema

{
 "description": "Describes the expected behavior of the node regarding shard tracking.\nIf the node is an active validator, it will also track the shards it is responsible for as a validator.",
 "oneOf": [
   {
     "description": "Tracks no shards (light client).",
     "type": "string",
     "enum": [
       "NoShards"
     ]
   },
   {
     "description": "Tracks arbitrary shards.",
     "type": "object",
     "required": [
       "Shards"
     ],
     "properties": {
       "Shards": {
         "type": "array",
         "items": {
           "$ref": "#/components/schemas/ShardUId"
         }
       }
     },
     "additionalProperties": false
   },
   {
     "description": "Tracks all shards.",
     "type": "string",
     "enum": [
       "AllShards"
     ]
   },
   {
     "description": "Tracks shards that are assigned to given validator account.",
     "type": "object",
     "required": [
       "ShadowValidator"
     ],
     "properties": {
       "ShadowValidator": {
         "$ref": "#/components/schemas/AccountId"
       }
     },
     "additionalProperties": false
   },
   {
     "description": "Rotate between these sets of tracked shards.\nUsed to simulate the behavior of chunk only producers without staking tokens.",
     "type": "object",
     "required": [
       "Schedule"
     ],
     "properties": {
       "Schedule": {
         "type": "array",
         "items": {
           "type": "array",
           "items": {
             "$ref": "#/components/schemas/ShardId"
           }
         }
       }
     },
     "additionalProperties": false
   },
   {
     "description": "Tracks shards that contain one of the given account.",
     "type": "object",
     "required": [
       "Accounts"
     ],
     "properties": {
       "Accounts": {
         "type": "array",
         "items": {
           "$ref": "#/components/schemas/AccountId"
         }
       }
     },
     "additionalProperties": false
   }
 ]
}

Variants

NoShards

Tracks no shards (light client).

Shards(Vec<ShardUId>)

Tracks arbitrary shards.

AllShards

Tracks all shards.

ShadowValidator(AccountId)

Tracks shards that are assigned to given validator account.

Schedule(Vec<Vec<ShardId>>)

Rotate between these sets of tracked shards. Used to simulate the behavior of chunk only producers without staking tokens.

Accounts(Vec<AccountId>)

Tracks shards that contain one of the given account.

Trait Implementations

impl Clone for TrackedShardsConfig

fn clone(&self) -> TrackedShardsConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TrackedShardsConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TrackedShardsConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&TrackedShardsConfig> for TrackedShardsConfig

fn from(value: &TrackedShardsConfig) -> Self

Converts to this type from the input type.

impl From<AccountId> for TrackedShardsConfig

fn from(value: AccountId) -> Self

Converts to this type from the input type.

impl From<Vec<AccountId>> for TrackedShardsConfig

fn from(value: Vec<AccountId>) -> Self

Converts to this type from the input type.

impl From<Vec<ShardUId>> for TrackedShardsConfig

fn from(value: Vec<ShardUId>) -> Self

Converts to this type from the input type.

impl From<Vec<Vec<ShardId>>> for TrackedShardsConfig

fn from(value: Vec<Vec<ShardId>>) -> Self

Converts to this type from the input type.

impl Serialize for TrackedShardsConfig

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.