feat: remove ic-cdk dependency from ic-cdk-timers (#641)

Author: adamspofford-dfinity

Cargo.toml

@@ -42,6 +42,7 @@ candid = "0.10.18"      # sync with the doc comment in ic-cdk/README.md
 candid_parser = "0.2.1"
 futures = "0.3"
 hex = "0.4"
+ic_principal = "0.1"
 quote = "1"
 serde = "1"
 serde_bytes = "0.11"

e2e-tests/src/bin/timers.rs

@@ -1,4 +1,5 @@
-use ic_cdk::{query, update};
+use futures::{stream::FuturesUnordered, StreamExt};
+use ic_cdk::{api::canister_self, call::Call, futures::spawn, query, update};
 use ic_cdk_timers::{clear_timer, set_timer, set_timer_interval, TimerId};
 use std::{
     cell::{Cell, RefCell},
@@ -7,15 +8,15 @@ use std::{
 };
 
 thread_local! {
-    static EVENTS: RefCell<Vec<&'static str>> = RefCell::default();
+    static EVENTS: RefCell<Vec<String>> = RefCell::default();
     static LONG: Cell<TimerId> = Cell::default();
     static REPEATING: Cell<TimerId> = Cell::default();
 }
 
 static EXECUTED_TIMERS: AtomicU32 = AtomicU32::new(0);
 
 #[query]
-fn get_events() -> Vec<&'static str> {
+fn get_events() -> Vec<String> {
     EVENTS.with(|events| events.borrow().clone())
 }
 
@@ -94,13 +95,47 @@ fn stop_repeating() {
     REPEATING.with(|repeating| clear_timer(repeating.get()));
 }
 
-fn add_event(event: &'static str) {
-    EVENTS.with(|events| events.borrow_mut().push(event));
+fn add_event(event: &str) {
+    EVENTS.with(|events| events.borrow_mut().push(event.to_string()));
 }
 
 #[update]
 fn global_timer_set(timestamp: u64) -> u64 {
     ic_cdk::api::global_timer_set(timestamp)
 }
 
+#[update]
+fn add_event_method(name: &str) {
+    add_event(&format!("method {name}"));
+}
+
+#[update]
+fn async_await() {
+    set_timer(Duration::from_secs(1), async {
+        add_event("1");
+        Call::bounded_wait(canister_self(), "add_event_method")
+            .with_arg("outer")
+            .await
+            .unwrap();
+        add_event("2");
+        spawn(async {
+            Call::bounded_wait(canister_self(), "add_event_method")
+                .with_arg("spawned")
+                .await
+                .unwrap();
+        });
+        let futs = FuturesUnordered::new();
+        for _ in 0..3 {
+            futs.push(async move {
+                Call::bounded_wait(canister_self(), "add_event_method")
+                    .with_arg("concurrent")
+                    .await
+                    .unwrap();
+            });
+        }
+        futs.collect::<()>().await;
+    });
+    add_event("0")
+}
+
 fn main() {}

e2e-tests/tests/timers.rs

@@ -19,7 +19,6 @@ fn test_timers() {
     advance_seconds(&pic, 5);
     update::<_, ()>(&pic, canister_id, "cancel_long", ()).expect("Failed to call cancel_long");
     advance_seconds(&pic, 5);
-
     update::<_, ()>(&pic, canister_id, "start_repeating", ())
         .expect("Failed to call start_repeating");
     advance_seconds(&pic, 3);
@@ -122,3 +121,35 @@ fn test_set_global_timers() {
         update::<(u64,), (u64,)>(&pic, canister_id, "global_timer_set", (0,)).unwrap();
     assert!(previous.abs_diff(t2) < 2); // time error no more than 1 nanosecond
 }
+
+#[test]
+fn test_async_timers() {
+    let wasm = cargo_build_canister("timers");
+    let pic = pic_base().build();
+
+    let canister_id = pic.create_canister();
+    pic.add_cycles(canister_id, 2_000_000_000_000);
+    pic.install_canister(canister_id, wasm, vec![], None);
+
+    update::<(), ()>(&pic, canister_id, "async_await", ()).unwrap();
+    advance_seconds(&pic, 5);
+
+    let (events,): (Vec<String>,) =
+        query_candid(&pic, canister_id, "get_events", ()).expect("Failed to call get_events");
+    assert_eq!(events.len(), 8);
+    assert_eq!(events[..4], ["0", "1", "method outer", "2",]);
+    assert_eq!(
+        events[4..]
+            .iter()
+            .filter(|e| *e == "method spawned")
+            .count(),
+        1
+    );
+    assert_eq!(
+        events[4..]
+            .iter()
+            .filter(|e| *e == "method concurrent")
+            .count(),
+        3
+    );
+}

ic-cdk-timers/CHANGELOG.md

@@ -6,7 +6,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [unreleased]
 
-- Timer bodies have been changed from `FnOnce`/`FnMut` to `Future`/`AsyncFnMut`, so `spawn` is no longer required to enter an async context from a timer. For `set_timer`, `|| {}` should be changed to `async {}`, and for `set_timer_interval`, `|| {}` should be changed to `async || {}`.
+- `ic-cdk-timers` no longer has a dependency on `ic-cdk` and no longer needs to be upgraded when `ic-cdk` is upgraded.
+- Breaking: Timer bodies have been changed from `FnOnce`/`FnMut` to `Future`/`AsyncFnMut`, so `spawn` is no longer required to enter an async context from a timer. For `set_timer`, `|| {}` should be changed to `async {}`, and for `set_timer_interval`, `|| {}` should be changed to `async || {}`.
+  - If you have any immediate `spawn` calls, you can remove them and run the async code directly. (You do not have to.)
 
 ## [0.12.2] - 2025-06-25
 

ic-cdk-timers/Cargo.toml

@@ -10,23 +10,17 @@ description = "Timers library for the Rust CDK."
 homepage = "https://docs.rs/ic-cdk"
 documentation = "https://docs.rs/ic-cdk-timers"
 readme = "README.md"
-categories = [
-    "api-bindings",
-    "data-structures",
-    "no-std",
-    "development-tools::ffi",
-]
+categories = ["api-bindings", "data-structures", "no-std", "development-tools::ffi"]
 keywords = ["internet-computer", "dfinity", "canister", "cdk"]
 include = ["src", "Cargo.toml", "LICENSE", "README.md"]
 
 [dependencies]
-candid.workspace = true
 ic0.workspace = true
-ic-cdk.workspace = true
-serde.workspace = true
-serde_bytes.workspace = true
+ic-cdk-executor.workspace = true
 slotmap.workspace = true
-futures.workspace = true
+
+[dev-dependencies]
+ic-cdk.workspace = true
 
 [package.metadata.docs.rs]
 default-target = "wasm32-unknown-unknown"