feat: implement NamedBarrier (#12)

* implement NamedBarrier

* fix clippy

Author: fahimahmedx

src/payload/checkpoint.rs

@@ -114,7 +114,7 @@ impl<P: Platform> Checkpoint<P> {
 	/// represents a bundle.
 	pub fn transactions(&self) -> &[Recovered<types::Transaction<P>>] {
 		match &self.inner.mutation {
-			Mutation::Barrier => &[],
+			Mutation::Barrier | Mutation::NamedBarrier(_) => &[],
 			Mutation::Executable(result) => result.transactions(),
 		}
 	}
@@ -123,7 +123,7 @@ impl<P: Platform> Checkpoint<P> {
 	/// checkpoint.
 	pub fn result(&self) -> Option<&ExecutionResult<P>> {
 		match &self.inner.mutation {
-			Mutation::Barrier => None,
+			Mutation::Barrier | Mutation::NamedBarrier(_) => None,
 			Mutation::Executable(result) => Some(result),
 		}
 	}
@@ -132,7 +132,7 @@ impl<P: Platform> Checkpoint<P> {
 	/// transaction(s) that created this checkpoint.
 	pub fn state(&self) -> Option<&BundleState> {
 		match self.inner.mutation {
-			Mutation::Barrier => None,
+			Mutation::Barrier | Mutation::NamedBarrier(_) => None,
 			Mutation::Executable(ref result) => Some(result.state()),
 		}
 	}
@@ -142,6 +142,11 @@ impl<P: Platform> Checkpoint<P> {
 		matches!(self.inner.mutation, Mutation::Barrier)
 	}
 
+	/// Returns true if this checkpoint is a named barrier checkpoint.
+	pub fn is_named_barrier(&self, name: &str) -> bool {
+		matches!(self.inner.mutation, Mutation::NamedBarrier(ref barrier_name) if barrier_name == name)
+	}
+
 	/// If this checkpoint is a single transaction, returns a reference to the
 	/// transaction that created this checkpoint. otherwise returns `None`.
 	pub fn as_transaction(&self) -> Option<&Recovered<types::Transaction<P>>> {
@@ -207,6 +212,22 @@ impl<P: Platform> Checkpoint<P> {
 			}),
 		}
 	}
+
+	/// Creates a new checkpoint on top of the current checkpoint that introduces
+	/// a named barrier. This new checkpoint will be now considered the new
+	/// beginning of mutable history.
+	#[must_use]
+	pub fn named_barrier(&self, name: impl Into<String>) -> Self {
+		Self {
+			inner: Arc::new(CheckpointInner {
+				block: self.inner.block.clone(),
+				prev: Some(Arc::clone(&self.inner)),
+				depth: self.inner.depth + 1,
+				mutation: Mutation::NamedBarrier(name.into()),
+				created_at: Instant::now(),
+			}),
+		}
+	}
 }
 
 /// Internal API
@@ -249,6 +270,11 @@ enum Mutation<P: Platform> {
 	/// the previous checkpoint. The executable item can be a single transaction
 	/// or a bundle of transactions.
 	Executable(ExecutionResult<P>),
+
+	/// A checkpoint that was created by applying a named barrier on top of the
+	/// previous checkpoint. The named barrier is used to indicate that any prior
+	/// checkpoints are immutable and should not be discarded or reordered.
+	NamedBarrier(String),
 }
 
 struct CheckpointInner<P: Platform> {
@@ -445,7 +471,15 @@ impl<P: Platform> Display for Checkpoint<P> {
 
 			// this is a barrier checkpoint, which has no transactions
 			// applied to it.
-			return write!(f, "[{}] barrier", self.depth());
+			return match &self.inner.mutation {
+				Mutation::Barrier => write!(f, "[{}] barrier", self.depth()),
+				Mutation::NamedBarrier(name) => {
+					write!(f, "[{}] barrier '{}'", self.depth(), name)
+				}
+				Mutation::Executable(_) => {
+					unreachable!("Executable variant handled above")
+				}
+			};
 		};
 
 		match exec_result.source() {

src/test_utils/step.rs

@@ -191,6 +191,16 @@ impl<P: PlatformWithRpcTypes + TestNodeFactory<P>> OneStep<P> {
 		self
 	}
 
+	/// Adds a named barrier to the input payload of the step at the current
+	/// position.
+	#[must_use]
+	pub fn with_payload_named_barrier(mut self, name: impl Into<String>) -> Self {
+		self
+			.payload_input
+			.push(InputPayloadItemFn::NamedBarrier(name.into()));
+		self
+	}
+
 	/// Adds a new transaction to the mempool and makes it available to the step.
 	/// Here we don't need to manage nonces, as the mempool will report the
 	/// pending transactions for the signer and nonces will be set automatically.
@@ -224,6 +234,9 @@ impl<P: PlatformWithRpcTypes + TestNodeFactory<P>> OneStep<P> {
 			.map(|input| -> eyre::Result<InputPayloadItem<P>> {
 				Ok(match input {
 					InputPayloadItemFn::Barrier => InputPayloadItem::Barrier,
+					InputPayloadItemFn::NamedBarrier(name) => {
+						InputPayloadItem::NamedBarrier(name)
+					}
 					InputPayloadItemFn::Tx(mut builder) => InputPayloadItem::Tx(
 						builder(
 							local_node
@@ -298,6 +311,7 @@ impl<P: PlatformWithRpcTypes> Step<P> for PopulatePayload<P> {
 		while let Ok(input) = self.receiver.lock().await.try_recv() {
 			payload = match input {
 				InputPayloadItem::Barrier => payload.barrier(),
+				InputPayloadItem::NamedBarrier(name) => payload.named_barrier(name),
 				InputPayloadItem::Tx(tx) => {
 					payload.apply(tx).expect("Failed to apply transaction")
 				}
@@ -381,12 +395,14 @@ impl<P: Platform> Step<P> for RecordBreakAndFail<P> {
 
 enum InputPayloadItemFn<P: PlatformWithRpcTypes> {
 	Barrier,
+	NamedBarrier(String),
 	Tx(BoxedTxBuilderFn<P>),
 	Bundle(types::Bundle<P>),
 }
 
 enum InputPayloadItem<P: PlatformWithRpcTypes> {
 	Barrier,
+	NamedBarrier(String),
 	Tx(types::TxEnvelope<P>),
 	Bundle(types::Bundle<P>),
 }