refactor(ckbtc): Generic events (#7991)

Refactor the ckBTC event log to be generic over the type of events
stored, so that the ckDOGE minter, that reuses code from the ckBTC
minter can have dedicated events. Quite a few ckBTC events are only
there for backwards-compatibility reasons or are not relevant for the
ckDOGE minter (e.g. events related to checking whether UTXOs or
addresses are tainted).

This PR is pure refactoring and does not change the behaviour of the
ckBTC or ckDOGE minter. It only allows to have 2 implementations, which
are currently identical, on how to record and replay events. The next PR
will change the ckDOGE implementation to have dedicated events.

1. #7991
2. #8035

---------

Co-authored-by: Thomas Locher <[email protected]>
Co-authored-by: IDX GitHub Automation <[email protected]>

Author: 3 people

Cargo.lock

@@ -2,7 +2,7 @@ use candid::{CandidType, Deserialize, Principal};
 use ic_agent::Agent;
 use ic_ckbtc_minter::queries::{EstimateFeeArg, RetrieveBtcStatusRequest, WithdrawalFee};
 use ic_ckbtc_minter::state::RetrieveBtcStatus;
-use ic_ckbtc_minter::state::eventlog::{Event, GetEventsArg};
+use ic_ckbtc_minter::state::eventlog::{CkBtcMinterEvent, GetEventsArg};
 use ic_ckbtc_minter::updates::{
     get_btc_address::GetBtcAddressArgs,
     retrieve_btc::{RetrieveBtcArgs, RetrieveBtcError, RetrieveBtcOk},
@@ -135,7 +135,7 @@ impl CkBtcMinterAgent {
         &self,
         start: u64,
         length: u64,
-    ) -> Result<Vec<Event>, CkBtcMinterAgentError> {
+    ) -> Result<Vec<CkBtcMinterEvent>, CkBtcMinterAgentError> {
         self.query("get_events", GetEventsArg { start, length })
             .await
     }

rs/bitcoin/ckbtc/agent/src/lib.rs

@@ -19,6 +19,7 @@ use std::collections::{BTreeMap, BTreeSet};
 use std::time::Duration;
 
 use crate::fees::{BitcoinFeeEstimator, FeeEstimator};
+use crate::state::eventlog::{CkBtcEventLogger, EventLogger};
 use crate::state::utxos::UtxoSet;
 use crate::state::{CkBtcMinterState, mutate_state, read_state};
 use crate::updates::get_btc_address;
@@ -1584,6 +1585,9 @@ pub trait CanisterRuntime {
     /// Type used to estimate fees.
     type Estimator: FeeEstimator;
 
+    /// Type used for events recording of state changes.
+    type EventLogger: EventLogger;
+
     /// Returns the caller of the current call.
     fn caller(&self) -> Principal {
         ic_cdk::api::msg_caller()
@@ -1631,6 +1635,9 @@ pub trait CanisterRuntime {
     /// How to estimate fees.
     fn fee_estimator(&self, state: &CkBtcMinterState) -> Self::Estimator;
 
+    /// How to record and replay events.
+    fn event_logger(&self) -> Self::EventLogger;
+
     /// Retrieves the current transaction fee percentiles.
     async fn get_current_fee_percentiles(
         &self,
@@ -1687,6 +1694,7 @@ pub struct IcCanisterRuntime {}
 #[async_trait]
 impl CanisterRuntime for IcCanisterRuntime {
     type Estimator = BitcoinFeeEstimator;
+    type EventLogger = CkBtcEventLogger;
 
     fn refresh_fee_percentiles_frequency(&self) -> Duration {
         const ONE_HOUR: Duration = Duration::from_secs(3_600);
@@ -1697,6 +1705,10 @@ impl CanisterRuntime for IcCanisterRuntime {
         BitcoinFeeEstimator::from_state(state)
     }
 
+    fn event_logger(&self) -> Self::EventLogger {
+        CkBtcEventLogger
+    }
+
     async fn get_current_fee_percentiles(
         &self,
         request: &GetCurrentFeePercentilesRequest,

rs/bitcoin/ckbtc/minter/src/lib.rs

@@ -1,9 +1,9 @@
 use crate::CanisterRuntime;
 use crate::logs::Priority;
-use crate::state::eventlog::{EventType, replay};
+use crate::state::eventlog::{EventLogger, EventType};
 use crate::state::invariants::CheckInvariantsImpl;
 use crate::state::{Mode, replace_state};
-use crate::storage::{count_events, events, migrate_old_events_if_not_empty, record_event};
+use crate::storage::{count_events, migrate_old_events_if_not_empty, record_event};
 use candid::{CandidType, Deserialize};
 use canlog::log;
 use ic_base_types::CanisterId;
@@ -84,9 +84,13 @@ pub fn post_upgrade<R: CanisterRuntime>(upgrade_args: Option<UpgradeArgs>, runti
         count_events()
     );
 
-    let state = replay::<CheckInvariantsImpl>(events()).unwrap_or_else(|e| {
-        ic_cdk::trap(format!("[upgrade]: failed to replay the event log: {e:?}"))
-    });
+    let event_logger = runtime.event_logger();
+
+    let state = event_logger
+        .replay::<CheckInvariantsImpl>(event_logger.events_iter())
+        .unwrap_or_else(|e| {
+            ic_cdk::trap(format!("[upgrade]: failed to replay the event log: {e:?}"))
+        });
 
     runtime.validate_config(&state);
 

rs/bitcoin/ckbtc/minter/src/lifecycle/upgrade.rs

@@ -5,7 +5,7 @@ use ic_ckbtc_minter::lifecycle::upgrade::UpgradeArgs;
 use ic_ckbtc_minter::lifecycle::{self, init::MinterArg};
 use ic_ckbtc_minter::queries::{EstimateFeeArg, RetrieveBtcStatusRequest, WithdrawalFee};
 use ic_ckbtc_minter::reimbursement::InvalidTransactionError;
-use ic_ckbtc_minter::state::eventlog::Event;
+use ic_ckbtc_minter::state::eventlog::CkBtcMinterEvent;
 use ic_ckbtc_minter::state::{
     BtcRetrievalStatusV2, RetrieveBtcStatus, RetrieveBtcStatusV2, mutate_state, read_state,
 };
@@ -61,13 +61,19 @@ fn ok_or_die(result: Result<(), String>) {
 /// Checks that ckBTC minter state internally consistent.
 #[cfg(feature = "self_check")]
 fn check_invariants() -> Result<(), String> {
-    use ic_ckbtc_minter::state::{eventlog::replay, invariants::CheckInvariantsImpl};
+    use ic_ckbtc_minter::state::{
+        eventlog::{CkBtcEventLogger, EventLogger},
+        invariants::CheckInvariantsImpl,
+    };
+
+    let events_logger = CkBtcEventLogger;
 
     read_state(|s| {
         s.check_invariants()?;
 
-        let events: Vec<_> = storage::events().collect();
-        let recovered_state = replay::<CheckInvariantsImpl>(events.clone().into_iter())
+        let events: Vec<_> = events_logger.events_iter().collect();
+        let recovered_state = events_logger
+            .replay::<CheckInvariantsImpl>(events.clone().into_iter())
             .unwrap_or_else(|e| panic!("failed to replay log ({e:?}): {events:?}"));
 
         recovered_state.check_invariants()?;
@@ -197,7 +203,7 @@ async fn get_canister_status() -> ic_cdk::management_canister::CanisterStatusRes
 
 #[cfg(feature = "self_check")]
 #[update]
-async fn upload_events(events: Vec<Event>) {
+async fn upload_events(events: Vec<CkBtcMinterEvent>) {
     for event in events {
         storage::record_event(event.payload, &IC_CANISTER_RUNTIME);
     }
@@ -259,7 +265,7 @@ fn http_request(req: HttpRequest) -> HttpResponse {
 }
 
 #[query]
-fn get_events(args: GetEventsArg) -> Vec<Event> {
+fn get_events(args: GetEventsArg) -> Vec<CkBtcMinterEvent> {
     const MAX_EVENTS_PER_QUERY: usize = 2000;
 
     storage::events()