mirror of
https://github.com/fluencelabs/aquavm
synced 2025-06-03 18:11:20 +00:00
109 lines
3.1 KiB
Rust
109 lines
3.1 KiB
Rust
/*
|
|
* Copyright 2020 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.
|
|
*/
|
|
|
|
#![warn(rust_2018_idioms)]
|
|
#![deny(
|
|
dead_code,
|
|
nonstandard_style,
|
|
unused_imports,
|
|
unused_mut,
|
|
unused_variables,
|
|
unused_unsafe,
|
|
unreachable_patterns
|
|
)]
|
|
|
|
pub mod call_services;
|
|
pub mod executed_state;
|
|
pub mod test_runner;
|
|
|
|
pub use air::interpreter_data::*;
|
|
pub use avm_server::raw_outcome::*;
|
|
pub use avm_server::*;
|
|
|
|
pub mod prelude {
|
|
pub use super::*;
|
|
pub use call_services::*;
|
|
pub use executed_state::*;
|
|
pub use test_runner::*;
|
|
|
|
pub use air::interpreter_data::*;
|
|
pub use avm_server::*;
|
|
|
|
pub use serde_json::json;
|
|
}
|
|
|
|
pub type CallServiceClosure = Box<dyn Fn(CallRequestParams) -> CallServiceResult + 'static>;
|
|
|
|
pub type JValue = serde_json::Value;
|
|
|
|
#[macro_export]
|
|
macro_rules! checked_call_vm {
|
|
($vm:expr, $init_peer_id:expr, $script:expr, $prev_data:expr, $data:expr) => {{
|
|
match $vm.call($script, $prev_data, $data, $init_peer_id) {
|
|
Ok(v) if v.ret_code != 0 => {
|
|
panic!("VM returns a error: {} {}", v.ret_code, v.error_message)
|
|
}
|
|
Ok(v) => v,
|
|
Err(err) => panic!("VM call failed: {}", err),
|
|
}
|
|
}};
|
|
}
|
|
|
|
#[macro_export]
|
|
macro_rules! call_vm {
|
|
($vm:expr, $init_peer_id:expr, $script:expr, $prev_data:expr, $data:expr) => {
|
|
match $vm.call($script, $prev_data, $data, $init_peer_id) {
|
|
Ok(v) => v,
|
|
Err(err) => panic!("VM call failed: {}", err),
|
|
}
|
|
};
|
|
}
|
|
|
|
pub fn trace_from_result(result: &RawAVMOutcome) -> ExecutionTrace {
|
|
let data = data_from_result(result);
|
|
data.trace
|
|
}
|
|
|
|
pub fn data_from_result(result: &RawAVMOutcome) -> InterpreterData {
|
|
serde_json::from_slice(&result.data).expect("default serializer shouldn't fail")
|
|
}
|
|
|
|
pub fn raw_data_from_trace(trace: ExecutionTrace) -> Vec<u8> {
|
|
let data = InterpreterData::from_execution_result(trace, <_>::default(), 0);
|
|
serde_json::to_vec(&data).expect("default serializer shouldn't fail")
|
|
}
|
|
|
|
#[macro_export]
|
|
macro_rules! assert_next_pks {
|
|
($expected:expr, $actual:expr) => {
|
|
let expected: std::collections::HashSet<_> =
|
|
$expected.into_iter().map(|s| s.as_str()).collect();
|
|
let actual: std::collections::HashSet<_> = $actual.into_iter().map(|s| *s).collect();
|
|
|
|
assert_eq!(expected, actual)
|
|
};
|
|
}
|
|
|
|
pub fn print_trace(result: &RawAVMOutcome, trace_name: &str) {
|
|
let trace = trace_from_result(result);
|
|
|
|
println!("trace {} (states_count: {}): [", trace_name, trace.len());
|
|
for (id, state) in trace.iter().enumerate() {
|
|
println!(" {}: {}", id, state);
|
|
}
|
|
println!("]");
|
|
}
|