@rivetkit/engine 1.0.0 → 2.2.1-pr.4600.b74ff3b

package/packages/epoxy/spec/PROPOSAL.md

@@ -1,125 +0,0 @@
-# EPaxos Proposal Specification
-
-Based on Figure 2 & 3.
-
-## Phase 1: Establish ordering constraints
-
-**Replica L on receiving Request(γ) from a client becomes the designated leader for command γ (steps 2, 3 and 4 executed atomically):**
-
-1: increment instance number i_L ← i_L + 1
-   {Interf_L,γ is the set of instances Q.j such that the command recorded in cmds_L[Q][j] interferes w/ γ}
-   -> src/replica/messages/lead_consensus.rs
-2: seq_γ ← 1+ max ({cmds_L[Q][j].seq | Q.j ∈ Interf_L,γ} ∪ {0})
-   -> src/replica/messages/lead_consensus.rs
-3: deps_γ ← Interf_L,γ
-   -> src/replica/messages/lead_consensus.rs
-4: cmds_L[L][i_L] ← (γ, seq_γ, deps_γ, pre-accepted)
-   -> src/replica/messages/lead_consensus.rs
-5: send PreAccept(γ, seq_γ, deps_γ, L.i_L) to all other replicas in F, where F is a fast quorum that includes L
-   -> src/replica/propose.rs
-
-**Any replica R, on receiving PreAccept(γ, seq_γ, deps_γ, L.i) (steps 6, 7 and 8 executed atomically):**
-
-6: update seq_γ ← max({seq_γ} ∪ {1 + cmds_R[Q][j].seq | Q.j ∈ Interf_R,γ})
-   -> src/replica/messages/pre_accept.rs
-7: update deps_γ ← deps_γ ∪ Interf_R,γ
-   -> src/replica/messages/pre_accept.rs
-8: cmds_R[L][i] ← (γ, seq_γ, deps_γ, pre-accepted)
-   -> src/replica/messages/pre_accept.rs
-9: reply PreAcceptOK(γ, seq_γ, deps_γ, L.i) to L
-   -> src/replica/messages/pre_accept.rs
-
-**Replica L (command leader for γ), on receiving at least ⌊N/2⌋ PreAcceptOK responses:**
-
-10: if received PreAcceptOK's from all replicas in F \ {L}, with seq_γ and deps_γ the same in all replies (for some fast quorum F) then
-    -> src/replica/messages/decide_path.rs
-11:    run Commit phase for (γ, seq_γ, deps_γ) at L.i
-       -> src/replica/messages/decide_path.rs
-12: else
-    -> src/replica/messages/decide_path.rs
-13:    update deps_γ ← Union(deps_γ from all replies)
-       -> src/replica/messages/decide_path.rs
-14:    update seq_γ ← max({seq_γ of all replies})
-       -> src/replica/messages/decide_path.rs
-15:    run Paxos-Accept phase for (γ, seq_γ, deps_γ) at L.i
-       -> src/replica/messages/decide_path.rs
-
-## Phase 2: Paxos-Accept
-
-**Command leader L, for (γ, seq_γ, deps_γ) at instance L.i:**
-
-16: cmds_L[L][i] ← (γ, seq_γ, deps_γ, accepted)
-    -> src/replica/messages/accepted.rs
-17: send Accept(γ, seq_γ, deps_γ, L.i) to at least ⌊N/2⌋ other replicas
-    -> src/replica/propose.rs
-
-**Any replica R, on receiving Accept(γ, seq_γ, deps_γ, L.i):**
-
-18: cmds_R[L][i] ← (γ, seq_γ, deps_γ, accepted)
-    -> src/replica/messages/accept.rs
-19: reply AcceptOK(γ, L.i) to L
-    -> src/replica/messages/accept.rs
-
-**Command leader L, on receiving at least ⌊N/2⌋ AcceptOK's:**
-
-20: run Commit phase for (γ, seq_γ, deps_γ) at L.i
-    -> src/replica/propose.rs
-
-## Commit
-
-**Command leader L, for (γ, seq_γ, deps_γ) at instance L.i:**
-
-21: cmds_L[L][i] ← (γ, seq_γ, deps_γ, committed)
-    -> src/replica/messages/committed.rs
-22: send commit notification for γ to client
-    -> src/replica/propose.rs (via return value)
-23: send Commit(γ, seq_γ, deps_γ, L.i) to all other replicas
-    -> src/replica/propose.rs
-
-**Any replica R, on receiving Commit(γ, seq_γ, deps_γ, L.i):**
-
-24: cmds_R[L][i] ← (γ, seq_γ, deps_γ, committed)
-    -> src/replica/messages/commit.rs
-
-## Explicit Prepare
-
-**Replica Q for instance L.i of potentially failed replica L**
-
-25: increment ballot number to epoch.(b+1).Q, (where epoch.b.R is the highest ballot number Q is aware of in instance L.i)
-    -> src/ops/explicit_prepare.rs
-26: send Prepare(epoch.(b+1).Q, L.i) to all replicas (including self) and wait for at least ⌊N/2⌋ + 1 replies
-    -> src/ops/explicit_prepare.rs
-27: let R be the set of replies w/ the highest ballot number
-    -> src/ops/explicit_prepare.rs
-28: if R contains a (γ, seq_γ, deps_γ, committed) then
-    -> src/ops/explicit_prepare.rs
-29:    run Commit phase for (γ, seq_γ, deps_γ) at L.i
-    -> src/ops/explicit_prepare.rs
-30: else if R contains an (γ, seq_γ, deps_γ, accepted) then
-    -> src/ops/explicit_prepare.rs
-31:    run Paxos-Accept phase for (γ, seq_γ, deps_γ) at L.i
-    -> src/ops/explicit_prepare.rs
-32: else if R contains at least ⌊N/2⌋ identical replies (γ, seq_γ, deps_γ, pre-accepted) for the default ballot epoch.0.L of instance L.i, and none of those replies is from L then
-    -> src/ops/explicit_prepare.rs
-33:    run Paxos-Accept phase for (γ, seq_γ, deps_γ) at L.i
-    -> src/ops/explicit_prepare.rs
-34: else if R contains at least one (γ, seq_γ, deps_γ, pre-accepted) then
-    -> src/ops/explicit_prepare.rs
-35:    start Phase 1 (at line 2) for γ at L.i, avoid fast path
-    -> src/ops/explicit_prepare.rs
-36: else
-    -> src/ops/explicit_prepare.rs
-37:    start Phase 1 (at line 2) for no-op at L.i, avoid fast path
-    -> src/ops/explicit_prepare.rs
-
-**Replica R, on receiving Prepare(epoch.b.Q, L.i) from Q**
-
-38: if epoch.b.Q is larger than the most recent ballot number epoch.x.Y accepted for instance L.i then
-    -> src/replica/messages/prepare.rs
-39:    reply PrepareOK(cmds_R[L][i], epoch.x.Y, L.i)
-    -> src/replica/messages/prepare.rs
-40: else
-    -> src/replica/messages/prepare.rs
-41:    reply NACK
-    -> src/replica/messages/prepare.rs
-

package/packages/epoxy/spec/RECONFIGURE.md

@@ -1,40 +0,0 @@
-# EPaxos Reconfiguration Specification
-
-This specification describes the reconfiguration process for EPaxos, specifically how new nodes join the cluster.
-
-## Process
-
-**Coordinator checks for configuration changes:**
-
-1: Read current topology from rivet_config
-2: Compare with existing cluster state to find new replicas
-3: if new replicas found then
-4:    Perform health checks on all new replicas
-9:    Add new replicas to cluster config with status=Joining
-10:   Send BeginLearningRequest to each new replica with current cluster config
-
-**New replica R on receiving BeginLearningSignal from coordinator:**
-
-14: for each existing replica E in config (excluding self) do
-15:    Download log entries from replica E
-16:    for each log entry in downloaded chunk do
-17:       Replay log entry (without committing to KV)
-18: Recover key-value state from replayed log entries
-19:    for each unique key in log entries do
-20:       Find all committed instances that touched this key
-21:       Determine final value using highest sequence leaf entry
-22:       Commit recovered value to KV store
-23: Send CoordinatorUpdateReplicaStatusRequest(status=Active) to coordinator
-
-**Coordinator on receiving replica status update to Active:**
-
-24: Update replica status in cluster config
-25: if status changed from non-Active to Active then
-26:    increment epoch
-27:    Send UpdateConfigRequest(new_config) to all replicas
-
-**Any replica R on receiving UpdateConfigRequest(new_config):**
-
-28: Update local cluster configuration to new_config
-29: Recognize new active members in cluster
-

package/packages/epoxy/src/ops/explicit_prepare.rs

@@ -1,342 +0,0 @@
-use anyhow::*;
-use epoxy_protocol::protocol::{self, ReplicaId};
-use gas::prelude::*;
-use rivet_api_builder::ApiCtx;
-
-use crate::{http_client, replica, utils};
-
-#[derive(Debug)]
-pub struct Input {
-	pub instance: protocol::Instance,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub enum ExplicitPrepareResult {
-	/// Command was successfully committed through explicit prepare
-	Committed,
-	/// Explicit prepare failed (couldn't reach quorum)
-	Failed,
-	/// Command error occurred during execution
-	CommandError(crate::ops::propose::CommandError),
-}
-
-#[operation]
-pub async fn epoxy_explicit_prepare(
-	ctx: &OperationCtx,
-	input: &Input,
-) -> Result<ExplicitPrepareResult> {
-	let replica_id = ctx.config().epoxy_replica_id();
-	let instance = &input.instance;
-
-	tracing::debug!(
-		?instance,
-		"starting explicit prepare for potentially failed replica"
-	);
-
-	// Read config
-	let config = ctx
-		.udb()?
-		.run(|tx| async move { utils::read_config(&tx, replica_id).await })
-		.custom_instrument(tracing::info_span!("read_config_tx"))
-		.await?;
-
-	// EPaxos Step 25: Increment ballot number
-	let new_ballot = ctx
-		.udb()?
-		.run(|tx| async move { replica::ballot::increment_ballot(&tx, replica_id).await })
-		.custom_instrument(tracing::info_span!("increment_ballot_tx"))
-		.await?;
-
-	// Get quorum members
-	let quorum_members = utils::get_quorum_members(&config);
-
-	// EPaxos Step 26: Send Prepare to all replicas and wait for quorum
-	let prepare_responses = send_prepares(
-		ctx,
-		&config,
-		replica_id,
-		&quorum_members,
-		&new_ballot,
-		instance,
-	)
-	.await?;
-
-	// Check if we got enough responses for a quorum
-	let required_quorum = utils::calculate_quorum(quorum_members.len(), utils::QuorumType::Slow);
-	if prepare_responses.len() < required_quorum {
-		tracing::warn!(
-			received_responses = prepare_responses.len(),
-			required_quorum = required_quorum,
-			"failed to get quorum for explicit prepare"
-		);
-		return Ok(ExplicitPrepareResult::Failed);
-	}
-
-	// EPaxos Step 27: Find replies with highest ballot number
-	let highest_ballot_responses = find_highest_ballot_responses(&prepare_responses);
-
-	// Decide what to do based on the responses
-	let result = match analyze_prepare_responses(&highest_ballot_responses, instance) {
-		PrepareDecision::Commit(payload) => {
-			// EPaxos Step 29: Run Commit phase
-			let result =
-				crate::ops::propose::commit(ctx, &config, replica_id, payload, false).await?;
-			convert_proposal_result(result)
-		}
-		PrepareDecision::Accept(payload) => {
-			// EPaxos Step 31: Run Paxos-Accept phase
-			let result = crate::ops::propose::run_paxos_accept(
-				ctx,
-				&config,
-				replica_id,
-				&quorum_members,
-				payload,
-				false,
-			)
-			.await?;
-			convert_proposal_result(result)
-		}
-		PrepareDecision::RestartPhase1(commands) => {
-			// EPaxos Steps 35-37: Start Phase 1, avoid fast path
-			restart_phase1(
-				ctx,
-				&config,
-				replica_id,
-				&quorum_members,
-				instance,
-				commands,
-			)
-			.await?
-		}
-	};
-
-	Ok(result)
-}
-
-fn convert_proposal_result(result: crate::ops::propose::ProposalResult) -> ExplicitPrepareResult {
-	match result {
-		crate::ops::propose::ProposalResult::Committed => ExplicitPrepareResult::Committed,
-		crate::ops::propose::ProposalResult::ConsensusFailed => ExplicitPrepareResult::Failed,
-		crate::ops::propose::ProposalResult::CommandError(cmd_err) => {
-			ExplicitPrepareResult::CommandError(cmd_err)
-		}
-	}
-}
-
-enum PrepareDecision {
-	Commit(protocol::Payload),
-	Accept(protocol::Payload),
-	RestartPhase1(Option<Vec<protocol::Command>>),
-}
-
-fn analyze_prepare_responses(
-	responses: &[&protocol::PrepareOk],
-	instance: &protocol::Instance,
-) -> PrepareDecision {
-	// EPaxos Step 28: Check if any response contains committed command
-	for response in responses {
-		if let Some(data) = &response.data {
-			if data.state == protocol::State::Committed {
-				let payload = protocol::Payload {
-					proposal: protocol::Proposal {
-						commands: data.commands.clone(),
-					},
-					seq: data.seq,
-					deps: data.deps.clone(),
-					instance: instance.clone(),
-				};
-				return PrepareDecision::Commit(payload);
-			}
-		}
-	}
-
-	// EPaxos Step 30: Check if any response contains accepted command
-	for response in responses {
-		if let Some(data) = &response.data {
-			if data.state == protocol::State::Accepted {
-				let payload = protocol::Payload {
-					proposal: protocol::Proposal {
-						commands: data.commands.clone(),
-					},
-					seq: data.seq,
-					deps: data.deps.clone(),
-					instance: instance.clone(),
-				};
-				return PrepareDecision::Accept(payload);
-			}
-		}
-	}
-
-	// EPaxos Step 32: Check for majority of identical pre-accepted replies from default ballot
-	let pre_accepted_responses: Vec<_> = responses
-		.iter()
-		.filter_map(|r| {
-			r.data.as_ref().filter(|data| {
-				data.state == protocol::State::PreAccepted
-					&& data.ballot.epoch == 0
-					&& data.ballot.ballot == 0
-					&& data.ballot.replica_id == instance.replica_id
-			})
-		})
-		.collect();
-
-	if pre_accepted_responses.len() >= responses.len() / 2 + 1 {
-		// Check if all pre-accepted responses are identical and none from original replica
-		if let Some(first) = pre_accepted_responses.first() {
-			let all_identical = pre_accepted_responses.iter().all(|r| {
-				r.commands == first.commands && r.seq == first.seq && r.deps == first.deps
-			});
-
-			let none_from_original = responses
-				.iter()
-				.all(|r| r.previous_ballot.replica_id != instance.replica_id);
-
-			if all_identical && none_from_original {
-				let payload = protocol::Payload {
-					proposal: protocol::Proposal {
-						commands: first.commands.clone(),
-					},
-					seq: first.seq,
-					deps: first.deps.clone(),
-					instance: instance.clone(),
-				};
-				// EPaxos Step 33
-				return PrepareDecision::Accept(payload);
-			}
-		}
-	}
-
-	// EPaxos Step 34: Check if any response contains pre-accepted command
-	for response in responses {
-		if let Some(data) = &response.data {
-			if data.state == protocol::State::PreAccepted {
-				// EPaxos Step 35
-				return PrepareDecision::RestartPhase1(Some(data.commands.clone()));
-			}
-		}
-	}
-
-	// EPaxos Step 36: No responses or no valid commands - restart with no-op
-	// EPaxos Step 37: Start Phase 1 for no-op at L.i, avoid fast path
-	PrepareDecision::RestartPhase1(None)
-}
-
-fn find_highest_ballot_responses(responses: &[protocol::PrepareOk]) -> Vec<&protocol::PrepareOk> {
-	if responses.is_empty() {
-		return Vec::new();
-	}
-
-	let highest_ballot = responses
-		.iter()
-		.map(|r| &r.previous_ballot)
-		.max_by(|a, b| compare_ballots(a, b))
-		.unwrap();
-
-	responses
-		.iter()
-		.filter(|r| {
-			compare_ballots(&r.previous_ballot, highest_ballot) == std::cmp::Ordering::Equal
-		})
-		.collect()
-}
-
-fn compare_ballots(a: &protocol::Ballot, b: &protocol::Ballot) -> std::cmp::Ordering {
-	match a.epoch.cmp(&b.epoch) {
-		std::cmp::Ordering::Equal => match a.ballot.cmp(&b.ballot) {
-			std::cmp::Ordering::Equal => a.replica_id.cmp(&b.replica_id),
-			other => other,
-		},
-		other => other,
-	}
-}
-
-#[tracing::instrument(skip_all)]
-async fn send_prepares(
-	ctx: &OperationCtx,
-	config: &protocol::ClusterConfig,
-	from_replica_id: ReplicaId,
-	replica_ids: &[ReplicaId],
-	ballot: &protocol::Ballot,
-	instance: &protocol::Instance,
-) -> Result<Vec<protocol::PrepareOk>> {
-	let responses = http_client::fanout_to_replicas(
-		from_replica_id,
-		replica_ids,
-		utils::QuorumType::Slow,
-		|to_replica_id| {
-			let config = config.clone();
-			let ballot = ballot.clone();
-			let instance = instance.clone();
-			async move {
-				let response = http_client::send_message(
-					&ApiCtx::new_from_operation(&ctx)?,
-					&config,
-					protocol::Request {
-						from_replica_id,
-						to_replica_id,
-						kind: protocol::RequestKind::PrepareRequest(protocol::PrepareRequest {
-							ballot,
-							instance,
-						}),
-					},
-				)
-				.await?;
-
-				let protocol::Response {
-					kind: protocol::ResponseKind::PrepareResponse(response),
-				} = response
-				else {
-					bail!("wrong response type");
-				};
-
-				match response {
-					protocol::PrepareResponse::PrepareOk(ok) => Ok(ok),
-					protocol::PrepareResponse::PrepareNack(_nack) => {
-						bail!("received NACK for prepare request");
-					}
-				}
-			}
-		},
-	)
-	.await?;
-
-	Ok(responses)
-}
-
-#[tracing::instrument(skip_all)]
-async fn restart_phase1(
-	ctx: &OperationCtx,
-	_config: &protocol::ClusterConfig,
-	_replica_id: ReplicaId,
-	_quorum_members: &[ReplicaId],
-	instance: &protocol::Instance,
-	commands: Option<Vec<protocol::Command>>,
-) -> Result<ExplicitPrepareResult> {
-	// Create proposal with provided commands or no-op
-	let proposal = protocol::Proposal {
-		commands: commands.unwrap_or_else(|| vec![]), // Empty vec for no-op
-	};
-
-	tracing::debug!(
-		?instance,
-		commands_count = proposal.commands.len(),
-		"restarting phase1 with propose operation"
-	);
-
-	// Call the propose operation to restart consensus from Phase 1
-	let result = ctx
-		.op(crate::ops::propose::Input {
-			proposal,
-			purge_cache: false,
-		})
-		.await?;
-
-	// Convert ProposalResult to ExplicitPrepareResult
-	match result {
-		crate::ops::propose::ProposalResult::Committed => Ok(ExplicitPrepareResult::Committed),
-		crate::ops::propose::ProposalResult::ConsensusFailed => Ok(ExplicitPrepareResult::Failed),
-		crate::ops::propose::ProposalResult::CommandError(cmd_err) => {
-			Ok(ExplicitPrepareResult::CommandError(cmd_err))
-		}
-	}
-}

package/packages/epoxy/src/replica/decide_path.rs

@@ -1,51 +0,0 @@
-use anyhow::Result;
-use epoxy_protocol::protocol;
-use universaldb::Transaction;
-
-use crate::replica::utils;
-
-pub fn decide_path(
-	_tx: &Transaction,
-	pre_accept_oks: Vec<protocol::Payload>,
-	payload: &protocol::Payload,
-) -> Result<protocol::Path> {
-	tracing::debug!(instance=?payload.instance, "deciding path");
-
-	let mut new_payload = payload.clone();
-	let mut path = protocol::Path::PathFast(protocol::PathFast {
-		payload: payload.clone(),
-	});
-
-	for pre_accept_ok in pre_accept_oks {
-		let protocol::Payload {
-			proposal: _,
-			seq,
-			deps,
-			instance: _,
-		} = pre_accept_ok.clone();
-
-		// EPaxos Steps 10
-		if seq == payload.seq && deps == payload.deps {
-			// EPaxos Steps 11 (returns PathFast)
-			continue;
-		} else {
-			tracing::debug!(?pre_accept_ok.deps, "received dissenting voice");
-
-			// EPaxos Step 13
-			let new_deps = utils::union_deps(new_payload.deps, pre_accept_ok.deps);
-			new_payload.deps = new_deps.clone();
-
-			// EPaxos Step 14
-			if pre_accept_ok.seq > new_payload.seq {
-				new_payload.seq = pre_accept_ok.seq;
-			}
-
-			// EPaxos Step 15
-			path = protocol::Path::PathSlow(protocol::PathSlow {
-				payload: new_payload.clone(),
-			});
-		}
-	}
-
-	Ok(path)
-}

package/packages/epoxy/src/replica/lead_consensus.rs

@@ -1,65 +0,0 @@
-use anyhow::Result;
-use epoxy_protocol::protocol;
-use universaldb::Transaction;
-use universaldb::utils::{FormalKey, IsolationLevel::*};
-
-use crate::keys;
-use crate::replica::{ballot, utils};
-
-#[tracing::instrument(skip_all)]
-pub async fn lead_consensus(
-	tx: &Transaction,
-	replica_id: protocol::ReplicaId,
-	proposal: protocol::Proposal,
-) -> Result<protocol::Payload> {
-	tracing::debug!(?replica_id, "leading consensus");
-
-	// EPaxos Step 1
-	let instance_num_key = keys::replica::InstanceNumberKey;
-	let packed_key = keys::subspace(replica_id).pack(&instance_num_key);
-
-	let value = tx.get(&packed_key, Serializable).await?;
-	let current_slot = if let Some(ref bytes) = value {
-		let current = instance_num_key.deserialize(bytes)?;
-		current
-	} else {
-		0
-	};
-
-	// Increment and store the new instance number
-	let slot_id = current_slot + 1;
-	tx.set(&packed_key, &instance_num_key.serialize(slot_id)?);
-
-	// Find interference for this key
-	let interf = utils::find_interference(tx, replica_id, &proposal.commands).await?;
-
-	// EPaxos Step 2
-	let seq = 1 + utils::find_max_seq(tx, replica_id, &interf).await?;
-
-	// EPaxos Step 3: deps are set to interf below
-
-	// EPaxos Step 4
-	let current_ballot = ballot::increment_ballot(tx, replica_id).await?;
-	let log_entry = protocol::LogEntry {
-		commands: proposal.commands.clone(),
-		seq,
-		deps: interf.clone(),
-		state: protocol::State::PreAccepted,
-		ballot: current_ballot,
-	};
-
-	// Update log
-	let instance = protocol::Instance {
-		replica_id,
-		slot_id,
-	};
-	crate::replica::update_log(tx, replica_id, log_entry, &instance).await?;
-
-	// Return payload
-	Ok(protocol::Payload {
-		proposal,
-		seq,
-		deps: interf,
-		instance,
-	})
-}

package/packages/epoxy/src/replica/log.rs

@@ -1,84 +0,0 @@
-use anyhow::{Result, ensure};
-use epoxy_protocol::protocol::{self, ReplicaId};
-use universaldb::Transaction;
-use universaldb::utils::{FormalKey, IsolationLevel::*};
-
-use crate::{keys, replica::utils};
-
-/// Returns the numeric order of a state for comparison.
-/// NONE < PREACCEPTED < ACCEPTED < COMMITTED
-pub fn state_order(state: &protocol::State) -> u8 {
-	match state {
-		protocol::State::PreAccepted => 1,
-		protocol::State::Accepted => 2,
-		protocol::State::Committed => 3,
-	}
-}
-
-#[tracing::instrument(skip_all)]
-pub async fn update_log(
-	tx: &Transaction,
-	replica_id: ReplicaId,
-	log_entry: protocol::LogEntry,
-	instance: &protocol::Instance,
-) -> Result<()> {
-	tracing::debug!(?replica_id, ?instance, ?log_entry.state, "updating log");
-
-	let subspace = keys::subspace(replica_id);
-	let log_key = keys::replica::LogEntryKey::new(instance.replica_id, instance.slot_id);
-	let packed_key = subspace.pack(&log_key);
-
-	// Read existing log entry to validate state progression
-	let current_entry = match tx.get(&packed_key, Serializable).await? {
-		Some(bytes) => Some(log_key.deserialize(&bytes)?),
-		None => None,
-	};
-
-	// Validate that new state is higher than current state
-	if let Some(current) = &current_entry {
-		let current_order = state_order(&current.state);
-		let new_order = state_order(&log_entry.state);
-
-		ensure!(
-			new_order > current_order,
-			"invalid state transition: cannot transition from {:?} to {:?} (order {} to {})",
-			current.state,
-			log_entry.state,
-			current_order,
-			new_order,
-		);
-
-		tracing::debug!(
-			?current.state,
-			?log_entry.state,
-			current_order,
-			new_order,
-			"validated state progression"
-		);
-	} else {
-		tracing::debug!(?log_entry.state, "creating new log entry");
-	}
-
-	// Store log entry in UDB
-	let value = log_key.serialize(log_entry.clone())?;
-	tx.set(&packed_key, &value);
-
-	// Store in keys for interference
-	let mut written_keys = 0;
-	for command in log_entry.commands {
-		let Some(key) = utils::extract_key_from_command(&command) else {
-			continue;
-		};
-
-		written_keys += 1;
-
-		let instance_key =
-			keys::replica::KeyInstanceKey::new(key.clone(), instance.replica_id, instance.slot_id);
-		let instance_packed_key = subspace.pack(&instance_key);
-		tx.set(&instance_packed_key, &[]);
-	}
-
-	tracing::debug!(?replica_id, ?instance, ?log_entry.state, ?written_keys, "wrote log entry");
-
-	Ok(())
-}