#6868

Committed 12 Feb 2026 01:11PM UTC coverage: 48.237% (-0.1%) from 48.357%

Build # #6868

Build Type

push

Committed by

Commit Message

Merge pull request #6460 from oasisprotocol/kostko/feature/rust-2026-02-11

Run Details

5 of 8 new or added lines in 3 files covered. (62.5%)

43 existing lines in 14 files now uncovered.

4650 of 9640 relevant lines covered (48.24%)

1.11 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/runtime/src/host/mod.rs

//! Host interface.
use async_trait::async_trait;
use thiserror::Error;

use crate::{
    common::{crypto::signature::PublicKey, namespace::Namespace},
    enclave_rpc,
    protocol::Protocol,
    storage::mkvs::sync,
    types::{self, Body},
};

pub mod attestation;
pub mod bundle_manager;
pub mod log_manager;
pub mod volume_manager;

/// Errors.
#[derive(Error, Debug)]
pub enum Error {
    #[error("bad response from host")]
    BadResponse,

    #[error("{0}")]
    Host(#[from] types::Error),

    #[error("{0}")]
    Decode(#[from] cbor::DecodeError),
}

/// Transaction submission options.
#[derive(Clone, Default, Debug)]
pub struct SubmitTxOpts {
    /// Target runtime identifier. If not specified, own runtime identifier is used.
    pub runtime_id: Option<Namespace>,
    /// Whether the call should wait until the transaction is included in a block.
    pub wait: bool,
    /// Whether the response should include a proof of transaction being included in a block.
    pub prove: bool,
}

/// Transaction submission result.
#[derive(Clone, Default, Debug)]
pub struct TxResult {
    /// Transaction output.
    pub output: Vec<u8>,
    /// Round in which the transaction was executed.
    pub round: u64,
    /// Order of the transaction in the execution batch.
    pub batch_order: u32,
    /// Optional inclusion proof.
    pub proof: Option<sync::Proof>,
}

/// Interface to the (untrusted) host node.
#[async_trait]
pub trait Host: Send + Sync {
    /// Returns the identity of the host node.
    async fn identity(&self) -> Result<PublicKey, Error>;

    /// Submit a transaction.
    async fn submit_tx(&self, data: Vec<u8>, opts: SubmitTxOpts)
        -> Result<Option<TxResult>, Error>;

    /// Bundle manager interface.
    fn bundle_manager(&self) -> &dyn bundle_manager::BundleManager;

    /// Volume manager interface.
    fn volume_manager(&self) -> &dyn volume_manager::VolumeManager;

    /// Log manager interface.
    fn log_manager(&self) -> &dyn log_manager::LogManager;

    /// Attestation interface.
    fn attestation(&self) -> &dyn attestation::Attestation;
}

#[async_trait]
impl Host for Protocol {
    async fn identity(&self) -> Result<PublicKey, Error> {
        match self.call_host_async(Body::HostIdentityRequest {}).await? {
            Body::HostIdentityResponse { node_id } => Ok(node_id),
            _ => Err(Error::BadResponse),
        }
    }

    async fn submit_tx(
        &self,
        data: Vec<u8>,
        opts: SubmitTxOpts,
    ) -> Result<Option<TxResult>, Error> {
        match self
            .call_host_async(Body::HostSubmitTxRequest {
                runtime_id: opts.runtime_id.unwrap_or_else(|| self.get_runtime_id()),
                data,
                wait: opts.wait,
                prove: opts.prove,
            })
            .await?
        {
            Body::HostSubmitTxResponse {
                output,
                round,
                batch_order,
                proof,
            } => {
                if opts.wait {
                    Ok(Some(TxResult {
                        output,
                        round,
                        batch_order,
                        proof,
                    }))
                } else {
                    // If we didn't wait for inclusion then there is no result.
                    Ok(None)
                }
            }
            _ => Err(Error::BadResponse),
        }
    }

    fn bundle_manager(&self) -> &dyn bundle_manager::BundleManager {
        self
    }

    fn volume_manager(&self) -> &dyn volume_manager::VolumeManager {
        self
    }

    fn log_manager(&self) -> &dyn log_manager::LogManager {
        self
    }

    fn attestation(&self) -> &dyn attestation::Attestation {
        self
    }
}

/// Wrapper to call the host via local RPC.
pub(super) async fn host_rpc_call<Rq: cbor::Encode, Rs: cbor::Decode>(
    protocol: &Protocol,
    endpoint: &str,
    method: &str,
    args: Rq,
) -> Result<Rs, Error> {
    match protocol
        .call_host_async(Body::HostRPCCallRequest {
            endpoint: endpoint.to_string(),
            request_id: 0,
            request: cbor::to_vec(enclave_rpc::types::Request {
                method: method.to_string(),
                args: cbor::to_value(args),
            }),
            kind: enclave_rpc::types::Kind::LocalQuery,
            nodes: vec![],
        })
        .await?
    {
        Body::HostRPCCallResponse { response, .. } => Ok(cbor::from_slice(&response)?),
        _ => Err(Error::BadResponse),
    }
}

1	//! Host interface.
2	use async_trait::async_trait;
3	use thiserror::Error;
4
5	use crate::{
6	common::{crypto::signature::PublicKey, namespace::Namespace},
7	enclave_rpc,
8	protocol::Protocol,
9	storage::mkvs::sync,
10	types::{self, Body},
11	};
12
13	pub mod attestation;
14	pub mod bundle_manager;
15	pub mod log_manager;
16	pub mod volume_manager;
17
18	/// Errors.
19	#[derive(Error, Debug)]
20	pub enum Error {
21	#[error("bad response from host")]
22	BadResponse,
23
24	#[error("{0}")]
25	Host(#[from] types::Error),
26
27	#[error("{0}")]
28	Decode(#[from] cbor::DecodeError),
29	}
30
31	/// Transaction submission options.
32	#[derive(Clone, Default, Debug)]
33	pub struct SubmitTxOpts {
34	/// Target runtime identifier. If not specified, own runtime identifier is used.
35	pub runtime_id: Option<Namespace>,
36	/// Whether the call should wait until the transaction is included in a block.
37	pub wait: bool,
38	/// Whether the response should include a proof of transaction being included in a block.
39	pub prove: bool,
40	}
41
42	/// Transaction submission result.
43	#[derive(Clone, Default, Debug)]
44	pub struct TxResult {
45	/// Transaction output.
46	pub output: Vec<u8>,
47	/// Round in which the transaction was executed.
48	pub round: u64,
49	/// Order of the transaction in the execution batch.
50	pub batch_order: u32,
51	/// Optional inclusion proof.
52	pub proof: Option<sync::Proof>,
53	}
54
55	/// Interface to the (untrusted) host node.
56	#[async_trait]
57	pub trait Host: Send + Sync {
58	/// Returns the identity of the host node.
59	async fn identity(&self) -> Result<PublicKey, Error>;
60
61	/// Submit a transaction.
62	async fn submit_tx(&self, data: Vec<u8>, opts: SubmitTxOpts)
63	-> Result<Option<TxResult>, Error>;
64
65	/// Bundle manager interface.
66	fn bundle_manager(&self) -> &dyn bundle_manager::BundleManager;
67
68	/// Volume manager interface.
69	fn volume_manager(&self) -> &dyn volume_manager::VolumeManager;
70
71	/// Log manager interface.
72	fn log_manager(&self) -> &dyn log_manager::LogManager;
73
74	/// Attestation interface.
75	fn attestation(&self) -> &dyn attestation::Attestation;
76	}
77
78	#[async_trait]
79	impl Host for Protocol {
80	async fn identity(&self) -> Result<PublicKey, Error> {	×
81	match self.call_host_async(Body::HostIdentityRequest {}).await? {	×
82	Body::HostIdentityResponse { node_id } => Ok(node_id),	×
83	_ => Err(Error::BadResponse),	×
84	}
85	}
86
UNCOV 87	async fn submit_tx(	×
88	&self,
89	data: Vec<u8>,
90	opts: SubmitTxOpts,
91	) -> Result<Option<TxResult>, Error> {
92	match self	×
93	.call_host_async(Body::HostSubmitTxRequest {	×
94	runtime_id: opts.runtime_id.unwrap_or_else(\|\| self.get_runtime_id()),	×
95	data,	×
96	wait: opts.wait,	×
97	prove: opts.prove,	×
98	})
99	.await?	×
100	{
101	Body::HostSubmitTxResponse {	×
102	output,
103	round,
104	batch_order,
105	proof,
106	} => {
107	if opts.wait {	×
108	Ok(Some(TxResult {	×
109	output,	×
110	round,
111	batch_order,
112	proof,	×
113	}))
114	} else {
115	// If we didn't wait for inclusion then there is no result.
116	Ok(None)	×
117	}
118	}
119	_ => Err(Error::BadResponse),	×
120	}
121	}
122
123	fn bundle_manager(&self) -> &dyn bundle_manager::BundleManager {	×
124	self
125	}
126
127	fn volume_manager(&self) -> &dyn volume_manager::VolumeManager {	×
128	self
129	}
130
131	fn log_manager(&self) -> &dyn log_manager::LogManager {	×
132	self
133	}
134
135	fn attestation(&self) -> &dyn attestation::Attestation {	×
136	self
137	}
138	}
139
140	/// Wrapper to call the host via local RPC.
141	pub(super) async fn host_rpc_call<Rq: cbor::Encode, Rs: cbor::Decode>(	×
142	protocol: &Protocol,
143	endpoint: &str,
144	method: &str,
145	args: Rq,
146	) -> Result<Rs, Error> {
147	match protocol	×
148	.call_host_async(Body::HostRPCCallRequest {	×
149	endpoint: endpoint.to_string(),	×
150	request_id: 0,	×
151	request: cbor::to_vec(enclave_rpc::types::Request {	×
152	method: method.to_string(),	×
153	args: cbor::to_value(args),	×
154	}),
155	kind: enclave_rpc::types::Kind::LocalQuery,	×
156	nodes: vec![],	×
157	})
158	.await?	×
159	{
160	Body::HostRPCCallResponse { response, .. } => Ok(cbor::from_slice(&response)?),	×
161	_ => Err(Error::BadResponse),	×
162	}
163	}

oasisprotocol / oasis-core / #6868

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous