fluencelabs/aquavm
1
0
Fork 0
mirror of https://github.com/fluencelabs/aquavm synced 2024-12-04 15:20:16 +00:00
Code Issues Projects Releases Wiki Activity

feat(execution-engine,test-utils,interpreter-data,interpreter-cid)!: Rc into CID (#718)

Browse Source 
* Hide `Rc` inside `CID` type, making it cheap to clone.
* Introduce `CidRef` type that abstracts on `CID`'s inner type.

This change makes code cleaner, makes memory more optimal (single allocation vs two allocations) and makes it easier to change CID's internal representation from string to binary.
This commit is contained in:
Ivan Boldyrev 2023-10-16 17:35:42 +04:00 committed by GitHub
parent d2ad221597
commit c2108e0fa0
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
27 changed files with 137 additions and 126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
air/src/execution_step/errors/uncatchable_errors.rs
View File

@ -23,6 +23,7 @@ use crate::StreamMapKeyError;
use crate::ToErrorCode;
use air_interpreter_cid::CidCalculationError;
use air_interpreter_cid::CidRef;
use air_interpreter_data::ValueRef;
use air_trace_handler::GenerationCompactificationError;
use air_trace_handler::IntConversionError;
@ -33,6 +34,8 @@ use strum_macros::EnumDiscriminants;
use strum_macros::EnumIter;
use thiserror::Error as ThisError;
use std::rc::Rc;
/// Uncatchable errors arisen during AIR script execution. Uncatchable here means that these errors
/// couldn't be handled by a xor instruction and their error_code couldn't be used in a match
/// instruction. They are similar to JVM runtime errors and some of them could be caught only
@ -90,7 +93,7 @@ pub enum UncatchableError {
/// We consider now that every CID should present in the data;
/// and not having any CID is considered a non-catching error.
#[error("{0} for CID {1:?} not found")]
ValueForCidNotFound(&'static str, String),
ValueForCidNotFound(&'static str, Rc<CidRef>),
/// Errors occurred while insertion of a value inside stream that doesn't have corresponding generation.
#[error(

14
air/src/execution_step/execution_context/cid_state.rs
View File

@ -71,7 +71,7 @@ impl ExecutionCidState {
value: Rc<JValue>,
tetraplet: RcSecurityTetraplet,
argument_hash: Rc<str>,
) -> Result<Rc<CID<ServiceResultCidAggregate>>, UncatchableError> {
) -> Result<CID<ServiceResultCidAggregate>, UncatchableError> {
let value_cid = self.value_tracker.track_value(value)?;
let tetraplet_cid = self.tetraplet_tracker.track_value(tetraplet)?;
let service_result_agg = ServiceResultCidAggregate::new(value_cid, argument_hash, tetraplet_cid);
@ -84,7 +84,7 @@ impl ExecutionCidState {
pub(crate) fn track_canon_value(
&mut self,
canon_value: &ValueAggregate,
) -> Result<Rc<CID<CanonCidAggregate>>, UncatchableError> {
) -> Result<CID<CanonCidAggregate>, UncatchableError> {
let value_cid = self.value_tracker.track_value(canon_value.get_result().clone())?;
let tetraplet = self.tetraplet_tracker.track_value(canon_value.get_tetraplet())?;
@ -97,7 +97,7 @@ impl ExecutionCidState {
pub(crate) fn get_value_by_cid(&self, cid: &CID<JValue>) -> Result<Rc<JValue>, UncatchableError> {
self.value_tracker
.get(cid)
.ok_or_else(|| UncatchableError::ValueForCidNotFound("value", cid.clone().into()))
.ok_or_else(|| UncatchableError::ValueForCidNotFound("value", cid.get_inner()))
}
pub(crate) fn get_tetraplet_by_cid(
@ -106,7 +106,7 @@ impl ExecutionCidState {
) -> Result<RcSecurityTetraplet, UncatchableError> {
self.tetraplet_tracker
.get(cid)
.ok_or_else(|| UncatchableError::ValueForCidNotFound("tetraplet", cid.clone().into()))
.ok_or_else(|| UncatchableError::ValueForCidNotFound("tetraplet", cid.get_inner()))
}
pub(crate) fn get_canon_value_by_cid(
@ -116,7 +116,7 @@ impl ExecutionCidState {
let canon_aggregate = self
.canon_element_tracker
.get(cid)
.ok_or_else(|| UncatchableError::ValueForCidNotFound("canon aggregate", cid.clone().into()))?;
.ok_or_else(|| UncatchableError::ValueForCidNotFound("canon aggregate", cid.get_inner()))?;
let result = self.get_value_by_cid(&canon_aggregate.value)?;
let tetraplet = self.get_tetraplet_by_cid(&canon_aggregate.tetraplet)?;
@ -135,7 +135,7 @@ impl ExecutionCidState {
) -> Result<Rc<CanonResultCidAggregate>, UncatchableError> {
self.canon_result_tracker
.get(cid)
.ok_or_else(|| UncatchableError::ValueForCidNotFound("canon result aggregate", cid.clone().into()))
.ok_or_else(|| UncatchableError::ValueForCidNotFound("canon result aggregate", cid.get_inner()))
}
pub(crate) fn get_service_result_agg_by_cid(
@ -144,7 +144,7 @@ impl ExecutionCidState {
) -> Result<Rc<ServiceResultCidAggregate>, UncatchableError> {
self.service_result_agg_tracker
.get(cid)
.ok_or_else(|| UncatchableError::ValueForCidNotFound("service result aggregate", cid.clone().into()))
.ok_or_else(|| UncatchableError::ValueForCidNotFound("service result aggregate", cid.get_inner()))
}
pub(crate) fn resolve_service_info(

4
air/src/execution_step/instructions/call/call_result_setter.rs
View File

@ -65,9 +65,7 @@ pub(crate) fn populate_context_from_peer_service_result<'i>(
Ok(CallResult::executed_stream_stub(service_result_agg_cid))
}
CallOutputValue::None => {
let value_cid = value_to_json_cid(&*executed_result.result)
.map_err(UncatchableError::from)?
.into();
let value_cid = value_to_json_cid(&*executed_result.result).map_err(UncatchableError::from)?;
Ok(CallResult::executed_unused(value_cid))
}

9
air/src/execution_step/instructions/call/resolved_call.rs
View File

@ -29,6 +29,7 @@ use crate::JValue;
use crate::SecurityTetraplet;
use air_interpreter_cid::value_to_json_cid;
use air_interpreter_cid::CidRef;
use air_interpreter_data::CallResult;
use air_interpreter_interface::CallRequestParams;
use air_parser::ast;
@ -102,12 +103,8 @@ impl<'i> ResolvedCall<'i> {
CheckArgsResult::Ok(args) => Some(args),
CheckArgsResult::Joinable(_) => None,
};
let argument_hash: Option<Rc<str>> = checked_args.map(|args| {
value_to_json_cid(&args)
.expect("JSON serializer shouldn't fail")
.into_inner()
.into()
});
let argument_hash: Option<Rc<CidRef>> =
checked_args.map(|args| value_to_json_cid(&args).expect("serializer shouldn't fail").get_inner());
let state = self.prepare_current_executed_state(raw_call, argument_hash.as_ref(), exec_ctx, trace_ctx)?;

3
air/src/execution_step/instructions/canon.rs
View File

@ -34,7 +34,6 @@ use air_parser::AirPos;
use air_trace_handler::merger::MergerCanonResult;
use std::borrow::Cow;
use std::rc::Rc;
impl<'i> super::ExecutableInstruction<'i> for ast::Canon<'i> {
#[tracing::instrument(level = "debug", skip(exec_ctx, trace_ctx))]
@ -65,7 +64,7 @@ impl<'i> super::ExecutableInstruction<'i> for ast::Canon<'i> {
fn epilog_closure(canon_stream_name: &str) -> Box<CanonEpilogClosure<'_>> {
Box::new(
move |canon_stream: CanonStream,
canon_result_cid: Rc<CID<CanonResultCidAggregate>>,
canon_result_cid: CID<CanonResultCidAggregate>,
exec_ctx: &mut ExecutionCtx<'_>,
trace_ctx: &mut TraceHandler|
-> ExecutionResult<()> {

3
air/src/execution_step/instructions/canon_map.rs
View File

@ -35,7 +35,6 @@ use air_parser::AirPos;
use air_trace_handler::merger::MergerCanonResult;
use std::borrow::Cow;
use std::rc::Rc;
impl<'i> super::ExecutableInstruction<'i> for ast::CanonMap<'i> {
#[tracing::instrument(level = "debug", skip(exec_ctx, trace_ctx))]
@ -65,7 +64,7 @@ impl<'i> super::ExecutableInstruction<'i> for ast::CanonMap<'i> {
fn epilog_closure<'closure, 'name: 'closure>(canon_stream_map_name: &'name str) -> Box<CanonEpilogClosure<'closure>> {
Box::new(
move |canon_stream: CanonStream,
canon_result_cid: Rc<CID<CanonResultCidAggregate>>,
canon_result_cid: CID<CanonResultCidAggregate>,
exec_ctx: &mut ExecutionCtx<'_>,
trace_ctx: &mut TraceHandler|
-> ExecutionResult<()> {

2
air/src/execution_step/instructions/canon_stream_map_scalar.rs
View File

@ -68,7 +68,7 @@ impl<'i> super::ExecutableInstruction<'i> for ast::CanonStreamMapScalar<'i> {
fn epilog_closure<'closure, 'name: 'closure>(scalar_name: &'name str) -> Box<CanonEpilogClosure<'closure>> {
Box::new(
move |canon_stream: CanonStream,
canon_result_cid: Rc<CID<CanonResultCidAggregate>>,
canon_result_cid: CID<CanonResultCidAggregate>,
exec_ctx: &mut ExecutionCtx<'_>,
trace_ctx: &mut TraceHandler|
-> ExecutionResult<()> {

10
air/src/execution_step/instructions/canon_utils/mod.rs
View File

@ -27,9 +27,7 @@ use air_interpreter_data::CanonResultCidAggregate;
use air_parser::ast::ResolvableToPeerIdVariable;
use polyplets::SecurityTetraplet;
use std::rc::Rc;
pub(crate) type CanonEpilogClosure<'closure> = dyn Fn(CanonStream, Rc<CID<CanonResultCidAggregate>>, &mut ExecutionCtx<'_>, &mut TraceHandler) -> ExecutionResult<()>
pub(crate) type CanonEpilogClosure<'closure> = dyn Fn(CanonStream, CID<CanonResultCidAggregate>, &mut ExecutionCtx<'_>, &mut TraceHandler) -> ExecutionResult<()>
+ 'closure;
pub(crate) type CreateCanonStreamClosure<'closure> = dyn Fn(&mut ExecutionCtx<'_>, String) -> CanonStream + 'closure;
@ -78,7 +76,7 @@ pub(crate) fn handle_canon_request_sent_by(
pub(crate) fn handle_canon_executed(
peer_id_var: &ResolvableToPeerIdVariable<'_>,
epilog: &CanonEpilogClosure<'_>,
canon_result_cid: Rc<CID<CanonResultCidAggregate>>,
canon_result_cid: CID<CanonResultCidAggregate>,
exec_ctx: &mut ExecutionCtx<'_>,
trace_ctx: &mut TraceHandler,
) -> ExecutionResult<()> {
@ -143,7 +141,7 @@ fn create_canon_stream_for_first_time(
fn populate_seen_cid_context(
exec_ctx: &mut ExecutionCtx<'_>,
peer_id: &str,
canon_result_cid: &Rc<CID<CanonResultCidAggregate>>,
canon_result_cid: &CID<CanonResultCidAggregate>,
) {
exec_ctx.record_canon_cid(peer_id, canon_result_cid)
}
@ -151,7 +149,7 @@ fn populate_seen_cid_context(
fn populate_unseen_cid_context(
exec_ctx: &mut ExecutionCtx<'_>,
canon_stream: &CanonStream,
) -> ExecutionResult<Rc<CID<CanonResultCidAggregate>>> {
) -> ExecutionResult<CID<CanonResultCidAggregate>> {
let value_cids = canon_stream
.iter()
.map(|canon_value| exec_ctx.cid_state.track_canon_value(canon_value))

4
air/src/execution_step/value_types/canon_stream.rs
View File

@ -103,11 +103,11 @@ impl fmt::Display for CanonStream {
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct CanonStreamWithProvenance {
pub(crate) canon_stream: CanonStream,
pub(crate) cid: Rc<CID<CanonResultCidAggregate>>,
pub(crate) cid: CID<CanonResultCidAggregate>,
}
impl CanonStreamWithProvenance {
pub(crate) fn new(canon_stream: CanonStream, cid: Rc<CID<CanonResultCidAggregate>>) -> Self {
pub(crate) fn new(canon_stream: CanonStream, cid: CID<CanonResultCidAggregate>) -> Self {
Self { canon_stream, cid }
}
}

4
air/src/execution_step/value_types/canon_stream_map.rs
View File

@ -112,11 +112,11 @@ impl fmt::Display for CanonStreamMap<'_> {
#[derive(Debug, Clone)]
pub struct CanonStreamMapWithProvenance<'a> {
pub(crate) canon_stream_map: CanonStreamMap<'a>,
pub(crate) cid: Rc<CID<CanonResultCidAggregate>>,
pub(crate) cid: CID<CanonResultCidAggregate>,
}
impl<'a> CanonStreamMapWithProvenance<'a> {
pub(crate) fn new(canon_stream_map: CanonStreamMap<'a>, cid: Rc<CID<CanonResultCidAggregate>>) -> Self {
pub(crate) fn new(canon_stream_map: CanonStreamMap<'a>, cid: CID<CanonResultCidAggregate>) -> Self {
Self { canon_stream_map, cid }
}
}

8
air/src/execution_step/value_types/scalar.rs
View File

@ -45,14 +45,14 @@ pub enum ValueAggregate {
result: ServiceResultAggregate,
// the original call result CID; not changed on lambda application
#[serde(rename = "cid")]
provenance_cid: Rc<CID<ServiceResultCidAggregate>>,
provenance_cid: CID<ServiceResultCidAggregate>,
},
Canon {
#[serde(flatten)]
result: CanonResultAggregate,
// the original canon CID; not changed on lambda application
#[serde(rename = "cid")]
provenance_cid: Rc<CID<CanonResultCidAggregate>>,
provenance_cid: CID<CanonResultCidAggregate>,
},
}
@ -109,7 +109,7 @@ impl ValueAggregate {
pub(crate) fn from_service_result(
service_result: ServiceResultAggregate,
service_result_agg_cid: Rc<CID<ServiceResultCidAggregate>>,
service_result_agg_cid: CID<ServiceResultCidAggregate>,
) -> Self {
Self::ServiceResult {
result: service_result,
@ -119,7 +119,7 @@ impl ValueAggregate {
pub(crate) fn from_canon_result(
canon_result: CanonResultAggregate,
canon_result_agg_cid: Rc<CID<CanonResultCidAggregate>>,
canon_result_agg_cid: CID<CanonResultCidAggregate>,
) -> Self {
Self::Canon {
result: canon_result,

2
air/src/execution_step/value_types/stream/stream_definition.rs
View File

@ -538,7 +538,7 @@ mod test {
let trace = ExecutionTrace::from(vec![]);
let mut trace_ctx = TraceHandler::from_trace(trace.clone(), trace);
let canon_result = CanonResult::executed(Rc::new(CID::new("fake canon CID")));
let canon_result = CanonResult::executed(CID::new("fake canon CID"));
trace_ctx.meet_canon_end(canon_result.clone());
trace_ctx.meet_canon_end(canon_result.clone());
trace_ctx.meet_canon_end(canon_result);

2
air/src/execution_step/value_types/stream_map.rs
View File

@ -239,7 +239,7 @@ mod test {
let trace = ExecutionTrace::from(vec![]);
let mut trace_ctx = TraceHandler::from_trace(trace.clone(), trace);
let canon_result = CanonResult::executed(Rc::new(CID::new("fake canon CID")));
let canon_result = CanonResult::executed(CID::new("fake canon CID"));
trace_ctx.meet_canon_end(canon_result.clone());
trace_ctx.meet_canon_end(canon_result.clone());
trace_ctx.meet_canon_end(canon_result);

8
air/tests/test_module/features/cid/canon.rs
View File

@ -230,7 +230,7 @@ fn test_canon_value_not_found() {
cid_state.value_tracker = CidTracker::<_>::new();
let cur_data = raw_data_from_trace_with_canon(trace, cid_state);
let result = call_vm!(vm, <_>::default(), air_script, vec![], cur_data);
let expected_error = ValueForCidNotFound("value", String::from(missing_cid));
let expected_error = ValueForCidNotFound("value", missing_cid.into());
assert!(check_error(&result, expected_error));
}
@ -281,7 +281,7 @@ fn test_canon_root_tetraplet_not_found() {
let cur_data = raw_data_from_trace_with_canon(trace, cid_state);
let result = call_vm!(vm, <_>::default(), air_script, vec![], cur_data);
let expected_error = ValueForCidNotFound("tetraplet", String::from(missing_cid));
let expected_error = ValueForCidNotFound("tetraplet", missing_cid.into());
assert!(check_error(&result, expected_error));
}
@ -337,7 +337,7 @@ fn test_canon_tetraplet_not_found() {
let cur_data = raw_data_from_trace_with_canon(trace, cid_state);
let result = call_vm!(vm, <_>::default(), air_script, vec![], cur_data);
let expected_error = ValueForCidNotFound("tetraplet", String::from(missing_cid));
let expected_error = ValueForCidNotFound("tetraplet", missing_cid.into());
assert!(check_error(&result, expected_error), "{}", result.error_message);
}
@ -383,6 +383,6 @@ fn test_canon_agg_not_found() {
let cur_data = raw_data_from_trace_with_canon(trace, cid_state);
let result = call_vm!(vm, <_>::default(), air_script, vec![], cur_data);
let expected_error = ValueForCidNotFound("canon aggregate", String::from(missing_cid));
let expected_error = ValueForCidNotFound("canon aggregate", missing_cid.into());
assert!(check_error(&result, expected_error));
}

2
air/tests/test_module/features/cid/mod.rs
View File

@ -42,7 +42,7 @@ fn test_missing_cid() {
let cur_data = raw_data_from_trace(trace, cid_state);
let result = call_vm!(vm, <_>::default(), air_script, vec![], cur_data);
let missing_cid = String::from("bagaaierajmqwu6mhm7iw5mxxy647ri6yznuwjxfm72u4u5a5zdasfid4xwiq");
let missing_cid = "bagaaierajmqwu6mhm7iw5mxxy647ri6yznuwjxfm72u4u5a5zdasfid4xwiq".into();
let expected_error = ValueForCidNotFound("service result aggregate", missing_cid);
assert!(check_error(&result, expected_error), "{:?}", result);
}

5
air/tests/test_module/features/signatures/attacks.rs
View File

@ -15,11 +15,14 @@
*/
use air::{ExecutionCidState, PreparationError};
use air_interpreter_cid::CidRef;
use air_interpreter_signatures::{PeerCidTracker, PublicKey, SignatureStore};
use air_test_utils::key_utils::derive_dummy_keypair;
use air_test_utils::prelude::*;
use semver::Version;
use std::rc::Rc;
/// This testing modules assert AquaVM resistance to various attacks.
///
/// CID store manipulations are checked in the `corruption` module.
@ -447,7 +450,7 @@ fn test_attack_replay() {
"3eSuF5uvjQvmvSC6vu5Kmb8bJcswXhNUcqsSG9USEad1oNgnpAcBNm2maM4Tyk3BsLYnwdwNEj4KiJ4pqence7XF".to_owned(),
"6m3zmtymxDL56KBpNgKqc7QiGRuWuxr82bG2q7dF5xCD".to_owned(),
);
let cids: Vec<Box<str>> = vec!["bagaaieraazcwm4lxybe4pwlisvcgpv4mii63nxouogvf4ihkmz762mnhea7a".into()];
let cids: Vec<Rc<CidRef>> = vec!["bagaaieraazcwm4lxybe4pwlisvcgpv4mii63nxouogvf4ihkmz762mnhea7a".into()];
let expected = PreparationError::DataSignatureCheckError(verification::DataVerifierError::SignatureMismatch {
error: nested_error.into(),
cids,

16
air/tests/test_module/features/signatures/corruption.rs
View File

@ -94,7 +94,7 @@ fn test_attack_replace_value() {
&res,
PreparationError::CidStoreVerificationError(CidStoreVerificationError::MismatchError {
type_name: "serde_json::value::Value",
cid_repr: "bagaaierabjifaczkgq2745dsq57lelki2r5cfduunmfzsgvxiavi2ahwwmwq".to_owned(),
cid_repr: "bagaaierabjifaczkgq2745dsq57lelki2r5cfduunmfzsgvxiavi2ahwwmwq".into(),
})
);
}
@ -167,7 +167,7 @@ fn test_attack_replace_tetraplet() {
&res,
PreparationError::CidStoreVerificationError(CidStoreVerificationError::MismatchError {
type_name: "marine_call_parameters::SecurityTetraplet",
cid_repr: "bagaaierapisclqfeq36psuo6uxiazvcash32pndayqlwxrqchii2ykxerfba".to_owned(),
cid_repr: "bagaaierapisclqfeq36psuo6uxiazvcash32pndayqlwxrqchii2ykxerfba".into(),
})
);
}
@ -196,7 +196,7 @@ fn test_attack_replace_call_result() {
let mut mallory_cid_state = ExecutionCidState::new();
let alice_trace_1 = scalar_tracked!("alice", &mut mallory_cid_state, peer = &alice_peer_id);
let alice_trace_1_cid = (*extract_service_result_cid(&alice_trace_1)).clone().into_inner();
let alice_trace_1_cid = extract_service_result_cid(&alice_trace_1).get_inner();
let mallory_trace = vec![
alice_trace_1,
@ -210,7 +210,7 @@ fn test_attack_replace_call_result() {
.unwrap()
.iter_mut()
{
if *cid == alice_trace_1_cid {
if &*cid == &*alice_trace_1_cid {
service_cid_val["argument_hash"] = "42".into();
cnt += 1;
}
@ -247,7 +247,7 @@ fn test_attack_replace_call_result() {
&res,
PreparationError::CidStoreVerificationError(CidStoreVerificationError::MismatchError {
type_name: "air_interpreter_data::executed_state::ServiceResultCidAggregate",
cid_repr: "bagaaierarbji6ebokx3pantdp6xg2l57bhdj7pmlydwe2wnbd6fdkatg7xka".to_owned(),
cid_repr: "bagaaierarbji6ebokx3pantdp6xg2l57bhdj7pmlydwe2wnbd6fdkatg7xka".into(),
})
);
}
@ -334,7 +334,7 @@ fn test_attack_replace_canon_value() {
&res,
PreparationError::CidStoreVerificationError(CidStoreVerificationError::MismatchError {
type_name: "air_interpreter_data::executed_state::CanonCidAggregate",
cid_repr: "bagaaierayrb7yu6tvdofr3d7tvuzx7fb3uve27rqty4ckzy7ox66oicuhjjq".to_owned(),
cid_repr: "bagaaierayrb7yu6tvdofr3d7tvuzx7fb3uve27rqty4ckzy7ox66oicuhjjq".into(),
})
);
}
@ -430,7 +430,7 @@ fn test_attack_replace_canon_result_values() {
&res,
PreparationError::CidStoreVerificationError(CidStoreVerificationError::MismatchError {
type_name: "air_interpreter_data::executed_state::CanonResultCidAggregate",
cid_repr: "bagaaieratezrhuyz2eprlmiidxywv6ir2tmswlxycad37noykg3p5oxhs5tq".to_owned(),
cid_repr: "bagaaieratezrhuyz2eprlmiidxywv6ir2tmswlxycad37noykg3p5oxhs5tq".into(),
})
);
}
@ -530,7 +530,7 @@ fn test_attack_replace_canon_result_tetraplet() {
&res,
PreparationError::CidStoreVerificationError(CidStoreVerificationError::MismatchError {
type_name: "air_interpreter_data::executed_state::CanonResultCidAggregate",
cid_repr: "bagaaieratezrhuyz2eprlmiidxywv6ir2tmswlxycad37noykg3p5oxhs5tq".to_owned(),
cid_repr: "bagaaieratezrhuyz2eprlmiidxywv6ir2tmswlxycad37noykg3p5oxhs5tq".into(),
})
);
}

2
air/tests/test_module/negative_tests/uncatchable_trace_unrelated.rs
View File

@ -126,7 +126,7 @@ fn value_for_cid_not_found() {
let data = raw_data_from_trace(wrong_trace, <_>::default());
let result = peer_vm_1.call(script, "", data, <_>::default()).unwrap();
let missing_cid = String::from("bagaaierax2kxw256denmh2rmtot4cnuvz7wrf6e2l7jnxhtv3qb6xvqj2vhq");
let missing_cid = "bagaaierax2kxw256denmh2rmtot4cnuvz7wrf6e2l7jnxhtv3qb6xvqj2vhq".into();
let expected_error = ValueForCidNotFound("service result aggregate", missing_cid);
assert!(check_error(&result, expected_error));
}

33
crates/air-lib/interpreter-cid/src/lib.rs
View File

@ -32,18 +32,37 @@ use serde::Serialize;
use std::fmt;
use std::io::BufWriter;
use std::marker::PhantomData;
use std::rc::Rc;
/// Should-be-opaque type for the inner representation of CID.
/// It has to be serializable and Borsh-serializable, as well as implement `Debug`, `Eq`, `Ord`, `Hash` and similar
/// basic traits. It is also can be unsized.
// You should be able to replace it with [u8], and most of the code will just work.
pub type CidRef = str;
#[derive(Serialize, Deserialize)]
#[serde(transparent)]
pub struct CID<T: ?Sized>(String, #[serde(skip)] PhantomData<*const T>);
pub struct CID<T: ?Sized>(Rc<CidRef>, #[serde(skip)] PhantomData<*const T>);
impl<T: ?Sized> CID<T> {
pub fn new(cid: impl Into<String>) -> Self {
pub fn new(cid: impl Into<Rc<CidRef>>) -> Self {
Self(cid.into(), PhantomData)
}
pub fn into_inner(self) -> String {
self.0
pub fn get_inner(&self) -> Rc<CidRef> {
self.0.clone()
}
}
impl<T: ?Sized> std::convert::AsRef<CidRef> for CID<T> {
fn as_ref(&self) -> &CidRef {
&self.0
}
}
impl<T: ?Sized> std::borrow::Borrow<CidRef> for CID<T> {
fn borrow(&self) -> &CidRef {
&self.0
}
}
@ -74,12 +93,6 @@ impl<Val> std::hash::Hash for CID<Val> {
}
}
impl<T: ?Sized> From<CID<T>> for String {
fn from(value: CID<T>) -> Self {
value.0
}
}
// TODO we might refactor this to `SerializationFormat` trait
// that both transform data to binary/text form (be it JSON, CBOR or something else)
// and produces CID too

27
crates/air-lib/interpreter-data/src/cid_store.rs
View File

@ -18,6 +18,7 @@ use crate::JValue;
use air_interpreter_cid::value_to_json_cid;
use air_interpreter_cid::CidCalculationError;
use air_interpreter_cid::CidRef;
use air_interpreter_cid::CID;
use serde::Deserialize;
use serde::Serialize;
@ -28,7 +29,7 @@ use std::{collections::HashMap, rc::Rc};
/// Stores CID to Value corresponance.
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
#[serde(transparent)]
pub struct CidStore<Val>(HashMap<Rc<CID<Val>>, Rc<Val>>);
pub struct CidStore<Val>(HashMap<CID<Val>, Rc<Val>>);
impl<Val> CidStore<Val> {
pub fn new() -> Self {
@ -47,21 +48,21 @@ impl<Val> CidStore<Val> {
self.0.len()
}
pub fn iter(&self) -> impl Iterator<Item = (&Rc<CID<Val>>, &Rc<Val>)> {
pub fn iter(&self) -> impl Iterator<Item = (&CID<Val>, &Rc<Val>)> {
self.0.iter()
}
pub fn check_reference<Src>(
&self,
_source_cid: &CID<Src>,
target_cid: &Rc<CID<Val>>,
target_cid: &CID<Val>,
) -> Result<(), CidStoreVerificationError> {
self.0
.get(target_cid)
.ok_or_else(|| CidStoreVerificationError::MissingReference {
source_type_name: std::any::type_name::<Src>(),
target_type_name: std::any::type_name::<Val>(),
target_cid_repr: (**target_cid).clone().into_inner(),
target_cid_repr: target_cid.get_inner(),
})?;
Ok(())
}
@ -71,10 +72,10 @@ impl<Val: Serialize> CidStore<Val> {
pub fn verify(&self) -> Result<(), CidStoreVerificationError> {
for (cid, value) in &self.0 {
let expected_cid = value_to_json_cid::<Val>(value)?;
if expected_cid != **cid {
if expected_cid != *cid {
return Err(CidStoreVerificationError::MismatchError {
type_name: std::any::type_name::<Val>(),
cid_repr: (**cid).clone().into_inner(),
cid_repr: (*cid).get_inner(),
});
}
}
@ -91,14 +92,14 @@ pub enum CidStoreVerificationError {
MismatchError {
// nb: type_name is std::any::type_name() result that may be inconsistent between the Rust compiler versions
type_name: &'static str,
cid_repr: String,
cid_repr: Rc<CidRef>,
},
#[error("Reference CID {target_cid_repr:?} from type {source_type_name:?} to {target_type_name:?} was not found")]
MissingReference {
source_type_name: &'static str,
target_type_name: &'static str,
target_cid_repr: String,
target_cid_repr: Rc<CidRef>,
},
}
@ -110,7 +111,7 @@ impl<Val> Default for CidStore<Val> {
#[derive(Clone, Debug)]
pub struct CidTracker<Val = JValue> {
cids: HashMap<Rc<CID<Val>>, Rc<Val>>,
cids: HashMap<CID<Val>, Rc<Val>>,
}
impl<Val> CidTracker<Val> {
@ -136,9 +137,9 @@ impl<Val: Serialize> CidTracker<Val> {
pub fn track_value(
&mut self,
value: impl Into<Rc<Val>>,
) -> Result<Rc<CID<Val>>, CidCalculationError> {
) -> Result<CID<Val>, CidCalculationError> {
let value = value.into();
let cid = Rc::new(value_to_json_cid(&*value)?);
let cid = value_to_json_cid(&*value)?;
self.cids.insert(cid.clone(), value);
Ok(cid)
}
@ -159,9 +160,9 @@ impl<Val> From<CidTracker<Val>> for CidStore<Val> {
}
impl<Val> IntoIterator for CidStore<Val> {
type Item = (Rc<CID<Val>>, Rc<Val>);
type Item = (CID<Val>, Rc<Val>);
type IntoIter = std::collections::hash_map::IntoIter<Rc<CID<Val>>, Rc<Val>>;
type IntoIter = std::collections::hash_map::IntoIter<CID<Val>, Rc<Val>>;
fn into_iter(self) -> Self::IntoIter {
self.0.into_iter()

28
crates/air-lib/interpreter-data/src/executed_state.rs
View File

@ -55,7 +55,7 @@ pub enum CallResult {
/// The call returned a service error.
///
/// The `JValue` has to be a two element array `[i32, String]`.
Failed(Rc<CID<ServiceResultCidAggregate>>),
Failed(CID<ServiceResultCidAggregate>),
}
/*
@ -76,21 +76,21 @@ pub enum CallResult {
* is not stored into the `value_store`:
*
* ```
* Unused(Rc<CID<JValue>>) ---> X
* Unused(CID<JValue>) ---> X
* ```
*/
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ValueRef {
/// The call value is stored to a scalar variable.
Scalar(Rc<CID<ServiceResultCidAggregate>>),
Scalar(CID<ServiceResultCidAggregate>),
/// The call value is stored to a stream variable.
Stream {
cid: Rc<CID<ServiceResultCidAggregate>>,
cid: CID<ServiceResultCidAggregate>,
generation: GenerationIdx,
},
/// The call value is not stored.
Unused(Rc<CID<JValue>>),
Unused(CID<JValue>),
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
@ -114,11 +114,11 @@ impl CallServiceFailed {
#[serde(rename_all = "snake_case")]
/// A proof of service result execution result.
pub struct ServiceResultCidAggregate {
pub value_cid: Rc<CID<JValue>>,
pub value_cid: CID<JValue>,
/// Hash of the call arguments.
pub argument_hash: Rc<str>,
/// The tetraplet of the call result.
pub tetraplet_cid: Rc<CID<SecurityTetraplet>>,
pub tetraplet_cid: CID<SecurityTetraplet>,
}
/// Let's consider an example of trace that could be produces by the following fold:
@ -190,21 +190,21 @@ pub enum CanonResult {
/// Request was sent to a target node by node with such public key and it shouldn't be called again.
#[serde(rename = "sent_by")]
RequestSentBy(Rc<String>),
Executed(Rc<CID<CanonResultCidAggregate>>),
Executed(CID<CanonResultCidAggregate>),
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub struct CanonResultCidAggregate {
pub tetraplet: Rc<CID<SecurityTetraplet>>,
pub values: Vec<Rc<CID<CanonCidAggregate>>>,
pub tetraplet: CID<SecurityTetraplet>,
pub values: Vec<CID<CanonCidAggregate>>,
}
/// The type Canon trace CID refers to.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct CanonCidAggregate {
pub value: Rc<CID<serde_json::Value>>,
pub tetraplet: Rc<CID<SecurityTetraplet>>,
pub value: CID<serde_json::Value>,
pub tetraplet: CID<SecurityTetraplet>,
pub provenance: Provenance,
}
@ -214,11 +214,11 @@ pub enum Provenance {
Literal,
ServiceResult {
// the original call result CID; not changed on lambda application
cid: Rc<CID<ServiceResultCidAggregate>>,
cid: CID<ServiceResultCidAggregate>,
},
Canon {
// the original canon CID; not changed on lambda application
cid: Rc<CID<CanonResultCidAggregate>>,
cid: CID<CanonResultCidAggregate>,
},
}

31
crates/air-lib/interpreter-data/src/executed_state/impls.rs
View File

@ -43,25 +43,25 @@ impl CallResult {
Self::Executed(value_ref)
}
pub fn executed_scalar(service_result_agg_cid: Rc<CID<ServiceResultCidAggregate>>) -> Self {
pub fn executed_scalar(service_result_agg_cid: CID<ServiceResultCidAggregate>) -> Self {
Self::executed_service_result(ValueRef::Scalar(service_result_agg_cid))
}
pub fn executed_stream_stub(cid: Rc<CID<ServiceResultCidAggregate>>) -> CallResult {
pub fn executed_stream_stub(cid: CID<ServiceResultCidAggregate>) -> CallResult {
let generation = GenerationIdx::stub();
let value = ValueRef::Stream { cid, generation };
CallResult::Executed(value)
}
pub fn executed_unused(value_cid: Rc<CID<JValue>>) -> CallResult {
pub fn executed_unused(value_cid: CID<JValue>) -> CallResult {
Self::executed_service_result(ValueRef::Unused(value_cid))
}
pub fn failed(service_result_agg_cid: Rc<CID<ServiceResultCidAggregate>>) -> CallResult {
pub fn failed(service_result_agg_cid: CID<ServiceResultCidAggregate>) -> CallResult {
CallResult::Failed(service_result_agg_cid)
}
pub fn get_cid(&self) -> Option<&Rc<CID<ServiceResultCidAggregate>>> {
pub fn get_cid(&self) -> Option<&CID<ServiceResultCidAggregate>> {
match self {
CallResult::RequestSentBy(_) => None,
CallResult::Executed(executed) => executed.get_cid(),
@ -105,7 +105,7 @@ impl ApResult {
}
impl CanonResult {
pub fn executed(cid: Rc<CID<CanonResultCidAggregate>>) -> Self {
pub fn executed(cid: CID<CanonResultCidAggregate>) -> Self {
CanonResult::Executed(cid)
}
@ -115,18 +115,15 @@ impl CanonResult {
}
impl CanonResultCidAggregate {
pub fn new(
tetraplet: Rc<CID<SecurityTetraplet>>,
values: Vec<Rc<CID<CanonCidAggregate>>>,
) -> Self {
pub fn new(tetraplet: CID<SecurityTetraplet>, values: Vec<CID<CanonCidAggregate>>) -> Self {
Self { tetraplet, values }
}
}
impl CanonCidAggregate {
pub fn new(
value: Rc<CID<serde_json::Value>>,
tetraplet: Rc<CID<SecurityTetraplet>>,
value: CID<serde_json::Value>,
tetraplet: CID<SecurityTetraplet>,
provenance: Provenance,
) -> Self {
Self {
@ -139,9 +136,9 @@ impl CanonCidAggregate {
impl ServiceResultCidAggregate {
pub fn new(
value_cid: Rc<CID<JValue>>,
value_cid: CID<JValue>,
argument_hash: Rc<str>,
tetraplet_cid: Rc<CID<SecurityTetraplet>>,
tetraplet_cid: CID<SecurityTetraplet>,
) -> Self {
Self {
value_cid,
@ -158,12 +155,12 @@ impl Provenance {
}
#[inline]
pub fn service_result(cid: Rc<CID<ServiceResultCidAggregate>>) -> Self {
pub fn service_result(cid: CID<ServiceResultCidAggregate>) -> Self {
Self::ServiceResult { cid }
}
#[inline]
pub fn canon(cid: Rc<CID<CanonResultCidAggregate>>) -> Self {
pub fn canon(cid: CID<CanonResultCidAggregate>) -> Self {
Self::Canon { cid }
}
}
@ -211,7 +208,7 @@ impl std::fmt::Display for ExecutedState {
}
impl ValueRef {
pub(crate) fn get_cid(&self) -> Option<&Rc<CID<ServiceResultCidAggregate>>> {
pub(crate) fn get_cid(&self) -> Option<&CID<ServiceResultCidAggregate>> {
match self {
ValueRef::Scalar(cid) => Some(cid),
ValueRef::Stream { cid, .. } => Some(cid),

9
crates/air-lib/interpreter-data/src/interpreter_data/errors.rs
View File

@ -14,6 +14,9 @@
* limitations under the License.
*/
use std::rc::Rc;
use air_interpreter_cid::CidRef;
use thiserror::Error as ThisError;
#[derive(Debug, ThisError)]
pub enum DataVerifierError {
@ -29,7 +32,7 @@ pub enum DataVerifierError {
#[error("signature mismatch for {peer_id:?}: {error:?}, values: CIDS: {cids:?}")]
SignatureMismatch {
error: Box<fluence_keypair::error::VerificationError>,
cids: Vec<Box<str>>,
cids: Vec<Rc<CidRef>>,
peer_id: String,
},
@ -38,7 +41,7 @@ pub enum DataVerifierError {
)]
MergeMismatch {
peer_id: String,
larger_cids: Vec<Box<str>>,
smaller_cids: Vec<Box<str>>,
larger_cids: Vec<Rc<CidRef>>,
smaller_cids: Vec<Rc<CidRef>>,
},
}

10
crates/air-lib/interpreter-data/src/interpreter_data/verification.rs
View File

@ -21,7 +21,7 @@ use crate::ExecutedState;
use crate::ExecutionTrace;
use crate::InterpreterData;
use air_interpreter_cid::CID;
use air_interpreter_cid::{CidRef, CID};
use air_interpreter_signatures::PublicKey;
use air_interpreter_signatures::Signature;
use air_interpreter_signatures::SignatureStore;
@ -179,11 +179,11 @@ fn collect_peers_cids_from_trace<'data>(
fn try_push_cid<T>(
grouped_cids: &mut HashMap<Box<str>, PeerInfo<'_>>,
peer_pk: &str,
cid: &Rc<CID<T>>,
cid: &CID<T>,
) -> Result<(), DataVerifierError> {
match grouped_cids.get_mut(peer_pk) {
Some(peer_info) => {
peer_info.cids.push((**cid).clone().into_inner().into());
peer_info.cids.push(cid.get_inner());
Ok(())
}
None => Err(DataVerifierError::PeerIdNotFound(peer_pk.into())),
@ -214,7 +214,7 @@ fn check_cid_multiset_invariant(
}
}
fn to_count_map(cids: &Vec<Box<str>>) -> HashMap<&str, usize> {
fn to_count_map(cids: &Vec<Rc<CidRef>>) -> HashMap<&str, usize> {
let mut count_map = HashMap::<_, usize>::new();
for cid in cids {
// the counter can't overflow, the memory will overflow first
@ -244,7 +244,7 @@ struct PeerInfo<'data> {
/// A peer's signature.
signature: &'data Signature,
/// Sorted vector of CIDs that belong to the peer.
cids: Vec<Box<str>>,
cids: Vec<Rc<CidRef>>,
}
impl<'data> PeerInfo<'data> {

2
crates/air-lib/interpreter-signatures/Cargo.toml
View File

@ -15,6 +15,6 @@ air-interpreter-cid = { version = "0.4.0", path = "../interpreter-cid" }
fluence-keypair = { version = "0.10.1", default-features = false }
bs58 = "0.5.0"
borsh = "0.10.3"
borsh = { version = "0.10.3", features = ["rc"]}
borsh-derive = "0.10.3"
serde = { version = "1.0.164", features = ["derive"] }

8
crates/air-lib/interpreter-signatures/src/trackers.rs
View File

@ -16,7 +16,7 @@
use crate::SaltedData;
use air_interpreter_cid::CID;
use air_interpreter_cid::{CidRef, CID};
use fluence_keypair::error::SigningError;
use fluence_keypair::KeyPair;
@ -26,7 +26,7 @@ use std::rc::Rc;
#[derive(Debug)]
pub struct PeerCidTracker {
current_peer_id: Rc<String>,
cids: Vec<Box<str>>,
cids: Vec<Rc<CidRef>>,
}
impl PeerCidTracker {
@ -39,7 +39,7 @@ impl PeerCidTracker {
pub fn register<T>(&mut self, peer: &str, cid: &CID<T>) {
if peer == *self.current_peer_id {
self.cids.push(cid.clone().into_inner().into())
self.cids.push(cid.get_inner())
}
}
@ -53,7 +53,7 @@ impl PeerCidTracker {
}
fn sign_cids(
mut cids: Vec<Box<str>>,
mut cids: Vec<Rc<CidRef>>,
salt: &str,
keypair: &KeyPair,
) -> Result<crate::Signature, SigningError> {

12
crates/air-lib/test-utils/src/executed_state.rs
View File

@ -46,7 +46,7 @@ use std::rc::Rc;
pub fn simple_value_aggregate_cid(
result: impl Into<serde_json::Value>,
cid_state: &mut ExecutionCidState,
) -> Rc<CID<ServiceResultCidAggregate>> {
) -> CID<ServiceResultCidAggregate> {
let value_cid = cid_state
.value_tracker
.track_value(Rc::new(result.into()))
@ -72,7 +72,7 @@ pub fn value_aggregate_cid(
tetraplet: SecurityTetraplet,
args: Vec<serde_json::Value>,
cid_state: &mut ExecutionCidState,
) -> Rc<CID<ServiceResultCidAggregate>> {
) -> CID<ServiceResultCidAggregate> {
let value_cid = cid_state
.value_tracker
.track_value(Rc::new(result.into()))
@ -83,7 +83,7 @@ pub fn value_aggregate_cid(
.unwrap();
let arguments = serde_json::Value::Array(args);
let argument_hash = value_to_json_cid(&arguments).unwrap().into_inner().into();
let argument_hash = value_to_json_cid(&arguments).unwrap().get_inner();
let service_result_agg = ServiceResultCidAggregate {
value_cid,
@ -344,7 +344,7 @@ impl ExecutedCallBuilder {
pub fn unused(self) -> ExecutedState {
let value_cid = value_to_json_cid(&self.result).unwrap();
let value = ValueRef::Unused(value_cid.into());
let value = ValueRef::Unused(value_cid);
ExecutedState::Call(CallResult::Executed(value))
}
@ -389,7 +389,7 @@ impl ExecutedCallBuilder {
pub fn extract_service_result_cid(
stream_exec_state: &ExecutedState,
) -> Rc<CID<ServiceResultCidAggregate>> {
) -> CID<ServiceResultCidAggregate> {
match stream_exec_state {
ExecutedState::Call(CallResult::Executed(ValueRef::Stream { cid, .. })) => cid.clone(),
ExecutedState::Call(CallResult::Executed(ValueRef::Scalar(cid))) => cid.clone(),
@ -397,7 +397,7 @@ pub fn extract_service_result_cid(
}
}
pub fn extract_canon_result_cid(canon_state: &ExecutedState) -> Rc<CID<CanonResultCidAggregate>> {
pub fn extract_canon_result_cid(canon_state: &ExecutedState) -> CID<CanonResultCidAggregate> {
match canon_state {
ExecutedState::Canon(CanonResult::Executed(cid)) => cid.clone(),
_ => panic!("the function is intended for executed canon only"),