Remove WireguardKeyProxy

2 files changed, 0 insertions, 122 deletions

diff --git a/mullvad-daemon/src/device.rs b/mullvad-daemon/src/device.rs
index 01bc6e2b8e..f015294a2d 100644
--- a/mullvad-daemon/src/device.rs
+++ b/mullvad-daemon/src/device.rs
@@ -791,7 +791,6 @@ fn should_retry_backoff<T>(result: &Result<T, RestError>) -> bool {
             if let RestError::ApiError(status, code) = error {
                 *status != rest::StatusCode::NOT_FOUND
                     && code != mullvad_rpc::INVALID_ACCOUNT
-                    && code != mullvad_rpc::KEY_LIMIT_REACHED
                     && code != mullvad_rpc::MAX_DEVICES_REACHED
                     && code != mullvad_rpc::PUBKEY_IN_USE
             } else {
diff --git a/mullvad-rpc/src/lib.rs b/mullvad-rpc/src/lib.rs
index 43c5f362e1..33b0371153 100644
--- a/mullvad-rpc/src/lib.rs
+++ b/mullvad-rpc/src/lib.rs
@@ -684,127 +684,6 @@ impl AppVersionProxy {
     }
 }
 
-/// Error code for when an account has too many keys. Returned when trying to push a new key.
-pub const KEY_LIMIT_REACHED: &str = "KEY_LIMIT_REACHED";
-#[derive(Clone)]
-pub struct WireguardKeyProxy {
-    handle: rest::MullvadRestHandle,
-}
-
-impl WireguardKeyProxy {
-    pub fn new(handle: rest::MullvadRestHandle) -> Self {
-        Self { handle }
-    }
-
-    pub fn push_wg_key(
-        &mut self,
-        account_token: AccountToken,
-        public_key: wireguard::PublicKey,
-        timeout: Option<std::time::Duration>,
-    ) -> impl Future<Output = Result<mullvad_types::wireguard::AssociatedAddresses, rest::Error>> + 'static
-    {
-        #[derive(serde::Serialize)]
-        struct PublishRequest {
-            pubkey: wireguard::PublicKey,
-        }
-
-        let service = self.handle.service.clone();
-        let body = PublishRequest { pubkey: public_key };
-
-        let request = self
-            .handle
-            .factory
-            .post_json(&"app/v1/wireguard-keys", &body);
-        async move {
-            let mut request = request?;
-            if let Some(timeout) = timeout {
-                request.set_timeout(timeout);
-            }
-            request.set_auth(Some(account_token))?;
-            let response = service.request(request).await?;
-            rest::deserialize_body(
-                rest::parse_rest_response(response, &[StatusCode::CREATED]).await?,
-            )
-            .await
-        }
-    }
-
-    pub async fn replace_wg_key(
-        &mut self,
-        account_token: AccountToken,
-        old: wireguard::PublicKey,
-        new: wireguard::PublicKey,
-    ) -> Result<mullvad_types::wireguard::AssociatedAddresses, rest::Error> {
-        #[derive(serde::Serialize)]
-        struct ReplacementRequest {
-            old: wireguard::PublicKey,
-            new: wireguard::PublicKey,
-        }
-
-        let service = self.handle.service.clone();
-        let body = ReplacementRequest { old, new };
-
-        let response = rest::send_json_request(
-            &self.handle.factory,
-            service,
-            &"app/v1/replace-wireguard-key",
-            Method::POST,
-            &body,
-            Some(account_token),
-            [StatusCode::CREATED, StatusCode::OK].as_slice(),
-        )
-        .await?;
-
-        rest::deserialize_body(response).await
-    }
-
-    pub async fn get_wireguard_key(
-        &mut self,
-        account_token: AccountToken,
-        key: &wireguard::PublicKey,
-    ) -> Result<mullvad_types::wireguard::AssociatedAddresses, rest::Error> {
-        let service = self.handle.service.clone();
-
-        let response = rest::send_request(
-            &self.handle.factory,
-            service,
-            &format!(
-                "app/v1/wireguard-keys/{}",
-                urlencoding::encode(&key.to_base64())
-            ),
-            Method::GET,
-            Some(account_token),
-            &[StatusCode::OK],
-        )
-        .await?;
-
-        rest::deserialize_body(response).await
-    }
-
-    pub fn remove_wireguard_key(
-        &mut self,
-        account_token: AccountToken,
-        key: wireguard::PublicKey,
-    ) -> impl Future<Output = Result<(), rest::Error>> {
-        let service = self.handle.service.clone();
-        let future = rest::send_request(
-            &self.handle.factory,
-            service,
-            &format!(
-                "app/v1/wireguard-keys/{}",
-                urlencoding::encode(&key.to_base64())
-            ),
-            Method::DELETE,
-            Some(account_token),
-            &[StatusCode::NO_CONTENT],
-        );
-        async move {
-            let _ = future.await?;
-            Ok(())
-        }
-    }
-}
-
 #[derive(Clone)]
 pub struct ApiProxy {
     handle: rest::MullvadRestHandle,