diff --git a/service/src/error.rs b/service/src/error.rs new file mode 100644 index 0000000..5ac7df1 --- /dev/null +++ b/service/src/error.rs @@ -0,0 +1,64 @@ +/* + * Copyright 2021 Fluence Labs Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +use thiserror::Error as ThisError; + +use crate::dto::DtoConversionError; +use fluence_keypair::error::DecodingError; +use trust_graph::{CertificateError, TrustError, TrustGraphError}; + +#[derive(ThisError, Debug)] +pub enum ServiceError { + #[error("peer id parse error: {0}")] + PeerIdParseError(String), + #[error("public key extraction from peer id failed: {0}")] + PublicKeyExtractionError(String), + #[error("{0}")] + PublicKeyDecodeError( + #[from] + #[source] + DecodingError, + ), + #[error("{0}")] + TGError( + #[from] + #[source] + TrustGraphError, + ), + #[error("{0}")] + CertError( + #[from] + #[source] + CertificateError, + ), + #[error("{0}")] + DtoError( + #[from] + #[source] + DtoConversionError, + ), + #[error("{0}")] + TrustError( + #[from] + #[source] + TrustError, + ), + #[error("you should use host peer.timestamp_sec to pass timestamp")] + InvalidTimestampTetraplet, + #[error("{0} can't be issued later than the current timestamp")] + InvalidTimestamp(String), + #[error("Root could add only by trust graph service owner")] + NotOwner, +} diff --git a/service/src/main.rs b/service/src/main.rs index d230698..060cc8e 100644 --- a/service/src/main.rs +++ b/service/src/main.rs @@ -7,12 +7,16 @@ use marine_rs_sdk::WasmLoggerBuilder; module_manifest!(); mod dto; +mod error; +mod misc; mod results; mod service_api; -mod service_impl; mod storage_impl; mod tests; +pub static TRUSTED_TIMESTAMP_SERVICE_ID: &str = "peer"; +pub static TRUSTED_TIMESTAMP_FUNCTION_NAME: &str = "timestamp_sec"; + pub fn main() { WasmLoggerBuilder::new() .with_log_level(log::LevelFilter::Trace) diff --git a/service/src/misc.rs b/service/src/misc.rs new file mode 100644 index 0000000..97f0ad0 --- /dev/null +++ b/service/src/misc.rs @@ -0,0 +1,72 @@ +/* + * Copyright 2021 Fluence Labs Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +use crate::error::ServiceError; +use crate::error::ServiceError::*; +use crate::storage_impl::{get_data, SQLiteStorage}; +use crate::{TRUSTED_TIMESTAMP_FUNCTION_NAME, TRUSTED_TIMESTAMP_SERVICE_ID}; +use fluence_keypair::PublicKey; +use libp2p_core::PeerId; +use marine_rs_sdk::CallParameters; +use parking_lot::MutexGuard; +use std::convert::TryFrom; +use std::str::FromStr; +use trust_graph::TrustGraph; + +/// Check timestamps are generated on the current host with builtin ("peer" "timestamp_sec") +pub(crate) fn check_timestamp_tetraplets( + call_parameters: &CallParameters, + arg_number: usize, +) -> Result<(), ServiceError> { + let tetraplets = call_parameters + .tetraplets + .get(arg_number) + .ok_or(InvalidTimestampTetraplet)?; + let tetraplet = tetraplets.get(0).ok_or(InvalidTimestampTetraplet)?; + (tetraplet.service_id == TRUSTED_TIMESTAMP_SERVICE_ID + && tetraplet.function_name == TRUSTED_TIMESTAMP_FUNCTION_NAME + && tetraplet.peer_pk == call_parameters.host_id) + .then(|| ()) + .ok_or(InvalidTimestampTetraplet) +} + +fn parse_peer_id(peer_id: String) -> Result { + libp2p_core::PeerId::from_str(&peer_id) + .map_err(|e| ServiceError::PeerIdParseError(format!("{:?}", e))) +} + +pub fn with_tg(func: F) -> T +where + F: FnOnce(MutexGuard>) -> T, +{ + let tg = get_data().lock(); + + func(tg) +} + +pub fn wrapped_try(func: F) -> T +where + F: FnOnce() -> T, +{ + func() +} + +pub fn extract_public_key(peer_id: String) -> Result { + PublicKey::try_from( + parse_peer_id(peer_id) + .map_err(|e| ServiceError::PublicKeyExtractionError(e.to_string()))?, + ) + .map_err(ServiceError::PublicKeyDecodeError) +} diff --git a/service/src/results.rs b/service/src/results.rs index fa1b61b..578ed70 100644 --- a/service/src/results.rs +++ b/service/src/results.rs @@ -1,5 +1,5 @@ use crate::dto::{Certificate, Revoke, Trust}; -use crate::service_impl::ServiceError; +use crate::error::ServiceError; use marine_rs_sdk::marine; #[marine] diff --git a/service/src/service_api.rs b/service/src/service_api.rs index fb7dcb2..40ee1e7 100644 --- a/service/src/service_api.rs +++ b/service/src/service_api.rs @@ -1,15 +1,16 @@ use crate::dto::{Certificate, Revoke, Trust}; +use crate::error::ServiceError; +use crate::misc::{check_timestamp_tetraplets, extract_public_key, with_tg, wrapped_try}; use crate::results::{ AddRootResult, AddTrustResult, AllCertsResult, GetRevokeBytesResult, GetTrustBytesResult, InsertResult, IssueRevocationResult, IssueTrustResult, RevokeResult, VerifyTrustResult, WeightResult, }; -use crate::service_impl::{ - add_root_impl, add_trust_impl, get_all_certs_impl, get_host_certs_impl, get_revoke_bytes_impl, - get_trust_bytes_impl, get_weight_impl, insert_cert_impl, insert_cert_impl_raw, - issue_revocation_impl, issue_trust_impl, revoke_impl, verify_trust_impl, ServiceError, -}; +use fluence_keypair::Signature; use marine_rs_sdk::{get_call_parameters, marine, CallParameters}; +use std::convert::{TryFrom, TryInto}; +use std::str::FromStr; +use std::time::Duration; use trust_graph::MAX_WEIGHT_FACTOR; #[marine] @@ -23,7 +24,12 @@ fn add_root(peer_id: String, weight_factor: u32) -> AddRootResult { let call_parameters: CallParameters = marine_rs_sdk::get_call_parameters(); let init_peer_id = call_parameters.init_peer_id; if call_parameters.service_creator_peer_id == init_peer_id { - add_root_impl(peer_id, weight_factor).into() + with_tg(|mut tg| { + let public_key = extract_public_key(peer_id)?; + tg.add_root_weight_factor(public_key, weight_factor)?; + Ok(()) + }) + .into() } else { return AddRootResult { success: false, @@ -36,44 +42,79 @@ fn add_root(peer_id: String, weight_factor: u32) -> AddRootResult { /// add a certificate in string representation to trust graph if it is valid /// see `trust_graph::Certificate` class for string encoding/decoding fn insert_cert_raw(certificate: String, timestamp_sec: u64) -> InsertResult { - insert_cert_impl_raw(certificate, timestamp_sec).into() + with_tg(|mut tg| { + let certificate = trust_graph::Certificate::from_str(&certificate)?; + let timestamp_sec = Duration::from_secs(timestamp_sec); + tg.add(certificate, timestamp_sec)?; + Ok(()) + }) + .into() } #[marine] /// add a certificate in JSON representation to trust graph if it is valid /// see `dto::Certificate` class for structure fn insert_cert(certificate: Certificate, timestamp_sec: u64) -> InsertResult { - insert_cert_impl(certificate, timestamp_sec).into() + with_tg(|mut tg| { + let timestamp_sec = Duration::from_secs(timestamp_sec); + tg.add( + trust_graph::Certificate::try_from(certificate)?, + timestamp_sec, + )?; + Ok(()) + }) + .into() } #[marine] fn get_all_certs(issued_for: String, timestamp_sec: u64) -> AllCertsResult { - get_all_certs_impl(issued_for, timestamp_sec).into() + with_tg(|mut tg| { + check_timestamp_tetraplets(&marine_rs_sdk::get_call_parameters(), 1)?; + let public_key = extract_public_key(issued_for)?; + let certs = tg.get_all_certs(public_key, Duration::from_secs(timestamp_sec))?; + Ok(certs.into_iter().map(|c| c.into()).collect()) + }) + .into() } #[marine] fn get_host_certs(timestamp_sec: u64) -> AllCertsResult { - get_host_certs_impl(timestamp_sec).into() + with_tg(|mut tg| { + let cp = marine_rs_sdk::get_call_parameters(); + check_timestamp_tetraplets(&cp, 0)?; + let public_key = extract_public_key(cp.host_id)?; + let certs = tg.get_all_certs(public_key, Duration::from_secs(timestamp_sec))?; + Ok(certs.into_iter().map(|c| c.into()).collect()) + }) + .into() } #[marine] fn get_host_certs_from(issuer: String, timestamp_sec: u64) -> AllCertsResult { - let host_id = get_call_parameters().host_id; - get_all_certs_impl(host_id, timestamp_sec) - .map(|certs| { - certs - .into_iter() - .filter(|cert| cert.chain.iter().any(|t| t.issued_for == issuer)) - .collect() - }) - .into() + with_tg(|mut tg| { + let cp = get_call_parameters(); + check_timestamp_tetraplets(&cp, 1)?; + let public_key = extract_public_key(cp.host_id)?; + let certs = tg.get_all_certs(public_key, Duration::from_secs(timestamp_sec))?; + Ok(certs + .into_iter() + .map(|c| c.into()) + .filter(|cert: &Certificate| cert.chain.iter().any(|t| t.issued_for == issuer)) + .collect()) + }) + .into() } #[marine] fn get_weight(peer_id: String, timestamp_sec: u64) -> WeightResult { - get_weight_impl(peer_id.clone(), timestamp_sec) - .map(|w| (w, peer_id)) - .into() + with_tg(|mut tg| { + check_timestamp_tetraplets(&marine_rs_sdk::get_call_parameters(), 1)?; + let public_key = extract_public_key(peer_id.clone())?; + let weight = tg.weight(public_key, Duration::from_secs(timestamp_sec))?; + Ok(weight) + }) + .map(|w| (w, peer_id)) + .into() } #[marine] @@ -82,7 +123,16 @@ fn get_trust_bytes( expires_at_sec: u64, issued_at_sec: u64, ) -> GetTrustBytesResult { - get_trust_bytes_impl(issued_for_peer_id, expires_at_sec, issued_at_sec).into() + wrapped_try(|| { + let public_key = extract_public_key(issued_for_peer_id)?; + + Ok(trust_graph::Trust::signature_bytes( + &public_key, + Duration::from_secs(expires_at_sec), + Duration::from_secs(issued_at_sec), + )) + }) + .into() } #[marine] @@ -92,28 +142,67 @@ fn issue_trust( issued_at_sec: u64, trust_bytes: Vec, ) -> IssueTrustResult { - issue_trust_impl( - issued_for_peer_id, - expires_at_sec, - issued_at_sec, - trust_bytes, - ) + wrapped_try(|| { + let public_key = extract_public_key(issued_for_peer_id)?; + let expires_at_sec = Duration::from_secs(expires_at_sec); + let issued_at_sec = Duration::from_secs(issued_at_sec); + let signature = Signature::from_bytes(public_key.get_key_format(), trust_bytes); + Ok(Trust::from(trust_graph::Trust::new( + public_key, + expires_at_sec, + issued_at_sec, + signature, + ))) + }) .into() } #[marine] fn verify_trust(trust: Trust, issuer_peer_id: String, timestamp_sec: u64) -> VerifyTrustResult { - verify_trust_impl(trust, issuer_peer_id, timestamp_sec).into() + wrapped_try(|| { + check_timestamp_tetraplets(&marine_rs_sdk::get_call_parameters(), 2)?; + let public_key = extract_public_key(issuer_peer_id)?; + trust_graph::Trust::verify( + &trust.try_into()?, + &public_key, + Duration::from_secs(timestamp_sec), + )?; + + Ok(()) + }) + .into() } #[marine] fn add_trust(trust: Trust, issuer_peer_id: String, timestamp_sec: u64) -> AddTrustResult { - add_trust_impl(trust, issuer_peer_id, timestamp_sec).into() + with_tg(|mut tg| { + let public_key = extract_public_key(issuer_peer_id)?; + check_timestamp_tetraplets(&marine_rs_sdk::get_call_parameters(), 2)?; + + if trust.issued_at > timestamp_sec { + return Err(ServiceError::InvalidTimestamp("Trust".to_string())); + } + + tg.add_trust( + &trust.try_into()?, + public_key, + Duration::from_secs(timestamp_sec), + ) + .map_err(ServiceError::TGError) + }) + .into() } #[marine] fn get_revoke_bytes(revoked_peer_id: String, revoked_at: u64) -> GetRevokeBytesResult { - get_revoke_bytes_impl(revoked_peer_id, revoked_at).into() + wrapped_try(|| { + let public_key = extract_public_key(revoked_peer_id)?; + Ok(trust_graph::Revoke::signature_bytes( + &public_key, + Duration::from_secs(revoked_at), + )) + }) + .into() } #[marine] @@ -123,16 +212,27 @@ fn issue_revocation( revoked_at_sec: u64, signature_bytes: Vec, ) -> IssueRevocationResult { - issue_revocation_impl( - revoked_peer_id, - revoked_by_peer_id, - revoked_at_sec, - signature_bytes, - ) + wrapped_try(|| { + let revoked_pk = extract_public_key(revoked_peer_id)?; + let revoked_by_pk = extract_public_key(revoked_by_peer_id)?; + + let revoked_at = Duration::from_secs(revoked_at_sec); + let signature = Signature::from_bytes(revoked_by_pk.get_key_format(), signature_bytes); + Ok(trust_graph::Revoke::new(revoked_pk, revoked_by_pk, revoked_at, signature).into()) + }) .into() } #[marine] fn revoke(revoke: Revoke, timestamp_sec: u64) -> RevokeResult { - revoke_impl(revoke, timestamp_sec).into() + with_tg(|mut tg| { + check_timestamp_tetraplets(&marine_rs_sdk::get_call_parameters(), 1)?; + + if revoke.revoked_at > timestamp_sec { + return Err(ServiceError::InvalidTimestamp("Revoke".to_string())); + } + + tg.revoke(revoke.try_into()?).map_err(ServiceError::TGError) + }) + .into() } diff --git a/service/src/service_impl.rs b/service/src/service_impl.rs deleted file mode 100644 index 9093baf..0000000 --- a/service/src/service_impl.rs +++ /dev/null @@ -1,255 +0,0 @@ -use crate::dto::{Certificate, DtoConversionError, Revoke, Trust}; -use crate::service_impl::ServiceError::InvalidTimestampTetraplet; -use crate::storage_impl::get_data; -use fluence_keypair::error::DecodingError; -use fluence_keypair::{PublicKey, Signature}; -use libp2p_core::PeerId; -use marine_rs_sdk::CallParameters; -use std::convert::{Into, TryFrom, TryInto}; -use std::str::FromStr; -use std::time::Duration; -use thiserror::Error as ThisError; -use trust_graph::{CertificateError, TrustError, TrustGraphError}; - -pub static TRUSTED_TIMESTAMP_SERVICE_ID: &str = "peer"; -pub static TRUSTED_TIMESTAMP_FUNCTION_NAME: &str = "timestamp_sec"; - -/// Check timestamps are generated on the current host with builtin ("peer" "timestamp_sec") -pub(crate) fn check_timestamp_tetraplets( - call_parameters: &CallParameters, - arg_number: usize, -) -> Result<(), ServiceError> { - let tetraplets = call_parameters - .tetraplets - .get(arg_number) - .ok_or(InvalidTimestampTetraplet)?; - let tetraplet = tetraplets.get(0).ok_or(InvalidTimestampTetraplet)?; - (tetraplet.service_id == TRUSTED_TIMESTAMP_SERVICE_ID - && tetraplet.function_name == TRUSTED_TIMESTAMP_FUNCTION_NAME - && tetraplet.peer_pk == call_parameters.host_id) - .then(|| ()) - .ok_or(InvalidTimestampTetraplet) -} - -#[derive(ThisError, Debug)] -pub enum ServiceError { - #[error("peer id parse error: {0}")] - PeerIdParseError(String), - #[error("public key extraction from peer id failed: {0}")] - PublicKeyExtractionError(String), - #[error("{0}")] - PublicKeyDecodeError( - #[from] - #[source] - DecodingError, - ), - #[error("{0}")] - TGError( - #[from] - #[source] - TrustGraphError, - ), - #[error("{0}")] - CertError( - #[from] - #[source] - CertificateError, - ), - #[error("{0}")] - DtoError( - #[from] - #[source] - DtoConversionError, - ), - #[error("{0}")] - TrustError( - #[from] - #[source] - TrustError, - ), - #[error("you should use host peer.timestamp_sec to pass timestamp")] - InvalidTimestampTetraplet, - #[error("{0} can't be issued later than the current timestamp")] - InvalidTimestamp(String), - #[error("Root could add only by trust graph service owner")] - NotOwner, -} - -fn parse_peer_id(peer_id: String) -> Result { - libp2p_core::PeerId::from_str(&peer_id) - .map_err(|e| ServiceError::PeerIdParseError(format!("{:?}", e))) -} - -fn extract_public_key(peer_id: String) -> Result { - PublicKey::try_from( - parse_peer_id(peer_id) - .map_err(|e| ServiceError::PublicKeyExtractionError(e.to_string()))?, - ) - .map_err(ServiceError::PublicKeyDecodeError) -} - -pub fn get_weight_impl(peer_id: String, timestamp_sec: u64) -> Result { - check_timestamp_tetraplets(&marine_rs_sdk::get_call_parameters(), 1)?; - let mut tg = get_data().lock(); - let public_key = extract_public_key(peer_id)?; - let weight = tg.weight(public_key, Duration::from_secs(timestamp_sec))?; - Ok(weight) -} - -fn add_cert(certificate: trust_graph::Certificate, timestamp_sec: u64) -> Result<(), ServiceError> { - let timestamp_sec = Duration::from_secs(timestamp_sec); - let mut tg = get_data().lock(); - tg.add(certificate, timestamp_sec)?; - Ok(()) -} - -pub fn insert_cert_impl_raw(certificate: String, timestamp_sec: u64) -> Result<(), ServiceError> { - let certificate = trust_graph::Certificate::from_str(&certificate)?; - - add_cert(certificate, timestamp_sec)?; - Ok(()) -} - -pub fn get_all_certs_impl( - issued_for: String, - timestamp_sec: u64, -) -> Result, ServiceError> { - check_timestamp_tetraplets(&marine_rs_sdk::get_call_parameters(), 1)?; - get_certs_helper(issued_for, timestamp_sec) -} - -pub fn get_host_certs_impl(timestamp_sec: u64) -> Result, ServiceError> { - let cp = marine_rs_sdk::get_call_parameters(); - check_timestamp_tetraplets(&cp, 0)?; - get_certs_helper(cp.host_id, timestamp_sec) -} - -pub fn get_certs_helper( - issued_for: String, - timestamp_sec: u64, -) -> Result, ServiceError> { - let mut tg = get_data().lock(); - - let public_key = extract_public_key(issued_for)?; - let certs = tg.get_all_certs(public_key, Duration::from_secs(timestamp_sec))?; - Ok(certs.into_iter().map(|c| c.into()).collect()) -} - -pub fn insert_cert_impl(certificate: Certificate, timestamp_sec: u64) -> Result<(), ServiceError> { - let certificate: trust_graph::Certificate = certificate.try_into()?; - - add_cert(certificate, timestamp_sec)?; - Ok(()) -} - -pub fn add_root_impl(peer_id: String, weight: u32) -> Result<(), ServiceError> { - let mut tg = get_data().lock(); - let public_key = extract_public_key(peer_id)?; - tg.add_root_weight_factor(public_key, weight)?; - Ok(()) -} - -pub fn get_trust_bytes_impl( - peer_id: String, - expires_at_sec: u64, - issued_at_sec: u64, -) -> Result, ServiceError> { - let public_key = extract_public_key(peer_id)?; - Ok(trust_graph::Trust::signature_bytes( - &public_key, - Duration::from_secs(expires_at_sec), - Duration::from_secs(issued_at_sec), - )) -} - -pub fn issue_trust_impl( - peer_id: String, - expires_at_sec: u64, - issued_at_sec: u64, - trust_bytes: Vec, -) -> Result { - let public_key = extract_public_key(peer_id)?; - let expires_at_sec = Duration::from_secs(expires_at_sec); - let issued_at_sec = Duration::from_secs(issued_at_sec); - let signature = Signature::from_bytes(public_key.get_key_format(), trust_bytes); - Ok(Trust::from(trust_graph::Trust::new( - public_key, - expires_at_sec, - issued_at_sec, - signature, - ))) -} - -pub fn verify_trust_impl( - trust: Trust, - issuer_peer_id: String, - timestamp_sec: u64, -) -> Result<(), ServiceError> { - check_timestamp_tetraplets(&marine_rs_sdk::get_call_parameters(), 2)?; - let public_key = extract_public_key(issuer_peer_id)?; - trust_graph::Trust::verify( - &trust.try_into()?, - &public_key, - Duration::from_secs(timestamp_sec), - )?; - - Ok(()) -} - -pub fn add_trust_impl( - trust: Trust, - issuer_peer_id: String, - timestamp_sec: u64, -) -> Result { - let public_key = extract_public_key(issuer_peer_id)?; - check_timestamp_tetraplets(&marine_rs_sdk::get_call_parameters(), 2)?; - - if trust.issued_at > timestamp_sec { - return Err(ServiceError::InvalidTimestamp("Trust".to_string())); - } - - let mut tg = get_data().lock(); - tg.add_trust( - &trust.try_into()?, - public_key, - Duration::from_secs(timestamp_sec), - ) - .map_err(ServiceError::TGError) -} - -pub fn get_revoke_bytes_impl( - revoked_peer_id: String, - revoked_at: u64, -) -> Result, ServiceError> { - let public_key = extract_public_key(revoked_peer_id)?; - Ok(trust_graph::Revoke::signature_bytes( - &public_key, - Duration::from_secs(revoked_at), - )) -} - -pub fn issue_revocation_impl( - revoked_peer_id: String, - revoked_by_peer_id: String, - revoked_at_sec: u64, - signature_bytes: Vec, -) -> Result { - let revoked_pk = extract_public_key(revoked_peer_id)?; - let revoked_by_pk = extract_public_key(revoked_by_peer_id)?; - - let revoked_at = Duration::from_secs(revoked_at_sec); - let signature = Signature::from_bytes(revoked_by_pk.get_key_format(), signature_bytes); - Ok(trust_graph::Revoke::new(revoked_pk, revoked_by_pk, revoked_at, signature).into()) -} - -pub fn revoke_impl(revoke: Revoke, timestamp_sec: u64) -> Result<(), ServiceError> { - check_timestamp_tetraplets(&marine_rs_sdk::get_call_parameters(), 1)?; - - if revoke.revoked_at > timestamp_sec { - return Err(ServiceError::InvalidTimestamp("Revoke".to_string())); - } - - let mut tg = get_data().lock(); - - tg.revoke(revoke.try_into()?).map_err(ServiceError::TGError) -} diff --git a/service/src/tests.rs b/service/src/tests.rs index f9909db..55d4fad 100644 --- a/service/src/tests.rs +++ b/service/src/tests.rs @@ -17,10 +17,9 @@ #[cfg(test)] mod service_tests { marine_rs_sdk_test::include_test_env!("/marine_test_env.rs"); - use crate::service_impl::{ - ServiceError, TRUSTED_TIMESTAMP_FUNCTION_NAME, TRUSTED_TIMESTAMP_SERVICE_ID, - }; + use crate::error::ServiceError; use crate::storage_impl::DB_PATH; + use crate::{TRUSTED_TIMESTAMP_FUNCTION_NAME, TRUSTED_TIMESTAMP_SERVICE_ID}; use fluence_keypair::KeyPair; use libp2p_core::PeerId; use marine_rs_sdk::{CallParameters, SecurityTetraplet}; @@ -780,7 +779,7 @@ mod service_tests { add_trust_checked(&mut trust_graph, auth.trust.clone(), auth.issuer, cur_time); } - let mut cp = get_correct_timestamp_cp_with_host_id( + let cp = get_correct_timestamp_cp_with_host_id( 0, key_pairs.last().unwrap().get_peer_id().to_base58(), ); @@ -799,7 +798,7 @@ mod service_tests { fn test_get_one_host_cert_from() { let mut trust_graph = ServiceInterface::new(); clear_env(); - let (key_pairs, mut trusts) = + let (key_pairs, trusts) = generate_trust_chain_with_len(&mut trust_graph, 5, HashMap::new()); let cur_time = current_time(); @@ -810,7 +809,7 @@ mod service_tests { add_trust_checked(&mut trust_graph, auth.trust.clone(), auth.issuer, cur_time); } - let mut cp = get_correct_timestamp_cp_with_host_id( + let cp = get_correct_timestamp_cp_with_host_id( 1, key_pairs.last().unwrap().get_peer_id().to_base58(), );