Feature/expose validator cosmos address (nymtech#1404)

* Move coconut validator api req out of coconut interface

and expose a new cosmos-address endpoint

* Finish cosmos address endpoint

* Guard under coconut feature gateway & validator-api code

* Update CHANGELOG

CHANGELOG.md

@@ -22,6 +22,7 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 - network-statistics: a new mixnet service that aggregates and exposes anonymized data about mixnet services ([#1328])
 - wallet: when simulating gas costs, an automatic adjustment is being used ([#1388]).
 - mixnode: Added basic mixnode hardware reporting to the HTTP API ([#1308]).
+- validator-api: endpoint, in coconut mode, for returning the validator-api cosmos address ([#1404]).
 
 ### Fixed
 
@@ -57,6 +58,7 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 [#1376]: https://github.com/nymtech/nym/pull/1376
 [#1388]: https://github.com/nymtech/nym/pull/1388
 [#1393]: https://github.com/nymtech/nym/pull/1393
+[#1404]: https://github.com/nymtech/nym/pull/1404
 
 ## [nym-contracts-v1.0.1](https://github.com/nymtech/nym/tree/nym-contracts-v1.0.1) (2022-06-22)
 

common/client-libs/validator-client/Cargo.toml

@@ -27,7 +27,7 @@ futures = "0.3"
 
 coconut-interface = { path = "../../coconut-interface" }
 network-defaults = { path = "../../network-defaults" }
-validator-api-requests = { path = "../../../validator-api/validator-api-requests" }
+validator-api-requests = { path = "../../../validator-api/validator-api-requests", features = ["coconut"] }
 
 # required for nymd-client
 # at some point it might be possible to make it wasm-compatible

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

@@ -2,13 +2,13 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::{validator_api, ValidatorClientError};
-use coconut_interface::{
+use mixnet_contract_common::{GatewayBond, IdentityKeyRef, MixNodeBond};
+use url::Url;
+use validator_api_requests::coconut::{
     BlindSignRequestBody, BlindedSignatureResponse, ExecuteReleaseFundsRequestBody,
     ProposeReleaseFundsRequestBody, ProposeReleaseFundsResponse, VerificationKeyResponse,
     VerifyCredentialBody, VerifyCredentialResponse,
 };
-use mixnet_contract_common::{GatewayBond, IdentityKeyRef, MixNodeBond};
-use url::Url;
 
 use validator_api_requests::models::{
     CoreNodeStatusResponse, MixnodeStatusResponse, RewardEstimationResponse,

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

@@ -3,15 +3,15 @@
 
 use crate::validator_api::error::ValidatorAPIError;
 use crate::validator_api::routes::{CORE_STATUS_COUNT, SINCE_ARG};
-use coconut_interface::{
-    BlindSignRequestBody, BlindedSignatureResponse, ExecuteReleaseFundsRequestBody,
-    ProposeReleaseFundsRequestBody, ProposeReleaseFundsResponse, VerificationKeyResponse,
-    VerifyCredentialBody, VerifyCredentialResponse,
-};
 use mixnet_contract_common::{GatewayBond, IdentityKeyRef, MixNodeBond};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use url::Url;
+use validator_api_requests::coconut::{
+    BlindSignRequestBody, BlindedSignatureResponse, CosmosAddressResponse,
+    ExecuteReleaseFundsRequestBody, ProposeReleaseFundsRequestBody, ProposeReleaseFundsResponse,
+    VerificationKeyResponse, VerifyCredentialBody, VerifyCredentialResponse,
+};
 use validator_api_requests::models::{
     CoreNodeStatusResponse, InclusionProbabilityResponse, MixNodeBondAnnotated,
     MixnodeStatusResponse, RewardEstimationResponse, StakeSaturationResponse, UptimeResponse,
@@ -376,6 +376,19 @@ impl Client {
         .await
     }
 
+    pub async fn get_cosmos_address(&self) -> Result<CosmosAddressResponse, ValidatorAPIError> {
+        self.query_validator_api(
+            &[
+                routes::API_VERSION,
+                routes::COCONUT_ROUTES,
+                routes::BANDWIDTH,
+                routes::COCONUT_COSMOS_ADDRESS,
+            ],
+            NO_PARAMS,
+        )
+        .await
+    }
+
     pub async fn verify_bandwidth_credential(
         &self,
         request_body: &VerifyCredentialBody,

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

@@ -17,6 +17,7 @@ pub const BANDWIDTH: &str = "bandwidth";
 pub const COCONUT_BLIND_SIGN: &str = "blind-sign";
 pub const COCONUT_PARTIAL_BANDWIDTH_CREDENTIAL: &str = "partial-bandwidth-credential";
 pub const COCONUT_VERIFICATION_KEY: &str = "verification-key";
+pub const COCONUT_COSMOS_ADDRESS: &str = "cosmos-address";
 pub const COCONUT_VERIFY_BANDWIDTH_CREDENTIAL: &str = "verify-bandwidth-credential";
 pub const COCONUT_PROPOSE_RELEASE_FUNDS: &str = "propose-release-funds";
 pub const COCONUT_EXECUTE_RELEASE_FUNDS: &str = "execute-release-funds";

common/coconut-interface/src/lib.rs

@@ -127,171 +127,6 @@ impl Bytable for Credential {
 
 impl Base58 for Credential {}
 
-#[derive(Serialize, Deserialize, Getters, CopyGetters)]
-pub struct VerifyCredentialBody {
-    #[getset(get = "pub")]
-    credential: Credential,
-    #[getset(get = "pub")]
-    proposal_id: u64,
-}
-
-impl VerifyCredentialBody {
-    pub fn new(credential: Credential, proposal_id: u64) -> VerifyCredentialBody {
-        VerifyCredentialBody {
-            credential,
-            proposal_id,
-        }
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct VerifyCredentialResponse {
-    pub verification_result: bool,
-}
-
-impl VerifyCredentialResponse {
-    pub fn new(verification_result: bool) -> Self {
-        VerifyCredentialResponse {
-            verification_result,
-        }
-    }
-}
-
-//  All strings are base58 encoded representations of structs
-#[derive(Clone, Serialize, Deserialize, Debug, Getters, CopyGetters)]
-pub struct BlindSignRequestBody {
-    #[getset(get = "pub")]
-    blind_sign_request: BlindSignRequest,
-    #[getset(get = "pub")]
-    tx_hash: String,
-    #[getset(get = "pub")]
-    signature: String,
-    public_attributes: Vec<String>,
-    #[getset(get = "pub")]
-    public_attributes_plain: Vec<String>,
-    #[getset(get = "pub")]
-    total_params: u32,
-}
-
-impl BlindSignRequestBody {
-    pub fn new(
-        blind_sign_request: &BlindSignRequest,
-        tx_hash: String,
-        signature: String,
-        public_attributes: &[Attribute],
-        public_attributes_plain: Vec<String>,
-        total_params: u32,
-    ) -> BlindSignRequestBody {
-        BlindSignRequestBody {
-            blind_sign_request: blind_sign_request.clone(),
-            tx_hash,
-            signature,
-            public_attributes: public_attributes
-                .iter()
-                .map(|attr| attr.to_bs58())
-                .collect(),
-            public_attributes_plain,
-            total_params,
-        }
-    }
-
-    pub fn public_attributes(&self) -> Vec<Attribute> {
-        self.public_attributes
-            .iter()
-            .map(|x| Attribute::try_from_bs58(x).unwrap())
-            .collect()
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct BlindedSignatureResponse {
-    pub remote_key: [u8; 32],
-    pub encrypted_signature: Vec<u8>,
-}
-
-impl BlindedSignatureResponse {
-    pub fn new(encrypted_signature: Vec<u8>, remote_key: [u8; 32]) -> BlindedSignatureResponse {
-        BlindedSignatureResponse {
-            encrypted_signature,
-            remote_key,
-        }
-    }
-
-    pub fn to_base58_string(&self) -> String {
-        bs58::encode(&self.to_bytes()).into_string()
-    }
-
-    pub fn from_base58_string<I: AsRef<[u8]>>(val: I) -> Result<Self, CoconutInterfaceError> {
-        let bytes = bs58::decode(val).into_vec()?;
-        Self::from_bytes(&bytes)
-    }
-
-    pub fn to_bytes(&self) -> Vec<u8> {
-        let mut bytes = self.remote_key.to_vec();
-        bytes.extend_from_slice(&self.encrypted_signature);
-        bytes
-    }
-
-    pub fn from_bytes(bytes: &[u8]) -> Result<Self, CoconutInterfaceError> {
-        if bytes.len() < 32 {
-            return Err(CoconutInterfaceError::InvalidByteLength(bytes.len(), 32));
-        }
-        let mut remote_key = [0u8; 32];
-        remote_key.copy_from_slice(&bytes[..32]);
-        let encrypted_signature = bytes[32..].to_vec();
-        Ok(BlindedSignatureResponse {
-            remote_key,
-            encrypted_signature,
-        })
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct VerificationKeyResponse {
-    pub key: VerificationKey,
-}
-
-impl VerificationKeyResponse {
-    pub fn new(key: VerificationKey) -> VerificationKeyResponse {
-        VerificationKeyResponse { key }
-    }
-}
-
-#[derive(Serialize, Deserialize, Getters, CopyGetters)]
-pub struct ProposeReleaseFundsRequestBody {
-    #[getset(get = "pub")]
-    credential: Credential,
-}
-
-impl ProposeReleaseFundsRequestBody {
-    pub fn new(credential: Credential) -> Self {
-        ProposeReleaseFundsRequestBody { credential }
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct ProposeReleaseFundsResponse {
-    pub proposal_id: u64,
-}
-
-impl ProposeReleaseFundsResponse {
-    pub fn new(proposal_id: u64) -> Self {
-        ProposeReleaseFundsResponse { proposal_id }
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, Getters, CopyGetters)]
-pub struct ExecuteReleaseFundsRequestBody {
-    #[getset(get = "pub")]
-    proposal_id: u64,
-}
-
-impl ExecuteReleaseFundsRequestBody {
-    pub fn new(proposal_id: u64) -> Self {
-        ExecuteReleaseFundsRequestBody { proposal_id }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

common/credentials/Cargo.toml

@@ -15,6 +15,7 @@ url = "2.2"
 coconut-interface = { path = "../coconut-interface" }
 crypto = { path = "../crypto", features = ["rand", "asymmetric", "symmetric", "hashing"] }
 network-defaults = { path = "../network-defaults" }
+validator-api-requests = { path = "../../validator-api/validator-api-requests" }
 validator-client = { path = "../client-libs/validator-client" }
 
 [dev-dependencies]

common/credentials/src/coconut/utils.rs

@@ -3,13 +3,13 @@
 
 use coconut_interface::{
     aggregate_signature_shares, aggregate_verification_keys, prove_bandwidth_credential, Attribute,
-    BlindSignRequestBody, BlindedSignature, Credential, Parameters, Signature, SignatureShare,
-    VerificationKey,
+    BlindedSignature, Credential, Parameters, Signature, SignatureShare, VerificationKey,
 };
 use crypto::asymmetric::encryption::PublicKey;
 use crypto::shared_key::recompute_shared_key;
 use crypto::symmetric::stream_cipher;
 use url::Url;
+use validator_api_requests::coconut::BlindSignRequestBody;
 
 use crate::coconut::bandwidth::{BandwidthVoucher, PRIVATE_ATTRIBUTES, PUBLIC_ATTRIBUTES};
 use crate::coconut::params::{

gateway/Cargo.toml

@@ -52,11 +52,12 @@ network-defaults = { path = "../common/network-defaults" }
 nymsphinx = { path = "../common/nymsphinx" }
 pemstore = { path = "../common/pemstore" }
 statistics-common = { path = "../common/statistics" }
+validator-api-requests = { path = "../validator-api/validator-api-requests" }
 validator-client = { path = "../common/client-libs/validator-client", features = ["nymd-client"] }
 version-checker = { path = "../common/version-checker" }
 
 [features]
-coconut = ["coconut-interface", "gateway-requests/coconut", "gateway-client/coconut", "credentials/coconut"]
+coconut = ["coconut-interface", "gateway-requests/coconut", "gateway-client/coconut", "credentials/coconut", "validator-api-requests/coconut"]
 eth = []
 
 [build-dependencies]

gateway/src/node/client_handling/websocket/connection_handler/authenticated.rs

@@ -223,7 +223,9 @@ where
             ));
         }
 
-        let req = coconut_interface::ProposeReleaseFundsRequestBody::new(credential.clone());
+        let req = validator_api_requests::coconut::ProposeReleaseFundsRequestBody::new(
+            credential.clone(),
+        );
         let proposal_id = self
             .inner
             .coconut_verifier
@@ -237,7 +239,10 @@ where
             .await?
             .proposal_id;
 
-        let req = coconut_interface::VerifyCredentialBody::new(credential.clone(), proposal_id);
+        let req = validator_api_requests::coconut::VerifyCredentialBody::new(
+            credential.clone(),
+            proposal_id,
+        );
         for client in self.inner.coconut_verifier.api_clients().iter().skip(1) {
             if !client
                 .verify_bandwidth_credential(&req)
@@ -248,7 +253,7 @@ where
             }
         }
 
-        let req = coconut_interface::ExecuteReleaseFundsRequestBody::new(proposal_id);
+        let req = validator_api_requests::coconut::ExecuteReleaseFundsRequestBody::new(proposal_id);
         self.inner
             .coconut_verifier
             .api_clients()

validator-api/Cargo.toml

@@ -70,7 +70,7 @@ console-subscriber = { version = "0.1.1", optional = true}
 cfg-if = "1.0"
 
 [features]
-coconut = ["coconut-interface", "credentials", "gateway-client/coconut", "credentials/coconut"]
+coconut = ["coconut-interface", "credentials", "gateway-client/coconut", "credentials/coconut", "validator-api-requests/coconut"]
 no-reward = []
 generate-ts = []
 

validator-api/src/coconut/client.rs

@@ -3,10 +3,11 @@
 
 use crate::coconut::error::Result;
 use multisig_contract_common::msg::ProposalResponse;
-use validator_client::nymd::{Fee, TxResponse};
+use validator_client::nymd::{AccountId, Fee, TxResponse};
 
 #[async_trait]
 pub trait Client {
+    async fn address(&self) -> AccountId;
     async fn get_tx(&self, tx_hash: &str) -> Result<TxResponse>;
     async fn get_proposal(&self, proposal_id: u64) -> Result<ProposalResponse>;
     async fn propose_release_funds(

validator-api/src/coconut/deposit.rs

@@ -5,10 +5,10 @@ use coconut_bandwidth_contract_common::events::{
     DEPOSITED_FUNDS_EVENT_TYPE, DEPOSIT_ENCRYPTION_KEY, DEPOSIT_IDENTITY_KEY, DEPOSIT_INFO,
     DEPOSIT_VALUE,
 };
-use coconut_interface::BlindSignRequestBody;
 use credentials::coconut::bandwidth::BandwidthVoucher;
 use crypto::asymmetric::encryption;
 use crypto::asymmetric::identity::{self, Signature};
+use validator_api_requests::coconut::BlindSignRequestBody;
 use validator_client::nymd::TxResponse;
 
 use super::error::{CoconutError, Result};