exposed nym-node related operations in the wallet backend

common/client-libs/validator-client/src/nym_api/mod.rs

@@ -11,7 +11,7 @@ use nym_api_requests::ecash::models::{
 };
 use nym_api_requests::ecash::VerificationKeyResponse;
 use nym_api_requests::legacy::LegacyGatewayBondWithId;
-use nym_api_requests::models::LegacyDescribedMixNode;
+use nym_api_requests::models::{LegacyDescribedMixNode, NodePerformanceResponse};
 pub use nym_api_requests::{
     ecash::{
         models::{
@@ -427,6 +427,14 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
+    async fn get_current_node_performance(
+        &self,
+        node_id: NodeId,
+    ) -> Result<NodePerformanceResponse, NymAPIError> {
+        self.get_json_from(format!("/v1/nym-nodes/performance/{node_id}"))
+            .await
+    }
+
     async fn get_mixnode_avg_uptime(&self, mix_id: NodeId) -> Result<UptimeResponse, NymAPIError> {
         self.get_json(
             &[

common/client-libs/validator-client/src/nym_api/routes.rs

@@ -38,6 +38,7 @@ pub mod ecash {
 pub const STATUS_ROUTES: &str = "status";
 pub const MIXNODE: &str = "mixnode";
 pub const GATEWAY: &str = "gateway";
+pub const NYM_NODES: &str = "nym-nodes";
 
 pub const CORE_STATUS_COUNT: &str = "core-status-count";
 pub const SINCE_ARG: &str = "since";
@@ -52,5 +53,6 @@ pub const STAKE_SATURATION: &str = "stake-saturation";
 pub const INCLUSION_CHANCE: &str = "inclusion-probability";
 pub const SUBMIT_GATEWAY: &str = "submit-gateway-monitoring-results";
 pub const SUBMIT_NODE: &str = "submit-node-monitoring-results";
+pub const PERFORMANCE: &str = "performance";
 
 pub const SERVICE_PROVIDERS: &str = "services";

nym-node/nym-node-requests/src/api/client.rs

@@ -2,7 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::api::v1::gateway::models::WebSockets;
-use crate::api::v1::node::models::{AuxiliaryDetails, NodeRoles, SignedHostInformation};
+use crate::api::v1::node::models::{
+    AuxiliaryDetails, NodeDescription, NodeRoles, SignedHostInformation,
+};
 use crate::api::ErrorResponse;
 use crate::routes;
 use async_trait::async_trait;
@@ -32,6 +34,11 @@ pub trait NymNodeApiClientExt: ApiClient {
             .await
     }
 
+    async fn get_description(&self) -> Result<NodeDescription, NymNodeApiClientError> {
+        self.get_json_from(routes::api::v1::description_absolute())
+            .await
+    }
+
     async fn get_build_information(
         &self,
     ) -> Result<BinaryBuildInformationOwned, NymNodeApiClientError> {

nym-wallet/src-tauri/Cargo.toml

@@ -52,6 +52,7 @@ zeroize = { version = "1.5", features = ["zeroize_derive", "serde"] }
 cosmwasm-std = "1.3.0"
 cosmrs = { git = "https://github.com/cosmos/cosmos-rust", rev = "4b1332e6d8258ac845cef71589c8d362a669675a" }
 
+nym-node-requests = { path = "../../nym-node/nym-node-requests" }
 nym-validator-client = { path = "../../common/client-libs/validator-client" }
 nym-crypto = { path = "../../common/crypto", features = ["asymmetric"] }
 nym-contracts-common = { path = "../../common/cosmwasm-smart-contracts/contracts-common" }

nym-wallet/src-tauri/src/error.rs

@@ -1,5 +1,6 @@
 use nym_contracts_common::signing::SigningAlgorithm;
 use nym_crypto::asymmetric::identity::Ed25519RecoveryError;
+use nym_node_requests::api::client::NymNodeApiClientError;
 use nym_types::error::TypesError;
 use nym_validator_client::nym_api::error::NymAPIError;
 use nym_validator_client::signing::direct_wallet::DirectSecp256k1HdWalletError;
@@ -12,17 +13,17 @@ use thiserror::Error;
 
 #[derive(Error, Debug)]
 pub enum BackendError {
-    #[error("{source}")]
+    #[error(transparent)]
     TypesError {
         #[from]
         source: TypesError,
     },
-    #[error("{source}")]
+    #[error(transparent)]
     Bip39Error {
         #[from]
         source: bip39::Error,
     },
-    #[error("{source}")]
+    #[error(transparent)]
     TendermintError {
         #[from]
         source: cosmrs::rpc::Error,
@@ -33,42 +34,47 @@ pub enum BackendError {
         #[source]
         source: NyxdError,
     },
-    #[error("{source}")]
+    #[error(transparent)]
     CosmwasmStd {
         #[from]
         source: cosmwasm_std::StdError,
     },
-    #[error("{source}")]
+    #[error(transparent)]
     ErrorReport {
         #[from]
         source: eyre::Report,
     },
-    #[error("{source}")]
+    #[error(transparent)]
     NymApiError {
         #[from]
         source: NymAPIError,
     },
-    #[error("{source}")]
+    #[error(transparent)]
+    NymNodeApiError {
+        #[from]
+        source: NymNodeApiClientError,
+    },
+    #[error(transparent)]
     IOError {
         #[from]
         source: io::Error,
     },
-    #[error("{source}")]
+    #[error(transparent)]
     SerdeJsonError {
         #[from]
         source: serde_json::Error,
     },
-    #[error("{source}")]
+    #[error(transparent)]
     MalformedUrlProvided {
         #[from]
         source: url::ParseError,
     },
-    #[error("{source}")]
+    #[error(transparent)]
     ReqwestError {
         #[from]
         source: reqwest::Error,
     },
-    #[error("{source}")]
+    #[error(transparent)]
     K256Error {
         #[from]
         source: k256::ecdsa::Error,

nym-wallet/src-tauri/src/main.rs

@@ -73,6 +73,14 @@ fn main() {
             mixnet::bond::get_number_of_mixnode_delegators,
             mixnet::bond::get_mix_node_description,
             mixnet::bond::get_mixnode_avg_uptime,
+            mixnet::bond::bond_nymnode,
+            mixnet::bond::unbond_nymnode,
+            mixnet::bond::nym_node_bond_details,
+            mixnet::bond::get_nym_node_description,
+            mixnet::bond::migrate_legacy_mixnode,
+            mixnet::bond::migrate_legacy_gateway,
+            mixnet::bond::update_nymnode_config,
+            mixnet::bond::get_nymnode_performance,
             mixnet::delegate::delegate_to_mixnode,
             mixnet::delegate::get_pending_delegator_rewards,
             mixnet::delegate::get_pending_delegation_events,
@@ -103,6 +111,7 @@ fn main() {
             state::save_config_to_files,
             utils::owns_gateway,
             utils::owns_mixnode,
+            utils::owns_nym_node,
             utils::get_env,
             utils::try_convert_pubkey_to_mix_id,
             utils::default_mixnode_cost_params,
@@ -188,6 +197,7 @@ fn main() {
             signatures::ed25519_signing_payload::generate_mixnode_bonding_msg_payload,
             signatures::ed25519_signing_payload::vesting_generate_mixnode_bonding_msg_payload,
             signatures::ed25519_signing_payload::generate_gateway_bonding_msg_payload,
+            signatures::ed25519_signing_payload::generate_nym_node_bonding_msg_payload,
             signatures::ed25519_signing_payload::vesting_generate_gateway_bonding_msg_payload,
             help::log::help_log_toggle_window,
             app::window::create_main_window,

nym-wallet/src-tauri/src/operations/helpers.rs

@@ -10,7 +10,8 @@ use nym_contracts_common::signing::{
 use nym_crypto::asymmetric::identity;
 use nym_mixnet_contract_common::{
     construct_legacy_mixnode_bonding_sign_payload, Gateway, GatewayBondingPayload, MixNode,
-    NodeCostParams, SignableGatewayBondingMsg, SignableLegacyMixNodeBondingMsg,
+    NodeCostParams, NymNode, NymNodeBondingPayload, SignableGatewayBondingMsg,
+    SignableLegacyMixNodeBondingMsg, SignableNymNodeBondingMsg,
 };
 use nym_validator_client::nyxd::contract_traits::MixnetQueryClient;
 use nym_validator_client::nyxd::error::NyxdError;
@@ -143,6 +144,52 @@ pub(crate) async fn verify_gateway_bonding_sign_payload<P: AddressAndNonceProvid
     Ok(())
 }
 
+pub(crate) async fn create_nym_node_bonding_sign_payload<P: AddressAndNonceProvider>(
+    client: &P,
+    nym_node: NymNode,
+    cost_params: NodeCostParams,
+    pledge: Coin,
+) -> Result<SignableNymNodeBondingMsg, BackendError> {
+    let payload = NymNodeBondingPayload::new(nym_node, cost_params);
+    let sender = client.cw_address();
+    let content = ContractMessageContent::new(sender, vec![pledge.into()], payload);
+    let nonce = client.get_signing_nonce().await?;
+
+    Ok(SignableMessage::new(nonce, content))
+}
+
+pub(crate) async fn verify_nym_node_bonding_sign_payload<P: AddressAndNonceProvider>(
+    client: &P,
+    nym_node: &NymNode,
+    cost_params: &NodeCostParams,
+    pledge: &Coin,
+    msg_signature: &MessageSignature,
+) -> Result<(), BackendError> {
+    let identity_key = identity::PublicKey::from_base58_string(&nym_node.identity_key)?;
+    let signature = identity::Signature::from_bytes(msg_signature.as_ref())?;
+
+    // recreate the plaintext
+    let msg = create_nym_node_bonding_sign_payload(
+        client,
+        nym_node.clone(),
+        cost_params.clone(),
+        pledge.clone(),
+    )
+    .await?;
+    let plaintext = msg.to_plaintext()?;
+
+    if !msg.algorithm.is_ed25519() {
+        return Err(BackendError::UnexpectedSigningAlgorithm {
+            received: msg.algorithm,
+            expected: SigningAlgorithm::Ed25519,
+        });
+    }
+
+    // TODO: possibly provide better error message if this check fails
+    identity_key.verify(plaintext, &signature)?;
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;