fix: update registration logic to handle early registration attempts

forester/src/epoch_manager.rs

@@ -902,7 +902,7 @@ impl<R: Rpc> EpochManager<R> {
         let slot = rpc.get_slot().await?;
         let phases = get_epoch_phases(&self.protocol_config, epoch);
 
-        if slot < phases.registration.end {
+        if slot >= phases.registration.start && slot < phases.registration.end {
             let forester_epoch_pda_pubkey =
                 get_forester_epoch_pda_from_authority(&self.config.derivation_pubkey, epoch).0;
             let existing_registration = rpc
@@ -984,6 +984,17 @@ impl<R: Rpc> EpochManager<R> {
             };
             debug!("Registered: {:?}", registration_info);
             Ok(registration_info)
+        } else if slot < phases.registration.start {
+            warn!(
+                "Too early to register for epoch {}. Current slot: {}, Registration starts: {}",
+                epoch, slot, phases.registration.start
+            );
+            Err(RegistrationError::RegistrationPhaseNotStarted {
+                epoch,
+                current_slot: slot,
+                registration_start: phases.registration.start,
+            }
+            .into())
         } else {
             warn!(
                 "Too late to register for epoch {}. Current slot: {}, Registration end: {}",

forester/src/errors.rs

@@ -68,6 +68,13 @@ pub enum ForesterError {
 
 #[derive(Error, Debug)]
 pub enum RegistrationError {
+    #[error("Too early to register for epoch {epoch}. Current slot: {current_slot}, Registration starts: {registration_start}")]
+    RegistrationPhaseNotStarted {
+        epoch: u64,
+        current_slot: u64,
+        registration_start: u64,
+    },
+
     #[error("Too late to register for epoch {epoch}. Current slot: {current_slot}, Registration end: {registration_end}")]
     RegistrationPhaseEnded {
         epoch: u64,

forester/src/processor/v2/processor.rs

@@ -293,6 +293,7 @@ where
             self.zkp_batch_size,
             self.current_root,
             self.proof_cache.clone(),
+            self.seq,
         );
         let job_tx = self
             .worker_pool

forester/src/processor/v2/tx_sender.rs

@@ -107,10 +107,10 @@ struct OrderedProofBuffer {
 }
 
 impl OrderedProofBuffer {
-    fn new(capacity: usize) -> Self {
+    fn new(capacity: usize, base_seq: u64) -> Self {
         Self {
             buffer: (0..capacity).map(|_| None).collect(),
-            base_seq: 0,
+            base_seq,
             len: 0,
             head: 0,
         }
@@ -191,6 +191,7 @@ impl<R: Rpc> TxSender<R> {
         zkp_batch_size: u64,
         last_seen_root: [u8; 32],
         proof_cache: Option<Arc<SharedProofCache>>,
+        initial_seq: u64,
     ) -> JoinHandle<crate::Result<TxSenderResult>> {
         let ixs_per_tx = if context.address_lookup_tables.is_empty() {
             V2_IXS_PER_TX_WITHOUT_LUT
@@ -200,7 +201,7 @@ impl<R: Rpc> TxSender<R> {
 
         let sender = Self {
             context,
-            buffer: OrderedProofBuffer::new(MAX_BUFFER_SIZE),
+            buffer: OrderedProofBuffer::new(MAX_BUFFER_SIZE, initial_seq),
             zkp_batch_size,
             last_seen_root,
             pending_batch: Vec::with_capacity(ixs_per_tx),