Add initial log entry during initialization, fixes #100

Previously, an add-chain request would add an entry to the pool, and
then during the first sequencing the initial log entry would be added as
the _second_ entry in the log. Instead, add the initial entry during
initialization to make sure it's actually the initial entry.

Author: lukevalenta

crates/generic_log_worker/src/log_ops.rs

@@ -467,11 +467,16 @@ impl SequenceState {
         })
     }
 
-    /// Returns the current checkpoint
+    /// Returns the current checkpoint.
     pub(crate) fn checkpoint(&self) -> &[u8] {
         &self.checkpoint
     }
 
+    /// Returns the current tree size.
+    pub(crate) fn tree_size(&self) -> u64 {
+        self.tree.size()
+    }
+
     /// Proves inclusion of the last leaf in the current tree.
     #[cfg(test)]
     pub(crate) fn prove_inclusion_of_last_elem(&self) -> Proof {
@@ -766,13 +771,6 @@ pub(crate) async fn sequence<L: LogEntry>(
     cache: &impl CacheWrite,
     metrics: &SequencerMetrics,
 ) -> Result<(), anyhow::Error> {
-    // Add the log's initial entry if needed.
-    if sequence_state.borrow().tree.size() == 0 {
-        if let Some(entry) = L::initial_entry() {
-            pool_state.borrow_mut().add(entry.lookup_key(), entry);
-        }
-    }
-
     let Some(entries) = pool_state.borrow_mut().take(
         sequence_state.borrow().tree.size(),
         config.max_sequence_skips,
@@ -882,6 +880,12 @@ async fn sequence_entries<L: LogEntry>(
     let mut cache_metadata = Vec::with_capacity(entries.len());
 
     for (entry, sender) in entries {
+        if n == 0 {
+            if let Some(initial_entry) = L::initial_entry() {
+                assert_eq!(entry.lookup_key(), initial_entry.lookup_key());
+            }
+        }
+
         // Add the entry and metadata to our lists of things sequenced
         let metadata = (n, timestamp);
         cache_metadata.push((entry.lookup_key(), metadata));

crates/generic_log_worker/src/sequencer_do.rs

@@ -7,7 +7,7 @@ use std::{cell::RefCell, future::Future, pin::Pin, time::Duration};
 
 use crate::{
     deserialize, get_durable_object_stub, load_public_bucket,
-    log_ops::{self, CreateError, PoolState, SequenceState},
+    log_ops::{self, add_leaf_to_pool, CreateError, PoolState, SequenceState},
     metrics::{millis_diff_as_secs, ObjectMetrics, SequencerMetrics},
     serialize,
     util::now_millis,
@@ -229,6 +229,13 @@ impl<L: LogEntry> GenericSequencer<L> {
                 .await
                 .map_err(|e| e.to_string())?;
 
+        // If the tree is empty, add the log's initial entry if it has one.
+        if self.sequence_state.borrow().tree_size() == 0 {
+            if let Some(entry) = L::initial_entry() {
+                add_leaf_to_pool(&self.pool_state, &self.cache, &self.config, entry);
+            }
+        }
+
         // Start sequencing loop (OK if alarm is already scheduled).
         self.do_state
             .storage()