working with transaction waiter

Cargo.toml

@@ -30,6 +30,5 @@ toml = "0.8"
 u256-literal = "1"
 url = "2"
 wasm-bindgen = "0.2"
-webauthn-authenticator-rs = { version = "0.4" }
 webauthn-rs-proto = "0.4"
 account-sdk = { path = "crates/account_sdk" }

crates/account_sdk/Cargo.toml

@@ -30,5 +30,4 @@ toml.workspace = true
 u256-literal.workspace = true
 url.workspace = true
 wasm-bindgen.workspace = true
-webauthn-authenticator-rs.workspace = true
 webauthn-rs-proto.workspace = true

crates/account_sdk/src/transaction_waiter.rs

@@ -1,15 +1,14 @@
 use std::future::Future;
 use std::pin::Pin;
 use std::task::{Context, Poll};
-use std::time::Duration;
+use std::time::{Duration, Instant};
 
 use futures::FutureExt;
 use starknet::core::types::{
     ExecutionResult, FieldElement, MaybePendingTransactionReceipt, PendingTransactionReceipt,
     StarknetError, TransactionFinalityStatus, TransactionReceipt,
 };
 use starknet::providers::{Provider, ProviderError};
-use tokio::time::{Instant, Interval};
 
 type GetReceiptResult = Result<MaybePendingTransactionReceipt, ProviderError>;
 type GetReceiptFuture<'a> = Pin<Box<dyn Future<Output = GetReceiptResult> + Send + 'a>>;
@@ -77,6 +76,31 @@ pub struct TransactionWaiter<'a, P: Provider> {
     started_at: Option<Instant>,
 }
 
+struct Interval {
+    last: Instant,
+    interval: Duration,
+}
+
+impl Interval {
+    fn new(interval: Duration) -> Self {
+        Self {
+            last: Instant::now(),
+            interval,
+        }
+    }
+
+    fn poll_tick(&mut self, _cx: &mut Context<'_>) -> Poll<()> {
+        if self.last.elapsed() > self.interval {
+            self.last = Instant::now();
+            Poll::Ready(())
+        } else {
+            std::thread::sleep(self.interval);
+            Poll::Pending
+        }
+    }
+
+}
+
 #[allow(dead_code)]
 impl<'a, P> TransactionWaiter<'a, P>
 where
@@ -94,17 +118,13 @@ where
             finality_status: None,
             receipt_request_fut: None,
             timeout: Self::DEFAULT_TIMEOUT,
-            interval: tokio::time::interval_at(
-                Instant::now() + Self::DEFAULT_INTERVAL,
-                Self::DEFAULT_INTERVAL,
-            ),
+            interval: Interval::new(Self::DEFAULT_INTERVAL),
         }
     }
 
     pub fn with_interval(self, milisecond: u64) -> Self {
-        let interval = Duration::from_millis(milisecond);
         Self {
-            interval: tokio::time::interval_at(Instant::now() + interval, interval),
+            interval: Interval::new(Duration::from_millis(milisecond)),
             ..self
         }
     }