feat(alpenglow): introduce alpenclock primitives to bank

Author: ksn6

runtime/src/bank.rs

@@ -186,7 +186,7 @@ use {
                 AtomicBool, AtomicI64, AtomicU64,
                 Ordering::{self, AcqRel, Acquire, Relaxed},
             },
-            Arc, LockResult, Mutex, RwLock, RwLockReadGuard, RwLockWriteGuard, Weak,
+            Arc, LazyLock, LockResult, Mutex, RwLock, RwLockReadGuard, RwLockWriteGuard, Weak,
         },
         time::{Duration, Instant},
     },
@@ -230,6 +230,14 @@ pub const MAX_LEADER_SCHEDULE_STAKES: Epoch = 5;
 /// only the top 2000 validators by stake will be present in vote account structures.
 pub const MAX_ALPENGLOW_VOTE_ACCOUNTS: usize = 2000;
 
+/// The off-curve account where we store the Alpenglow clock. The clock sysvar has seconds
+/// resolution while the Alpenglow clock has nanosecond resolution.
+static NANOSECOND_CLOCK_ACCOUNT: LazyLock<Pubkey> = LazyLock::new(|| {
+    let (pubkey, _) =
+        Pubkey::find_program_address(&[b"alpenclock"], &agave_feature_set::alpenglow::id());
+    pubkey
+});
+
 pub type BankStatusCache = StatusCache<Result<()>>;
 #[cfg_attr(
     feature = "frozen-abi",
@@ -2849,6 +2857,59 @@ impl Bank {
         })
     }
 
+    /// Update the clock sysvar from a block footer's nanosecond timestamp.
+    /// Also stores the nanosecond value for later retrieval via `get_nanosecond_clock`.
+    pub fn update_clock_from_footer(&self, time_nanos: i64) {
+        if !self.feature_set.is_active(&feature_set::alpenglow::id()) {
+            return;
+        }
+
+        let time_secs = time_nanos / 1_000_000_000;
+
+        let parent_epoch = self.parent().map(|p| p.epoch());
+        let epoch_start_timestamp =
+            if parent_epoch.is_some() && parent_epoch.unwrap() != self.epoch() {
+                time_secs
+            } else {
+                self.clock().epoch_start_timestamp
+            };
+
+        let clock = sysvar::clock::Clock {
+            slot: self.slot,
+            epoch_start_timestamp,
+            epoch: self.epoch_schedule().get_epoch(self.slot),
+            leader_schedule_epoch: self.epoch_schedule().get_leader_schedule_epoch(self.slot),
+            unix_timestamp: time_secs,
+        };
+        self.update_sysvar_account(&sysvar::clock::id(), |account| {
+            create_account(
+                &clock,
+                self.inherit_specially_retained_account_fields(account),
+            )
+        });
+
+        // Store nanosecond clock value in account for later retrieval
+        let data = time_nanos.to_le_bytes();
+        let lamports = self.get_minimum_balance_for_rent_exemption(data.len());
+        let mut account = AccountSharedData::new(lamports, data.len(), &Pubkey::default());
+        account.set_data_from_slice(&data);
+        self.store_account(&NANOSECOND_CLOCK_ACCOUNT, &account);
+    }
+
+    /// Get the nanosecond clock value. Returns `None` if the nanosecond clock has not been
+    /// populated (i.e., before Alpenglow migration completes).
+    pub fn get_nanosecond_clock(&self) -> Option<i64> {
+        self.get_account(&NANOSECOND_CLOCK_ACCOUNT)
+            .and_then(|acct| {
+                let data = acct.data();
+                if data.len() == 8 {
+                    Some(i64::from_le_bytes(data.try_into().unwrap()))
+                } else {
+                    None
+                }
+            })
+    }
+
     pub fn confirmed_last_blockhash(&self) -> Hash {
         const NUM_BLOCKHASH_CONFIRMATIONS: usize = 3;