Attesteer RPC additions

cli/src/attesteer/commands/mod.rs

@@ -19,5 +19,5 @@ mod send_dcap_quote;
 mod send_ias_attestation;
 
 pub use self::{
-	send_dcap_quote::SendDCAPQuoteCmd, send_ias_attestation::SendIASAttestationReportCmd,
+	send_dcap_quote::SendDcapQuoteCmd, send_ias_attestation::SendIasAttestationReportCmd,
 };

cli/src/attesteer/commands/send_dcap_quote.rs

@@ -25,34 +25,33 @@ use std::fs::read_to_string;
 
 /// Forward DCAP quote for verification.
 #[derive(Debug, Clone, Parser)]
-pub struct SendDCAPQuoteCmd {
+pub struct SendDcapQuoteCmd {
 	/// Hex encoded DCAP quote filename.
 	quote: String,
 }
 
-impl SendDCAPQuoteCmd {
+impl SendDcapQuoteCmd {
 	pub fn run(&self, cli: &Cli) {
 		let direct_api = get_worker_api_direct(cli);
-		let hex_encoded_quote = read_to_string(&self.quote)
-			.map_err(|e| error!("Opening hex encoded DCAP quote file failed: {:#?}", e))
-			.unwrap();
+		let hex_encoded_quote = match read_to_string(&self.quote) {
+			Ok(hex_encoded_quote) => hex_encoded_quote,
+			Err(e) => panic!("Opening hex encoded DCAP quote file failed: {:#?}", e),
+		};
 
-		let rpc_method = "attesteer_callForwardDCAPQuote".to_owned();
+		let rpc_method = "attesteer_ForwardDcapQuote".to_owned();
 		let jsonrpc_call: String =
 			RpcRequest::compose_jsonrpc_call(rpc_method, vec![hex_encoded_quote]).unwrap();
 
 		let rpc_response_str = direct_api.get(&jsonrpc_call).unwrap();
 
 		// Decode RPC response.
-		let rpc_response: RpcResponse = serde_json::from_str(&rpc_response_str).ok().unwrap();
-		let rpc_return_value = RpcReturnValue::from_hex(&rpc_response.result)
-			// Replace with `inspect_err` once it's stable.
-			.map_err(|e| {
-				error!("Failed to decode RpcReturnValue: {:?}", e);
-				e
-			})
-			.ok()
-			.unwrap();
+		let Ok(rpc_response) = serde_json::from_str::<RpcResponse>(&rpc_response_str) else {
+			panic!("Can't parse RPC response: '{rpc_response_str}'");
+		};
+		let rpc_return_value = match RpcReturnValue::from_hex(&rpc_response.result) {
+			Ok(rpc_return_value) => rpc_return_value,
+			Err(e) => panic!("Failed to decode RpcReturnValue: {:?}", e),
+		};
 
 		match rpc_return_value.status {
 			DirectRequestStatus::Ok => println!("DCAP quote verification succeded."),

cli/src/attesteer/commands/send_ias_attestation.rs

@@ -19,43 +19,42 @@ use itc_rpc_client::direct_client::DirectApi;
 use itp_rpc::{RpcRequest, RpcResponse, RpcReturnValue};
 use itp_types::DirectRequestStatus;
 use itp_utils::FromHexPrefixed;
-use log::error;
+use log::*;
 use std::fs::read_to_string;
 
 use crate::{command_utils::get_worker_api_direct, Cli};
 
 /// Forward IAS attestation report for verification.
 #[derive(Debug, Clone, Parser)]
-pub struct SendIASAttestationReportCmd {
+pub struct SendIasAttestationReportCmd {
 	/// Hex encoded IAS attestation report filename.
 	report: String,
 }
 
-impl SendIASAttestationReportCmd {
+impl SendIasAttestationReportCmd {
 	pub fn run(&self, cli: &Cli) {
 		let direct_api = get_worker_api_direct(cli);
-		let hex_encoded_report = read_to_string(&self.report)
-			.map_err(|e| error!("Opening hex encoded IAS attestation report file failed: {:#?}", e))
-			.unwrap();
+		let hex_encoded_report = match read_to_string(&self.report) {
+			Ok(hex_encoded_report) => hex_encoded_report,
+			Err(e) => panic!("Opening hex encoded IAS attestation report file failed: {:#?}", e),
+		};
 
 		//let request = Request { shard, cyphertext: hex_encoded_quote.to_vec() };
 
-		let rpc_method = "attesteer_callForwardIASAttestationReport".to_owned();
+		let rpc_method = "attesteer_ForwardIasAttestationReport".to_owned();
 		let jsonrpc_call: String =
 			RpcRequest::compose_jsonrpc_call(rpc_method, vec![hex_encoded_report]).unwrap();
 
 		let rpc_response_str = direct_api.get(&jsonrpc_call).unwrap();
 
 		// Decode RPC response.
-		let rpc_response: RpcResponse = serde_json::from_str(&rpc_response_str).ok().unwrap();
-		let rpc_return_value = RpcReturnValue::from_hex(&rpc_response.result)
-			// Replace with `inspect_err` once it's stable.
-			.map_err(|e| {
-				error!("Failed to decode RpcReturnValue: {:?}", e);
-				e
-			})
-			.ok()
-			.unwrap();
+		let Ok(rpc_response) = serde_json::from_str::<RpcResponse>(&rpc_response_str) else {
+			panic!("Can't parse RPC response: '{rpc_response_str}'");
+		};
+		let rpc_return_value = match RpcReturnValue::from_hex(&rpc_response.result) {
+			Ok(rpc_return_value) => rpc_return_value,
+			Err(e) => panic!("Failed to decode RpcReturnValue: {:?}", e),
+		};
 
 		match rpc_return_value.status {
 			DirectRequestStatus::Ok => println!("IAS attestation report verification succeded."),

cli/src/attesteer/mod.rs

@@ -17,18 +17,18 @@
 
 use crate::Cli;
 
-use self::commands::{SendDCAPQuoteCmd, SendIASAttestationReportCmd};
+use self::commands::{SendDcapQuoteCmd, SendIasAttestationReportCmd};
 
 mod commands;
 
 /// Attesteer subcommands for the CLI.
 #[derive(Debug, clap::Subcommand)]
 pub enum AttesteerCommand {
 	/// Forward DCAP quote for verification.
-	SendDCAPQuote(SendDCAPQuoteCmd),
+	SendDCAPQuote(SendDcapQuoteCmd),
 
 	/// Forward IAS attestation report for verification.
-	SendIASAttestationReport(SendIASAttestationReportCmd),
+	SendIASAttestationReport(SendIasAttestationReportCmd),
 }
 
 impl AttesteerCommand {

enclave-runtime/src/rpc/worker_api_direct.rs

@@ -15,13 +15,17 @@
 
 */
 
-use crate::attestation::{
-	generate_dcap_ra_extrinsic_from_quote_internal,
-	generate_ias_ra_extrinsic_from_der_cert_internal,
+use crate::{
+	attestation::{
+		generate_dcap_ra_extrinsic_from_quote_internal,
+		generate_ias_ra_extrinsic_from_der_cert_internal,
+	},
+	utils::get_validator_accessor_from_solo_or_parachain,
 };
 use codec::Encode;
 use core::result::Result;
 use ita_sgx_runtime::Runtime;
+use itc_parentchain::light_client::{concurrent_access::ValidatorAccess, ExtrinsicSender};
 use itp_primitives_cache::{GetPrimitives, GLOBAL_PRIMITIVES_CACHE};
 use itp_rpc::RpcReturnValue;
 use itp_sgx_crypto::Rsa3072Seal;
@@ -149,7 +153,7 @@ where
 	});
 
 	// attesteer_forward_dcap_quote
-	let attesteer_forward_dcap_quote: &str = "attesteer_callForwardDCAPQuote";
+	let attesteer_forward_dcap_quote: &str = "attesteer_ForwardDcapQuote";
 	io.add_sync_method(attesteer_forward_dcap_quote, move |params: Params| {
 		let json_value = match forward_dcap_quote_inner(params) {
 			Ok(val) => RpcReturnValue {
@@ -165,8 +169,7 @@ where
 	});
 
 	// attesteer_forward_ias_attestation_report
-	let attesteer_forward_ias_attestation_report: &str =
-		"attesteer_callForwardIASAttestationReport";
+	let attesteer_forward_ias_attestation_report: &str = "attesteer_ForwardIasAttestationReport";
 	io.add_sync_method(attesteer_forward_ias_attestation_report, move |params: Params| {
 		let json_value = match attesteer_forward_ias_attestation_report_inner(params) {
 			Ok(val) => RpcReturnValue {
@@ -233,15 +236,26 @@ fn execute_getter_inner<G: ExecuteGetter>(
 fn forward_dcap_quote_inner(params: Params) -> Result<OpaqueExtrinsic, String> {
 	let hex_encoded_params = params.parse::<Vec<String>>().map_err(|e| format!("{:?}", e))?;
 
-	let request =
-		Request::from_hex(&hex_encoded_params[0].clone()).map_err(|e| format!("{:?}", e))?;
+	if hex_encoded_params.len() != 1 {
+		return Err(format!(
+			"Wrong number of arguments for IAS attestation report forwarding: {}, expected: {}",
+			hex_encoded_params.len(),
+			1
+		))
+	}
 
-	let encoded_quote_to_forward: Vec<u8> = request.cyphertext;
+	let encoded_quote_to_forward: Vec<u8> =
+		itp_utils::hex::decode_hex(&hex_encoded_params[0]).map_err(|e| format!("{:?}", e))?;
 
 	let url = String::new();
 	let ext = generate_dcap_ra_extrinsic_from_quote_internal(url, &encoded_quote_to_forward)
 		.map_err(|e| format!("{:?}", e))?;
 
+	let validator_access = get_validator_accessor_from_solo_or_parachain().unwrap();
+	validator_access
+		.execute_mut_on_validator(|v| v.send_extrinsics(vec![ext.clone()]))
+		.unwrap();
+
 	Ok(ext)
 }
 
@@ -250,15 +264,26 @@ fn attesteer_forward_ias_attestation_report_inner(
 ) -> Result<OpaqueExtrinsic, String> {
 	let hex_encoded_params = params.parse::<Vec<String>>().map_err(|e| format!("{:?}", e))?;
 
-	let request =
-		Request::from_hex(&hex_encoded_params[0].clone()).map_err(|e| format!("{:?}", e))?;
+	if hex_encoded_params.len() != 1 {
+		return Err(format!(
+			"Wrong number of arguments for IAS attestation report forwarding: {}, expected: {}",
+			hex_encoded_params.len(),
+			1
+		))
+	}
 
-	let ias_attestation_report: Vec<u8> = request.cyphertext;
+	let ias_attestation_report =
+		itp_utils::hex::decode_hex(&hex_encoded_params[0]).map_err(|e| format!("{:?}", e))?;
 
 	let url = String::new();
 	let ext = generate_ias_ra_extrinsic_from_der_cert_internal(url, &ias_attestation_report)
 		.map_err(|e| format!("{:?}", e))?;
 
+	let validator_access = get_validator_accessor_from_solo_or_parachain().unwrap();
+	validator_access
+		.execute_mut_on_validator(|v| v.send_extrinsics(vec![ext.clone()]))
+		.unwrap();
+
 	Ok(ext)
 }