diff --git a/crates/librqbit/src/limits.rs b/crates/librqbit/src/limits.rs
index 8baccbf..4b151eb 100644
--- a/crates/librqbit/src/limits.rs
+++ b/crates/librqbit/src/limits.rs
@@ -3,29 +3,28 @@ use governor::DefaultDirectRateLimiter as RateLimiter;
 use governor::Quota;
 use serde::Deserialize;
 use serde::Serialize;
-use std::num::NonZero;
 use std::num::NonZeroU32;
 use std::sync::Arc;
 
 #[derive(Default, Serialize, Deserialize, Clone, Copy, Debug, PartialEq, Eq)]
 pub struct LimitsConfig {
-    pub upload_bps: Option<NonZero<u32>>,
-    pub download_bps: Option<NonZero<u32>>,
+    pub upload_bps: Option<NonZeroU32>,
+    pub download_bps: Option<NonZeroU32>,
 }
 
 struct Limit(ArcSwapOption<RateLimiter>);
 
 impl Limit {
-    fn new_inner(bps: Option<NonZero<u32>>) -> Option<Arc<RateLimiter>> {
+    fn new_inner(bps: Option<NonZeroU32>) -> Option<Arc<RateLimiter>> {
         let bps = bps?;
         Some(Arc::new(RateLimiter::direct(Quota::per_second(bps))))
     }
 
-    fn new(bps: Option<NonZero<u32>>) -> Self {
+    fn new(bps: Option<NonZeroU32>) -> Self {
         Self(ArcSwapOption::new(Self::new_inner(bps)))
     }
 
-    async fn acquire(&self, size: NonZero<u32>) -> anyhow::Result<()> {
+    async fn acquire(&self, size: NonZeroU32) -> anyhow::Result<()> {
         let lim = self.0.load().clone();
         if let Some(rl) = lim.as_ref() {
             rl.until_n_ready(size).await?;
@@ -33,7 +32,7 @@ impl Limit {
         Ok(())
     }
 
-    fn set(&self, limit: Option<NonZero<u32>>) {
+    fn set(&self, limit: Option<NonZeroU32>) {
         let new = Self::new_inner(limit);
         self.0.swap(new);
     }
@@ -52,15 +51,15 @@ impl Limits {
         }
     }
 
-    pub async fn prepare_for_upload(&self, len: NonZero<u32>) -> anyhow::Result<()> {
+    pub async fn prepare_for_upload(&self, len: NonZeroU32) -> anyhow::Result<()> {
         self.up.acquire(len).await
     }
 
-    pub async fn prepare_for_download(&self, len: NonZero<u32>) -> anyhow::Result<()> {
+    pub async fn prepare_for_download(&self, len: NonZeroU32) -> anyhow::Result<()> {
         self.down.acquire(len).await
     }
 
-    pub fn set_upload_bps(&self, bps: Option<NonZero<u32>>) {
+    pub fn set_upload_bps(&self, bps: Option<NonZeroU32>) {
         self.up.set(bps);
     }
 
diff --git a/crates/librqbit/src/torrent_state/live/mod.rs b/crates/librqbit/src/torrent_state/live/mod.rs
index 980455f..da9037b 100644
--- a/crates/librqbit/src/torrent_state/live/mod.rs
+++ b/crates/librqbit/src/torrent_state/live/mod.rs
@@ -46,7 +46,7 @@ pub mod stats;
 use std::{
     collections::{HashMap, HashSet},
     net::SocketAddr,
-    num::NonZero,
+    num::NonZeroU32,
     sync::{
         atomic::{AtomicBool, AtomicU64, Ordering},
         Arc,
@@ -418,12 +418,12 @@ impl TorrentStateLive {
     ) -> anyhow::Result<()> {
         while let Some((tx, ci)) = rx.recv().await {
             self.ratelimits
-                .prepare_for_upload(NonZero::new(ci.size).unwrap())
+                .prepare_for_upload(NonZeroU32::new(ci.size).unwrap())
                 .await?;
             if let Some(session) = self.torrent.session.upgrade() {
                 session
                     .ratelimits
-                    .prepare_for_upload(NonZero::new(ci.size).unwrap())
+                    .prepare_for_upload(NonZeroU32::new(ci.size).unwrap())
                     .await?;
             }
             let _ = tx.send(WriterRequest::ReadChunkRequest(ci));
@@ -1449,13 +1449,13 @@ impl PeerHandler {
 
                 self.state
                     .ratelimits
-                    .prepare_for_download(NonZero::new(request.length).unwrap())
+                    .prepare_for_download(NonZeroU32::new(request.length).unwrap())
                     .await?;
 
                 if let Some(session) = self.state.torrent().session.upgrade() {
                     session
                         .ratelimits
-                        .prepare_for_download(NonZero::new(request.length).unwrap())
+                        .prepare_for_download(NonZeroU32::new(request.length).unwrap())
                         .await?;
                 }