Merge commit e2ebf25b (no conflict)

Parent branch: origin/master
Forked at: bf7ccb84

.gitlab-ci.yml

@@ -177,6 +177,18 @@ build-linux-release:               &build
     - cp -r scripts/docker/* ./artifacts
     - sccache -s
 
+build-linux-release-pr:            &build
+  stage:                           build
+  <<:                              *collect-artifacts
+  <<:                              *test-refs
+  <<:                              *docker-env
+  <<:                              *compiler_info
+  script:
+    - time cargo build --release --verbose
+    - mkdir -p ./artifacts
+    - mv ./target/release/polkadot ./artifacts/.
+    - sha256sum ./artifacts/polkadot | tee ./artifacts/polkadot.sha256
+  when: manual
 
 generate-impl-guide:
   stage:                          build

Cargo.toml

@@ -4,7 +4,7 @@ path = "src/main.rs"
 
 [package]
 name = "polkadot"
-version = "0.8.22"
+version = "0.8.23"
 authors = ["Parity Technologies <admin@parity.io>"]
 edition = "2018"
 

RELEASE.md

+# Release Checklist
+
+The following checks should be completed before publishing a new release of the
+Polkadot/Kusama/Westend runtime or client.
+
+### Runtime Releases
+
+The following should be done *prior* to tagging the potential release. Upon
+completion, tag the commit and proceed with the [All Releases](#all-releases) steps.
+
+- [ ] List any [native runtime](#native-runtimes) versions associated with the release.
+- [ ] Has incremented  [`spec_version`](#spec-version) for any native runtimes from any existing use on public (non-private/test) networks.
+- [ ] Verify [new migrations](#new-migrations) complete successfully, and the runtime state is
+  correctly updated.
+- [ ] Verify previously [completed migrations](#old-migrations-removed) are removed.
+- [ ] Verify pallet and [extrinsic ordering](#extrinsic-ordering) has stayed the same. Bump
+  `transaction_version` if not.
+- [ ] Verify new extrinsics have been correctly whitelisted/blacklisted for
+  [proxy filters](#proxy-filtering).
+- [ ] Verify [benchmarks](#benchmarks) have been updated for any modified runtime logic.
+- [ ] Verify [Polkadot JS API](#polkadot-js) are up to date with the latest runtime changes.
+
+### All Releases
+
+- [ ] Check that the new client versions have [run on the network](#burn-in) without issue for 12
+  hours.
+- [ ] Check that a draft release has been created at https://github.com/paritytech/polkadot/releases with relevant [release notes](#release-notes)
+- [ ] Check that [build artifacts](#build-artifacts) have been added to the draft-release
+
+## Notes
+
+### Burn In
+
+Ensure that Parity DevOps has run the new release on Westend, Kusama, and Polkadot validators for
+at least 12 hours prior to publishing the release.
+
+### Build Artifacts
+
+Add any necessary assets to the release. They should include:
+
+- Linux binary
+- GPG signature of the Linux binary
+- SHA256 of binary
+- Source code
+- Wasm binaries of any runtimes
+
+### Release notes
+
+The release notes should list:
+
+- The priority of the release (i.e., how quickly users should upgrade)
+- Which native runtimes and their versions are included
+- The proposal hashes of the runtimes as built with [srtool](https://gitlab.com/chevdor/srtool)
+
+The release notes may also list:
+
+- Free text at the beginning of the notes mentioning anything important regarding this release
+- Notable changes (those labelled with B[1-9]-* labels) separated into sections
+
+### Spec Version
+
+A runtime upgrade must bump the spec number. This may follow a pattern with the client release
+(e.g. runtime v12 corresponds to v0.8.12, even if the current runtime is not v11).
+
+### New Migrations
+
+Ensure that any migrations that are required due to storage or logic changes are included in the
+`on_runtime_upgrade` function of the appropriate pallets.
+
+### Old Migrations Removed
+
+Any previous `on_runtime_upgrade` functions from old upgrades must be removed to prevent them from
+executing a second time.
+
+### Extrinsic Ordering
+
+Offline signing libraries depend on a consistent ordering of call indices and functions. Compare
+the metadata of the current and new runtimes and ensure that the `module index, call index` tuples
+map to the same set of functions. In case of a breaking change, increase `transaction_version`.
+
+Note: Adding new functions to the runtime does not constitute a breaking change as long as they are
+added to the end of a pallet (i.e., does not break any other call index).
+
+### Proxy Filtering
+
+The runtime contains proxy filters that map proxy types to allowable calls. If the new runtime
+contains any new calls, verify that the proxy filters are up to date to include them.
+
+### Benchmarks
+
+Run the benchmarking suite with the new runtime and update any function weights if necessary.
+
+### Polkadot JS
+
+Ensure that a release of [Polkadot JS API]() contains any new types or interfaces necessary to
+interact with the new runtime.

cli/Cargo.toml

 [package]
 name = "polkadot-cli"
-version = "0.8.22"
+version = "0.8.23"
 authors = ["Parity Technologies <admin@parity.io>"]
 description = "Polkadot Relay-chain Client Node"
 edition = "2018"

cli/src/cli.rs

@@ -21,9 +21,26 @@ use structopt::StructOpt;
 #[allow(missing_docs)]
 #[derive(Debug, StructOpt)]
 pub enum Subcommand {
-	#[allow(missing_docs)]
-	#[structopt(flatten)]
-	Base(sc_cli::Subcommand),
+	/// Build a chain specification.
+	BuildSpec(sc_cli::BuildSpecCmd),
+
+	/// Validate blocks.
+	CheckBlock(sc_cli::CheckBlockCmd),
+
+	/// Export blocks.
+	ExportBlocks(sc_cli::ExportBlocksCmd),
+
+	/// Export the state of a given block into a chain spec.
+	ExportState(sc_cli::ExportStateCmd),
+
+	/// Import blocks.
+	ImportBlocks(sc_cli::ImportBlocksCmd),
+
+	/// Remove the whole chain.
+	PurgeChain(sc_cli::PurgeChainCmd),
+
+	/// Revert the chain to a previous state.
+	Revert(sc_cli::RevertCmd),
 
 	#[allow(missing_docs)]
 	#[structopt(name = "validation-worker", setting = structopt::clap::AppSettings::Hidden)]

cli/src/command.rs

@@ -96,24 +96,24 @@ impl SubstrateCli for Cli {
 	}
 }
 
+fn set_default_ss58_version(spec: &Box<dyn service::ChainSpec>) {
+	use sp_core::crypto::Ss58AddressFormat;
+
+	let ss58_version = if spec.is_kusama() {
+		Ss58AddressFormat::KusamaAccount
+	} else if spec.is_westend() {
+		Ss58AddressFormat::SubstrateAccount
+	} else {
+		Ss58AddressFormat::PolkadotAccount
+	};
+
+	sp_core::crypto::set_default_ss58_version(ss58_version);
+}
+
 /// Parses polkadot specific CLI arguments and run the service.
 pub fn run() -> Result<()> {
 	let cli = Cli::from_args();
 
-	fn set_default_ss58_version(spec: &Box<dyn service::ChainSpec>) {
-		use sp_core::crypto::Ss58AddressFormat;
-
-		let ss58_version = if spec.is_kusama() {
-			Ss58AddressFormat::KusamaAccount
-		} else if spec.is_westend() {
-			Ss58AddressFormat::SubstrateAccount
-		} else {
-			Ss58AddressFormat::PolkadotAccount
-		};
-
-		sp_core::crypto::set_default_ss58_version(ss58_version);
-	};
-
 	match &cli.subcommand {
 		None => {
 			let runner = cli.create_runner(&cli.run.base)?;
@@ -150,34 +150,68 @@ pub fn run() -> Result<()> {
 				}
 			})
 		},
-		Some(Subcommand::Base(subcommand)) => {
-			let runner = cli.create_runner(subcommand)?;
+		Some(Subcommand::BuildSpec(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.sync_run(|config| cmd.run(config.chain_spec, config.network))
+		},
+		Some(Subcommand::CheckBlock(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			let chain_spec = &runner.config().chain_spec;
+
+			set_default_ss58_version(chain_spec);
+
+			runner.async_run(|mut config| {
+				let (client, _, import_queue, task_manager) = service::new_chain_ops(&mut config)?;
+				Ok((cmd.run(client, import_queue), task_manager))
+			})
+		},
+		Some(Subcommand::ExportBlocks(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
 			let chain_spec = &runner.config().chain_spec;
 
 			set_default_ss58_version(chain_spec);
 
-			if chain_spec.is_kusama() {
-				runner.run_subcommand(subcommand, |config|
-					service::new_chain_ops::<
-						service::kusama_runtime::RuntimeApi,
-						service::KusamaExecutor,
-					>(config)
-				)
-			} else if chain_spec.is_westend() {
-				runner.run_subcommand(subcommand, |config|
-					service::new_chain_ops::<
-						service::westend_runtime::RuntimeApi,
-						service::WestendExecutor,
-					>(config)
-				)
-			} else {
-				runner.run_subcommand(subcommand, |config|
-					service::new_chain_ops::<
-						service::polkadot_runtime::RuntimeApi,
-						service::PolkadotExecutor,
-					>(config)
-				)
-			}
+			runner.async_run(|mut config| {
+				let (client, _, _, task_manager) = service::new_chain_ops(&mut config)?;
+				Ok((cmd.run(client, config.database), task_manager))
+			})
+		},
+		Some(Subcommand::ExportState(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			let chain_spec = &runner.config().chain_spec;
+
+			set_default_ss58_version(chain_spec);
+
+			runner.async_run(|mut config| {
+				let (client, _, _, task_manager) = service::new_chain_ops(&mut config)?;
+				Ok((cmd.run(client, config.chain_spec), task_manager))
+			})
+		},
+		Some(Subcommand::ImportBlocks(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			let chain_spec = &runner.config().chain_spec;
+
+			set_default_ss58_version(chain_spec);
+
+			runner.async_run(|mut config| {
+				let (client, _, import_queue, task_manager) = service::new_chain_ops(&mut config)?;
+				Ok((cmd.run(client, import_queue), task_manager))
+			})
+		},
+		Some(Subcommand::PurgeChain(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.sync_run(|config| cmd.run(config.database))
+		},
+		Some(Subcommand::Revert(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			let chain_spec = &runner.config().chain_spec;
+
+			set_default_ss58_version(chain_spec);
+
+			runner.async_run(|mut config| {
+				let (client, backend, _, task_manager) = service::new_chain_ops(&mut config)?;
+				Ok((cmd.run(client, backend), task_manager))
+			})
 		},
 		Some(Subcommand::ValidationWorker(cmd)) => {
 			sc_cli::init_logger("");
@@ -196,19 +230,9 @@ pub fn run() -> Result<()> {
 
 			set_default_ss58_version(chain_spec);
 
-			if chain_spec.is_kusama() {
-				runner.sync_run(|config| {
-					cmd.run::<service::kusama_runtime::Block, service::KusamaExecutor>(config)
-				})
-			} else if chain_spec.is_westend() {
-				runner.sync_run(|config| {
-					cmd.run::<service::westend_runtime::Block, service::WestendExecutor>(config)
-				})
-			} else {
-				runner.sync_run(|config| {
-					cmd.run::<service::polkadot_runtime::Block, service::PolkadotExecutor>(config)
-				})
-			}
+			runner.sync_run(|config| {
+				cmd.run::<service::kusama_runtime::Block, service::KusamaExecutor>(config)
+			})
 		},
 	}
 }

erasure-coding/Cargo.toml

 [package]
 name = "polkadot-erasure-coding"
-version = "0.8.22"
+version = "0.8.23"
 authors = ["Parity Technologies <admin@parity.io>"]
 edition = "2018"
 

node/core/av-store/Cargo.toml

@@ -11,7 +11,7 @@ polkadot-overseer = { path = "../../overseer" }
 polkadot-primitives = { path = "../../../primitives" }
 erasure = { package = "polkadot-erasure-coding", path = "../../../erasure-coding" }
 kvdb = "0.7.0"
-kvdb-rocksdb = "0.9.0"
+kvdb-rocksdb = "0.9.1"
 codec = { package = "parity-scale-codec", version = "1.3.1", features = ["derive"] }
 log = "0.4.8"
 derive_more = "0.99.9"

node/network/bitfield-distribution/src/lib.rs

@@ -127,6 +127,8 @@ impl PerRelayParentData {
 	}
 }
 
+const TARGET: &'static str = "bitd";
+
 /// The bitfield distribution subsystem.
 pub struct BitfieldDistribution;
 
@@ -144,22 +146,22 @@ impl BitfieldDistribution {
 				FromOverseer::Communication {
 					msg: BitfieldDistributionMessage::DistributeBitfield(hash, signed_availability),
 				} => {
-					trace!(target: "bitd", "Processing DistributeBitfield");
+					trace!(target: TARGET, "Processing DistributeBitfield");
 					handle_bitfield_distribution(&mut ctx, &mut state, hash, signed_availability)
 						.await?;
 				}
 				FromOverseer::Communication {
 					msg: BitfieldDistributionMessage::NetworkBridgeUpdateV1(event),
 				} => {
-					trace!(target: "bitd", "Processing NetworkMessage");
+					trace!(target: TARGET, "Processing NetworkMessage");
 					// a network message was received
 					if let Err(e) = handle_network_msg(&mut ctx, &mut state, event).await {
-						warn!(target: "bitd", "Failed to handle incomming network messages: {:?}", e);
+						warn!(target: TARGET, "Failed to handle incomming network messages: {:?}", e);
 					}
 				}
 				FromOverseer::Signal(OverseerSignal::ActiveLeaves(ActiveLeavesUpdate { activated, deactivated })) => {
 					for relay_parent in activated {
-						trace!(target: "bitd", "Start {:?}", relay_parent);
+						trace!(target: TARGET, "Start {:?}", relay_parent);
 						// query basic system parameters once
 						if let Some((validator_set, signing_context)) =
 							query_basics(&mut ctx, relay_parent).await?
@@ -181,15 +183,15 @@ impl BitfieldDistribution {
 					}
 
 					for relay_parent in deactivated {
-						trace!(target: "bitd", "Stop {:?}", relay_parent);
+						trace!(target: TARGET, "Stop {:?}", relay_parent);
 						// defer the cleanup to the view change
 					}
 				}
 				FromOverseer::Signal(OverseerSignal::BlockFinalized(hash)) => {
-					trace!(target: "bitd", "Block finalized {:?}", hash);
+					trace!(target: TARGET, "Block finalized {:?}", hash);
 				}
 				FromOverseer::Signal(OverseerSignal::Conclude) => {
-					trace!(target: "bitd", "Conclude");
+					trace!(target: TARGET, "Conclude");
 					return Ok(());
 				}
 			}
@@ -206,7 +208,7 @@ async fn modify_reputation<Context>(
 where
 	Context: SubsystemContext<Message = BitfieldDistributionMessage>,
 {
-	trace!(target: "bitd", "Reputation change of {:?} for peer {:?}", rep, peer);
+	trace!(target: TARGET, "Reputation change of {:?} for peer {:?}", rep, peer);
 	ctx.send_message(AllMessages::NetworkBridge(
 		NetworkBridgeMessage::ReportPeer(peer, rep),
 	))
@@ -231,7 +233,7 @@ where
 		job_data
 	} else {
 		trace!(
-			target: "bitd",
+			target: TARGET,
 			"Not supposed to work on relay parent {} related data",
 			relay_parent
 		);
@@ -240,7 +242,7 @@ where
 	};
 	let validator_set = &job_data.validator_set;
 	if validator_set.is_empty() {
-		trace!(target: "bitd", "Validator set for {:?} is empty", relay_parent);
+		trace!(target: TARGET, "Validator set for {:?} is empty", relay_parent);
 		return Ok(());
 	}
 
@@ -248,7 +250,7 @@ where
 	let validator = if let Some(validator) = validator_set.get(validator_index) {
 		validator.clone()
 	} else {
-		trace!(target: "bitd", "Could not find a validator for index {}", validator_index);
+		trace!(target: TARGET, "Could not find a validator for index {}", validator_index);
 		return Ok(());
 	};
 
@@ -308,7 +310,7 @@ where
 
 	if interested_peers.is_empty() {
 		trace!(
-			target: "bitd",
+			target: TARGET,
 			"No peers are interested in gossip for relay parent {:?}",
 			message.relay_parent
 		);
@@ -334,12 +336,12 @@ async fn process_incoming_peer_message<Context>(
 where
 	Context: SubsystemContext<Message = BitfieldDistributionMessage>,
 {
-	// we don't care about this, not part of our view
+	// we don't care about this, not part of our view.
 	if !state.view.contains(&message.relay_parent) {
 		return modify_reputation(ctx, origin, COST_NOT_IN_VIEW).await;
 	}
 
-	// Ignore anything the overseer did not tell this subsystem to work on
+	// Ignore anything the overseer did not tell this subsystem to work on.
 	let mut job_data = state.per_relay_parent.get_mut(&message.relay_parent);
 	let job_data: &mut _ = if let Some(ref mut job_data) = job_data {
 		job_data
@@ -350,7 +352,7 @@ where
 	let validator_set = &job_data.validator_set;
 	if validator_set.is_empty() {
 		trace!(
-			target: "bitd",
+			target: TARGET,
 			"Validator set for relay parent {:?} is empty",
 			&message.relay_parent
 		);
@@ -391,7 +393,7 @@ where
 		// only relay_message a message of a validator once
 		if one_per_validator.get(&validator).is_some() {
 			trace!(
-				target: "bitd",
+				target: TARGET,
 				"Already received a message for validator at index {}",
 				validator_index
 			);
@@ -407,6 +409,7 @@ where
 		modify_reputation(ctx, origin, COST_SIGNATURE_INVALID).await
 	}
 }
+
 /// Deal with network bridge updates and track what needs to be tracked
 /// which depends on the message type received.
 async fn handle_network_msg<Context>(
@@ -435,7 +438,7 @@ where
 		NetworkBridgeEvent::PeerMessage(remote, message) => {
 			match message {
 				protocol_v1::BitfieldDistributionMessage::Bitfield(relay_parent, bitfield) => {
-					trace!(target: "bitd", "Received bitfield gossip from peer {:?}", &remote);
+					trace!(target: TARGET, "Received bitfield gossip from peer {:?}", &remote);
 					let gossiped_bitfield = BitfieldGossipMessage {
 						relay_parent,
 						signed_availability: bitfield,
@@ -455,7 +458,7 @@ fn handle_our_view_change(state: &mut ProtocolState, view: View) -> SubsystemRes
 	for added in state.view.difference(&old_view) {
 		if !state.per_relay_parent.contains_key(&added) {
 			warn!(
-				target: "bitd",
+				target: TARGET,
 				"Our view contains {} but the overseer never told use we should work on this",
 				&added
 			);
@@ -501,7 +504,7 @@ where
 					one_per_validator
 						.into_iter()
 						.filter(move |(validator, _message)| {
-							// ..except for the ones the peer already has
+							// ..except for the ones the peer already has.
 							job_data.message_from_validator_needed_by_peer(&origin, validator)
 						}),
 				)
@@ -598,7 +601,7 @@ where
 			SigningContext { parent_hash: relay_parent, session_index: s },
 		))),
 		(Err(e), _) | (_, Err(e)) => {
-			warn!(target: "bitd", "Failed to fetch basics from runtime API: {:?}", e);
+			warn!(target: TARGET, "Failed to fetch basics from runtime API: {:?}", e);
 			Ok(None)
 		}
 	}

node/network/bridge/src/lib.rs

@@ -52,11 +52,11 @@ const MAX_VIEW_HEADS: usize = 5;
 /// The engine ID of the validation protocol.
 pub const VALIDATION_PROTOCOL_ID: ConsensusEngineId = *b"pvn1";
 /// The protocol name for the validation peer-set.
-pub const VALIDATION_PROTOCOL_NAME: &[u8] = b"/polkadot/validation/1";
+pub const VALIDATION_PROTOCOL_NAME: &'static str = "/polkadot/validation/1";
 /// The engine ID of the collation protocol.
 pub const COLLATION_PROTOCOL_ID: ConsensusEngineId = *b"pcn1";
 /// The protocol name for the collation peer-set.
-pub const COLLATION_PROTOCOL_NAME: &[u8] = b"/polkadot/collation/1";
+pub const COLLATION_PROTOCOL_NAME: &'static str = "/polkadot/collation/1";
 
 const MALFORMED_MESSAGE_COST: ReputationChange
 	= ReputationChange::new(-500, "Malformed Network-bridge message");
@@ -81,7 +81,7 @@ pub enum WireMessage<M> {
 
 /// Information about the notifications protocol. Should be used during network configuration
 /// or shortly after startup to register the protocol with the network service.
-pub fn notifications_protocol_info() -> Vec<(ConsensusEngineId, std::borrow::Cow<'static, [u8]>)> {
+pub fn notifications_protocol_info() -> Vec<(ConsensusEngineId, std::borrow::Cow<'static, str>)> {
 	vec![
 		(VALIDATION_PROTOCOL_ID, VALIDATION_PROTOCOL_NAME.into()),
 		(COLLATION_PROTOCOL_ID, COLLATION_PROTOCOL_NAME.into()),

node/service/src/lib.rs

@@ -631,7 +631,7 @@ fn new_light<Runtime, Dispatch>(mut config: Configuration) -> Result<TaskManager
 
 /// Builds a new object suitable for chain operations.
 #[cfg(feature = "full-node")]
-pub fn new_chain_ops<Runtime, Dispatch>(mut config: Configuration) -> Result<
+pub fn new_chain_ops<Runtime, Dispatch>(mut config: &mut Configuration) -> Result<
 	(
 		Arc<FullClient<Runtime, Dispatch>>,
 		Arc<FullBackend>,
@@ -648,7 +648,7 @@ where
 {
 	config.keystore = service::config::KeystoreConfig::InMemory;
 	let service::PartialComponents { client, backend, import_queue, task_manager, .. }
-		= new_partial::<Runtime, Dispatch>(&mut config)?;
+		= new_partial::<Runtime, Dispatch>(config)?;
 	Ok((client, backend, import_queue, task_manager))
 }
 

parachain/Cargo.toml

 [package]
 name = "polkadot-parachain"
-version = "0.8.22"
+version = "0.8.23"
 authors = ["Parity Technologies <admin@parity.io>"]
 description = "Types and utilities for creating and working with parachains"
 edition = "2018"

parachain/test-parachains/adder/Cargo.toml

 [package]
 name = "test-parachain-adder"
-version = "0.8.22"
+version = "0.8.23"
 authors = ["Parity Technologies <admin@parity.io>"]
 description = "Test parachain which adds to a number as its state transition"
 edition = "2018"

parachain/test-parachains/halt/Cargo.toml

 [package]
 name = "test-parachain-halt"
-version = "0.8.22"
+version = "0.8.23"
 authors = ["Parity Technologies <admin@parity.io>"]
 description = "Test parachain which executes forever"
 edition = "2018"

primitives/Cargo.toml

 [package]
 name = "polkadot-primitives"
-version = "0.8.22"
+version = "0.8.23"
 authors = ["Parity Technologies <admin@parity.io>"]
 edition = "2018"
 

roadmap/implementers-guide/src/SUMMARY.md

@@ -5,15 +5,16 @@
 - [Whence Parachains](whence-parachains.md)
 - [Parachains Overview](parachains-overview.md)
 - [Architecture Overview](architecture.md)
+- [Approval Overview](approval.md)
 - [Messaging Overview](messaging.md)
 - [Runtime Architecture](runtime/README.md)
   - [Initializer Module](runtime/initializer.md)
   - [Configuration Module](runtime/configuration.md)
+  - [Disputes Module](runtime/disputes.md)
   - [Paras Module](runtime/paras.md)
   - [Scheduler Module](runtime/scheduler.md)
   - [Inclusion Module](runtime/inclusion.md)
   - [InclusionInherent Module](runtime/inclusioninherent.md)
-  - [Validity Module](runtime/validity.md)
   - [Router Module](runtime/router.md)
 - [Runtime APIs](runtime-api/README.md)
   - [Validators](runtime-api/validators.md)
@@ -40,9 +41,6 @@
     - [Availability Distribution](node/availability/availability-distribution.md)
     - [Bitfield Distribution](node/availability/bitfield-distribution.md)
     - [Bitfield Signing](node/availability/bitfield-signing.md)
-  - [Validity](node/validity/README.md)
-    - [Approvals](node/validity/approvals.md)
-    - [Approval assignments](node/validity/assignmets.md)
   - [Utility Subsystems](node/utility/README.md)