Merge remote-tracking branch 'origin/release/2024.13-magura' into rel…

…ease/2024.13-magura-vpn-fork

common/authenticator-requests/src/v3/conversion.rs

@@ -98,6 +98,16 @@ impl TryFrom<v3::response::AuthenticatorResponse> for v2::response::Authenticato
     }
 }
 
+impl From<v2::response::AuthenticatorResponse> for v3::response::AuthenticatorResponse {
+    fn from(value: v2::response::AuthenticatorResponse) -> Self {
+        Self {
+            protocol: value.protocol,
+            data: value.data.into(),
+            reply_to: value.reply_to,
+        }
+    }
+}
+
 impl TryFrom<v3::response::AuthenticatorResponseData> for v2::response::AuthenticatorResponseData {
     type Error = crate::Error;
 
@@ -129,6 +139,22 @@ impl TryFrom<v3::response::AuthenticatorResponseData> for v2::response::Authenti
     }
 }
 
+impl From<v2::response::AuthenticatorResponseData> for v3::response::AuthenticatorResponseData {
+    fn from(value: v2::response::AuthenticatorResponseData) -> Self {
+        match value {
+            v2::response::AuthenticatorResponseData::PendingRegistration(
+                pending_registration_response,
+            ) => Self::PendingRegistration(pending_registration_response.into()),
+            v2::response::AuthenticatorResponseData::Registered(registered_response) => {
+                Self::Registered(registered_response.into())
+            }
+            v2::response::AuthenticatorResponseData::RemainingBandwidth(
+                remaining_bandwidth_response,
+            ) => Self::RemainingBandwidth(remaining_bandwidth_response.into()),
+        }
+    }
+}
+
 impl From<v3::response::PendingRegistrationResponse> for v2::response::PendingRegistrationResponse {
     fn from(value: v3::response::PendingRegistrationResponse) -> Self {
         Self {
@@ -139,6 +165,16 @@ impl From<v3::response::PendingRegistrationResponse> for v2::response::PendingRe
     }
 }
 
+impl From<v2::response::PendingRegistrationResponse> for v3::response::PendingRegistrationResponse {
+    fn from(value: v2::response::PendingRegistrationResponse) -> Self {
+        Self {
+            request_id: value.request_id,
+            reply_to: value.reply_to,
+            reply: value.reply.into(),
+        }
+    }
+}
+
 impl From<v3::response::RegisteredResponse> for v2::response::RegisteredResponse {
     fn from(value: v3::response::RegisteredResponse) -> Self {
         Self {
@@ -149,6 +185,16 @@ impl From<v3::response::RegisteredResponse> for v2::response::RegisteredResponse
     }
 }
 
+impl From<v2::response::RegisteredResponse> for v3::response::RegisteredResponse {
+    fn from(value: v2::response::RegisteredResponse) -> Self {
+        Self {
+            request_id: value.request_id,
+            reply_to: value.reply_to,
+            reply: value.reply.into(),
+        }
+    }
+}
+
 impl From<v3::response::RemainingBandwidthResponse> for v2::response::RemainingBandwidthResponse {
     fn from(value: v3::response::RemainingBandwidthResponse) -> Self {
         Self {
@@ -159,6 +205,16 @@ impl From<v3::response::RemainingBandwidthResponse> for v2::response::RemainingB
     }
 }
 
+impl From<v2::response::RemainingBandwidthResponse> for v3::response::RemainingBandwidthResponse {
+    fn from(value: v2::response::RemainingBandwidthResponse) -> Self {
+        Self {
+            request_id: value.request_id,
+            reply_to: value.reply_to,
+            reply: value.reply.map(Into::into),
+        }
+    }
+}
+
 impl From<v3::registration::RegistrationData> for v2::registration::RegistrationData {
     fn from(value: v3::registration::RegistrationData) -> Self {
         Self {
@@ -169,6 +225,16 @@ impl From<v3::registration::RegistrationData> for v2::registration::Registration
     }
 }
 
+impl From<v2::registration::RegistrationData> for v3::registration::RegistrationData {
+    fn from(value: v2::registration::RegistrationData) -> Self {
+        Self {
+            nonce: value.nonce,
+            gateway_data: value.gateway_data.into(),
+            wg_port: value.wg_port,
+        }
+    }
+}
+
 impl From<v3::registration::RegistredData> for v2::registration::RegistredData {
     fn from(value: v3::registration::RegistredData) -> Self {
         Self {
@@ -179,10 +245,28 @@ impl From<v3::registration::RegistredData> for v2::registration::RegistredData {
     }
 }
 
+impl From<v2::registration::RegistredData> for v3::registration::RegistredData {
+    fn from(value: v2::registration::RegistredData) -> Self {
+        Self {
+            pub_key: value.pub_key,
+            private_ip: value.private_ip,
+            wg_port: value.wg_port,
+        }
+    }
+}
+
 impl From<v3::registration::RemainingBandwidthData> for v2::registration::RemainingBandwidthData {
     fn from(value: v3::registration::RemainingBandwidthData) -> Self {
         Self {
             available_bandwidth: value.available_bandwidth,
         }
     }
 }
+
+impl From<v2::registration::RemainingBandwidthData> for v3::registration::RemainingBandwidthData {
+    fn from(value: v2::registration::RemainingBandwidthData) -> Self {
+        Self {
+            available_bandwidth: value.available_bandwidth,
+        }
+    }
+}

common/wireguard/src/peer_controller.rs

@@ -7,8 +7,8 @@ use defguard_wireguard_rs::{
     WireguardInterfaceApi,
 };
 use futures::channel::oneshot;
-use nym_authenticator_requests::{
-    latest::registration::RemainingBandwidthData, v1::registration::BANDWIDTH_CAP_PER_DAY,
+use nym_authenticator_requests::latest::registration::{
+    RemainingBandwidthData, BANDWIDTH_CAP_PER_DAY,
 };
 use nym_credential_verification::{
     bandwidth_storage_manager::BandwidthStorageManager, BandwidthFlushingBehaviourConfig,
@@ -230,7 +230,7 @@ impl<St: Storage + Clone + 'static> PeerController<St> {
                 // host information not updated yet
                 return Ok(None);
             };
-            BANDWIDTH_CAP_PER_DAY.saturating_sub((peer.rx_bytes + peer.tx_bytes) as i64)
+            BANDWIDTH_CAP_PER_DAY.saturating_sub(peer.rx_bytes + peer.tx_bytes) as i64
         };
 
         Ok(Some(RemainingBandwidthData {

explorer/src/utils/index.ts

@@ -102,7 +102,6 @@ export const isLessThan = (a: number, b: number) => a < b;
  */
 
 export const isBalanceEnough = (fee: string, tx: string = '0', balance: string = '0') => {
-  console.log('balance', balance, fee, tx);
   try {
     return Big(balance).gte(Big(fee).plus(Big(tx)));
   } catch (e) {

nym-node-status-agent/Cargo.toml

@@ -4,7 +4,7 @@
 
 [package]
 name = "nym-node-status-agent"
-version = "0.1.4"
+version = "0.1.5"
 authors.workspace = true
 repository.workspace = true
 homepage.workspace = true

nym-node-status-agent/src/cli.rs

@@ -1,3 +1,4 @@
+use anyhow::bail;
 use clap::{Parser, Subcommand};
 use nym_bin_common::bin_info;
 use nym_common_models::ns_api::TestrunAssignment;
@@ -51,11 +52,13 @@ impl Args {
         let version = probe.version().await;
         tracing::info!("Probe version:\n{}", version);
 
-        let testrun = request_testrun(&server_address).await?;
+        if let Some(testrun) = request_testrun(&server_address).await? {
+            let log = probe.run_and_get_log(&Some(testrun.gateway_identity_key));
 
-        let log = probe.run_and_get_log(&Some(testrun.gateway_identity_key));
-
-        submit_results(&server_address, testrun.testrun_id, log).await?;
+            submit_results(&server_address, testrun.testrun_id, log).await?;
+        } else {
+            tracing::info!("No testruns available, exiting")
+        }
 
         Ok(())
     }
@@ -64,16 +67,26 @@ impl Args {
 const URL_BASE: &str = "internal/testruns";
 
 #[instrument(level = "debug", skip_all)]
-async fn request_testrun(server_addr: &str) -> anyhow::Result<TestrunAssignment> {
+async fn request_testrun(server_addr: &str) -> anyhow::Result<Option<TestrunAssignment>> {
     let target_url = format!("{}/{}", server_addr, URL_BASE);
     let client = reqwest::Client::new();
-    let res = client
-        .get(target_url)
-        .send()
-        .await
-        .and_then(|response| response.error_for_status())?;
-    res.json()
-        .await
+    let res = client.get(target_url).send().await?;
+    let status = res.status();
+    let response_text = res.text().await?;
+
+    if status.is_client_error() {
+        bail!("{}: {}", status, response_text);
+    } else if status.is_server_error() {
+        if matches!(status, reqwest::StatusCode::SERVICE_UNAVAILABLE)
+            && response_text.contains("No testruns available")
+        {
+            return Ok(None);
+        } else {
+            bail!("{}: {}", status, response_text);
+        }
+    }
+
+    serde_json::from_str(&response_text)
         .map(|testrun| {
             tracing::info!("Received testrun assignment: {:?}", testrun);
             testrun

nym-node-status-api/Cargo.toml

@@ -3,7 +3,7 @@
 
 [package]
 name = "nym-node-status-api"
-version = "0.1.5"
+version = "0.1.6"
 authors.workspace = true
 repository.workspace = true
 homepage.workspace = true

nym-node-status-api/src/http/api/mod.rs

@@ -1,10 +1,7 @@
 use anyhow::anyhow;
 use axum::{response::Redirect, Router};
 use tokio::net::ToSocketAddrs;
-use tower_http::{
-    cors::CorsLayer,
-    trace::{DefaultOnResponse, TraceLayer},
-};
+use tower_http::{cors::CorsLayer, trace::TraceLayer};
 use utoipa::OpenApi;
 use utoipa_swagger_ui::SwaggerUi;
 
@@ -61,10 +58,7 @@ impl RouterBuilder {
             // CORS layer needs to wrap other API layers
             .layer(setup_cors())
             // logger should be outermost layer
-            .layer(
-                TraceLayer::new_for_http()
-                    .on_response(DefaultOnResponse::new().level(tracing::Level::DEBUG)),
-            )
+            .layer(TraceLayer::new_for_http())
     }
 }
 

nym-node-status-api/src/http/api/testruns.rs

@@ -49,7 +49,8 @@ async fn request_testrun(State(state): State<AppState>) -> HttpResult<Json<Testr
                 );
                 Ok(Json(testrun))
             } else {
-                Err(HttpError::no_available_testruns())
+                tracing::debug!("No testruns available for agent");
+                Err(HttpError::no_testruns_available())
             }
         }
         Err(err) => Err(HttpError::internal_with_logging(err)),

nym-node-status-api/src/http/error.rs

@@ -27,9 +27,9 @@ impl HttpError {
         }
     }
 
-    pub(crate) fn no_available_testruns() -> Self {
+    pub(crate) fn no_testruns_available() -> Self {
         Self {
-            message: serde_json::json!({"message": "No available testruns"}).to_string(),
+            message: serde_json::json!({"message": "No testruns available"}).to_string(),
             status: axum::http::StatusCode::SERVICE_UNAVAILABLE,
         }
     }

nym-wallet/src/components/Bonding/modals/RedeemRewardsModal.tsx

@@ -4,35 +4,29 @@ import { ModalListItem } from 'src/components/Modals/ModalListItem';
 import { SimpleModal } from 'src/components/Modals/SimpleModal';
 import { ModalFee } from 'src/components/Modals/ModalFee';
 import { useGetFee } from 'src/hooks/useGetFee';
-import { simulateClaimOperatorReward, simulateVestingClaimOperatorReward } from 'src/requests';
 import { AppContext } from 'src/context';
 import { BalanceWarning } from 'src/components/FeeWarning';
 import { Box } from '@mui/material';
-import { TBondedMixnode } from 'src/requests/mixnodeDetails';
+import { TBondedNymNode } from 'src/requests/nymNodeDetails';
 
 export const RedeemRewardsModal = ({
   node,
   onConfirm,
   onError,
   onClose,
 }: {
-  node: TBondedMixnode;
+  node: TBondedNymNode;
   onConfirm: (fee?: FeeDetails) => Promise<void>;
   onError: (err: string) => void;
   onClose: () => void;
 }) => {
-  const { fee, getFee, isFeeLoading, feeError } = useGetFee();
+  const { fee, isFeeLoading, feeError } = useGetFee();
   const { userBalance } = useContext(AppContext);
 
   useEffect(() => {
     if (feeError) onError(feeError);
   }, [feeError]);
 
-  useEffect(() => {
-    if (node.proxy) getFee(simulateVestingClaimOperatorReward, {});
-    else getFee(simulateClaimOperatorReward, {});
-  }, []);
-
   const handleOnOK = async () => onConfirm(fee);
 
   return (

nym-wallet/src/pages/bonding/Bonding.tsx

@@ -292,7 +292,7 @@ export const Bonding = () => {
         />
       )}
 
-      {showModal === 'redeem' && bondedNode && isMixnode(bondedNode) && (
+      {showModal === 'redeem' && bondedNode && isNymNode(bondedNode) && (
         <RedeemRewardsModal
           node={bondedNode}
           onClose={() => setShowModal(undefined)}

nym-wallet/src/requests/actions.ts

@@ -7,7 +7,7 @@ import {
   NodeConfigUpdate,
   GatewayConfigUpdate,
 } from '@nymproject/types';
-import { TBondGatewayArgs, TBondGatewaySignatureArgs, TNodeConfigUpdateArgs } from '../types';
+import { TBondGatewayArgs, TBondGatewaySignatureArgs } from '../types';
 import { invokeWrapper } from './wrapper';
 
 export const bondGateway = async (args: TBondGatewayArgs) =>

nym-wallet/src/requests/rewards.ts

@@ -6,7 +6,7 @@ export const claimOperatorReward = async (fee?: Fee) =>
 
 export const claimDelegatorRewards = async (mixId: number, fee?: FeeDetails) =>
   invokeWrapper<TransactionExecuteResult[]>('claim_locked_and_unlocked_delegator_reward', {
-    mixId,
+    nodeId: mixId,
     fee: fee?.fee,
   });