WIP

air/src/lib.rs

@@ -62,9 +62,6 @@ pub use polyplets::SecurityTetraplet;
 pub use preparation_step::interpreter_version;
 pub use preparation_step::min_supported_version;
 pub use preparation_step::PreparationError;
-pub use preparation_step::MAX_AIR_SIZE;
-pub use preparation_step::MAX_CALL_RESULTS_SIZE;
-pub use preparation_step::MAX_PARTICLE_SIZE;
 
 pub use utils::ToErrorCode;
 

air/src/preparation_step/errors.rs

@@ -93,15 +93,15 @@ pub enum PreparationError {
 
     /// AIR script size is bigger than the allowed limit.
     #[error("air size: {0} bytes is bigger than a limit allowed: {1} bytes")]
-    AIRSizeLimitReached(usize, usize),
+    AIRSizeLimitReached(usize, u64),
 
     /// Current_data particle size is bigger than the allowed limit.
     #[error("Current_data particle size: {0} bytes is bigger than a limit allowed: {1} bytes")]
-    ParticleSizeLimitReached(usize, usize),
+    ParticleSizeLimitReached(usize, u64),
 
-    /// CallResults cummulative size is bigger than the allowed limit.
+    /// CallResult size is bigger than the allowed limit.
-    #[error("Call results cummulative size: {0} bytes is bigger than a limit allowed: {1} bytes")]
+    #[error("Call result size is bigger than the limit allowed: {0} bytes")]
-    CallResultsSizeLimitReached(usize, usize),
+    CallResultSizeLimitReached(u64),
 }
 
 impl ToErrorCode for PreparationError {
@@ -135,15 +135,15 @@ impl PreparationError {
         }
     }
 
-    pub fn air_size_limit(actual_size: usize, limit: usize) -> Self {
+    pub fn air_size_limit(actual_size: usize, limit: u64) -> Self {
         Self::AIRSizeLimitReached(actual_size, limit)
     }
 
-    pub fn particle_size_limit(actual_size: usize, limit: usize) -> Self {
+    pub fn particle_size_limit(actual_size: usize, limit: u64) -> Self {
         Self::ParticleSizeLimitReached(actual_size, limit)
     }
 
-    pub fn call_results_size_limit(actual_size: usize, limit: usize) -> Self {
+    pub fn call_result_size_limit(limit: u64) -> Self {
-        Self::CallResultsSizeLimitReached(actual_size, limit)
+        Self::CallResultSizeLimitReached(limit)
     }
 }

air/src/preparation_step/mod.rs

@@ -22,9 +22,6 @@ mod sizes_limits_check;
 pub use errors::PreparationError;
 pub use interpreter_versions::interpreter_version;
 pub use interpreter_versions::min_supported_version;
-pub use sizes_limits_check::MAX_AIR_SIZE;
-pub use sizes_limits_check::MAX_CALL_RESULTS_SIZE;
-pub use sizes_limits_check::MAX_PARTICLE_SIZE;
 
 pub(crate) use preparation::check_version_compatibility;
 pub(crate) use preparation::parse_data;

air/src/preparation_step/preparation.rs

@@ -152,6 +152,16 @@ fn make_exec_ctx(
         "CallResultsRepr.deserialize",
     );
 
+    // This is a part of argument size limit check where we check the size of every call results.
+    if call_results
+        .values()
+        .any(|call_result| call_result.result.len() > run_parameters.call_result_size_limit as usize)
+    {
+        return Err(PreparationError::call_result_size_limit(
+            run_parameters.call_result_size_limit,
+        ));
+    }
+
     let ctx = ExecutionCtx::new(
         prev_ingredients,
         current_ingredients,

air/src/preparation_step/sizes_limits_check.rs

@@ -14,36 +14,27 @@
  * limitations under the License.
  */
 
-use air_interpreter_interface::SerializedCallResults;
-
 use super::preparation::PreparationResult;
 use crate::PreparationError;
 
-const MB: usize = 1024 * 1024;
+use air_interpreter_interface::RunParameters;
-pub const MAX_AIR_SIZE: usize = 16 * MB;
-pub const MAX_PARTICLE_SIZE: usize = 64 * MB;
-pub const MAX_CALL_RESULTS_SIZE: usize = 32 * MB;
 
 pub(crate) fn check_against_size_limits(
+    run_parameters: &RunParameters,
     air: &str,
     raw_current_data: &[u8],
-    call_results: &SerializedCallResults,
 ) -> PreparationResult<()> {
-    if air.len() > MAX_AIR_SIZE {
+    if air.len() > run_parameters.air_size_limit as usize {
-        return Err(PreparationError::air_size_limit(air.len(), MAX_AIR_SIZE));
+        return Err(PreparationError::air_size_limit(
-    }
+            air.len(),
-
+            run_parameters.air_size_limit,
-    if raw_current_data.len() > MAX_PARTICLE_SIZE {
-        return Err(PreparationError::particle_size_limit(
-            raw_current_data.len(),
-            MAX_PARTICLE_SIZE,
         ));
     }
 
-    if call_results.len() > MAX_CALL_RESULTS_SIZE {
+    if raw_current_data.len() > run_parameters.particle_size_limit as usize {
-        return Err(PreparationError::call_results_size_limit(
+        return Err(PreparationError::particle_size_limit(
-            call_results.len(),
+            raw_current_data.len(),
-            MAX_CALL_RESULTS_SIZE,
+            run_parameters.particle_size_limit,
         ));
     }
 

air/src/runner.rs

@@ -64,7 +64,7 @@ fn execute_air_impl(
     use crate::preparation_step::check_against_size_limits;
 
     farewell_if_fail!(
-        check_against_size_limits(&air, &raw_current_data, &call_results),
+        check_against_size_limits(&params, &air, &raw_current_data),
         raw_prev_data
     );
 

air/tests/test_module/features/signatures/algorithms.rs

@@ -99,7 +99,7 @@ fn test_banned_signing_key() {
     let air_script = "(null)";
     let bad_algo_keypair = fluence_keypair::KeyPair::generate_secp256k1();
 
-    let mut avm = create_avm_with_key::<NativeAirRunner>(bad_algo_keypair, unit_call_service());
+    let mut avm = create_avm_with_key::<NativeAirRunner>(bad_algo_keypair, unit_call_service(), <_>::default());
     let res = avm
         .call(air_script, "", "", TestRunParameters::from_init_peer_id("init_peer_id"))
         .unwrap();

air/tests/test_module/features/signatures/attacks.rs

@@ -80,7 +80,7 @@ fn test_attack_injection_current_peer_scalar() {
         Version::new(1, 1, 1),
     );
 
-    let mut alice_avm = create_avm_with_key::<NativeAirRunner>(alice_keypair, unit_call_service());
+    let mut alice_avm = create_avm_with_key::<NativeAirRunner>(alice_keypair, unit_call_service(), <_>::default());
     let test_run_params = TestRunParameters::from_init_peer_id(alice_peer_id);
     let prev_data = alice_data.serialize().unwrap();
     let cur_data = mallory_data.serialize().unwrap();
@@ -151,7 +151,7 @@ fn test_attack_injection_current_peer_stream() {
         Version::new(1, 1, 1),
     );
 
-    let mut alice_avm = create_avm_with_key::<NativeAirRunner>(alice_keypair, unit_call_service());
+    let mut alice_avm = create_avm_with_key::<NativeAirRunner>(alice_keypair, unit_call_service(), <_>::default());
     let test_run_params = TestRunParameters::from_init_peer_id(alice_peer_id);
     let prev_data = alice_data.serialize().unwrap();
     let cur_data = mallory_data.serialize().unwrap();
@@ -220,7 +220,7 @@ fn test_attack_injection_current_injection_unused() {
         Version::new(1, 1, 1),
     );
 
-    let mut alice_avm = create_avm_with_key::<NativeAirRunner>(alice_keypair, unit_call_service());
+    let mut alice_avm = create_avm_with_key::<NativeAirRunner>(alice_keypair, unit_call_service(), <_>::default());
     let test_run_params = TestRunParameters::from_init_peer_id(alice_peer_id);
     let prev_data = alice_data.serialize().unwrap();
     let cur_data = mallory_data.serialize().unwrap();
@@ -281,7 +281,7 @@ fn test_attack_injection_other_peer_scalar() {
         Version::new(1, 1, 1),
     );
 
-    let mut bob_avm = create_avm_with_key::<NativeAirRunner>(bob_keypair, unit_call_service());
+    let mut bob_avm = create_avm_with_key::<NativeAirRunner>(bob_keypair, unit_call_service(), <_>::default());
     let test_run_params = TestRunParameters::from_init_peer_id(alice_peer_id);
     let prev_data = "";
     let cur_data = mallory_data.serialize().unwrap();
@@ -339,7 +339,7 @@ fn test_attack_injection_other_peer_stream() {
         Version::new(1, 1, 1),
     );
 
-    let mut bob_avm = create_avm_with_key::<NativeAirRunner>(bob_keypair, unit_call_service());
+    let mut bob_avm = create_avm_with_key::<NativeAirRunner>(bob_keypair, unit_call_service(), <_>::default());
     let test_run_params = TestRunParameters::from_init_peer_id(alice_peer_id);
     let prev_data = "";
     let cur_data = mallory_data.serialize().unwrap();
@@ -397,7 +397,7 @@ fn test_attack_injection_other_peer_unused() {
         Version::new(1, 1, 1),
     );
 
-    let mut bob_avm = create_avm_with_key::<NativeAirRunner>(bob_keypair, unit_call_service());
+    let mut bob_avm = create_avm_with_key::<NativeAirRunner>(bob_keypair, unit_call_service(), <_>::default());
     let test_run_params = TestRunParameters::from_init_peer_id(alice_peer_id);
     let prev_data = "";
     let cur_data = mallory_data.serialize().unwrap();
@@ -420,8 +420,9 @@ fn test_attack_replay() {
              (call "bob" ("" "") [] z))"#
     );
 
-    let mut alice_avm = create_avm_with_key::<NativeAirRunner>(alice_keypair.clone(), unit_call_service());
+    let mut alice_avm =
-    let mut bob_avm = create_avm_with_key::<NativeAirRunner>(bob_keypair.clone(), unit_call_service());
+        create_avm_with_key::<NativeAirRunner>(alice_keypair.clone(), unit_call_service(), <_>::default());
+    let mut bob_avm = create_avm_with_key::<NativeAirRunner>(bob_keypair.clone(), unit_call_service(), <_>::default());
 
     let run_params1 = TestRunParameters::from_init_peer_id(&alice_peer_id).with_particle_id("first_particle");
     let run_params2 = run_params1.clone();

air/tests/test_module/features/signatures/runtime.rs

@@ -47,9 +47,9 @@ fn test_runtime_executed_call_argument_hash() {
         "#
     );
 
-    let mut alice_avm = create_avm_with_key::<NativeAirRunner>(alice_keypair, echo_call_service());
+    let mut alice_avm = create_avm_with_key::<NativeAirRunner>(alice_keypair, echo_call_service(), <_>::default());
-    let mut bob_avm = create_avm_with_key::<NativeAirRunner>(bob_keypair, echo_call_service());
+    let mut bob_avm = create_avm_with_key::<NativeAirRunner>(bob_keypair, echo_call_service(), <_>::default());
-    let mut mallory_avm = create_avm_with_key::<NativeAirRunner>(mallory_keypair, echo_call_service());
+    let mut mallory_avm = create_avm_with_key::<NativeAirRunner>(mallory_keypair, echo_call_service(), <_>::default());
 
     let alice_res = alice_avm.call(&air_script, "", "", test_run_params.clone()).unwrap();
     let mallory_res = mallory_avm
@@ -103,9 +103,9 @@ fn test_runtime_executed_call_tetraplet() {
         "#
     );
 
-    let mut alice_avm = create_avm_with_key::<NativeAirRunner>(alice_keypair, echo_call_service());
+    let mut alice_avm = create_avm_with_key::<NativeAirRunner>(alice_keypair, echo_call_service(), <_>::default());
-    let mut bob_avm = create_avm_with_key::<NativeAirRunner>(bob_keypair, echo_call_service());
+    let mut bob_avm = create_avm_with_key::<NativeAirRunner>(bob_keypair, echo_call_service(), <_>::default());
-    let mut mallory_avm = create_avm_with_key::<NativeAirRunner>(mallory_keypair, echo_call_service());
+    let mut mallory_avm = create_avm_with_key::<NativeAirRunner>(mallory_keypair, echo_call_service(), <_>::default());
 
     let alice_res = alice_avm.call(&air_script, "", "", test_run_params.clone()).unwrap();
     let mallory_res = mallory_avm
@@ -177,9 +177,10 @@ fn test_runtime_executed_failed_argument_hash() {
         "#
     );
 
-    let mut alice_avm = create_avm_with_key::<NativeAirRunner>(alice_keypair, fallible_call_service_by_arg(43));
+    let mut alice_avm =
-    let mut bob_avm = create_avm_with_key::<NativeAirRunner>(bob_keypair, echo_call_service());
+        create_avm_with_key::<NativeAirRunner>(alice_keypair, fallible_call_service_by_arg(43), <_>::default());
-    let mut mallory_avm = create_avm_with_key::<NativeAirRunner>(mallory_keypair, echo_call_service());
+    let mut bob_avm = create_avm_with_key::<NativeAirRunner>(bob_keypair, echo_call_service(), <_>::default());
+    let mut mallory_avm = create_avm_with_key::<NativeAirRunner>(mallory_keypair, echo_call_service(), <_>::default());
 
     let alice_res = alice_avm.call(&air_script, "", "", test_run_params.clone()).unwrap();
     let mallory_res = mallory_avm
@@ -237,9 +238,10 @@ fn test_runtime_failed_call_tetraplet() {
         "#
     );
 
-    let mut alice_avm = create_avm_with_key::<NativeAirRunner>(alice_keypair, fallible_call_service("service1"));
+    let mut alice_avm =
-    let mut bob_avm = create_avm_with_key::<NativeAirRunner>(bob_keypair, echo_call_service());
+        create_avm_with_key::<NativeAirRunner>(alice_keypair, fallible_call_service("service1"), <_>::default());
-    let mut mallory_avm = create_avm_with_key::<NativeAirRunner>(mallory_keypair, echo_call_service());
+    let mut bob_avm = create_avm_with_key::<NativeAirRunner>(bob_keypair, echo_call_service(), <_>::default());
+    let mut mallory_avm = create_avm_with_key::<NativeAirRunner>(mallory_keypair, echo_call_service(), <_>::default());
 
     let alice_res = alice_avm.call(&air_script, "", "", test_run_params.clone()).unwrap();
     let mallory_res = mallory_avm
@@ -309,9 +311,10 @@ fn test_runtime_canon_tetraplet() {
     "#
     );
 
-    let mut alice_avm = create_avm_with_key::<NativeAirRunner>(alice_keypair, fallible_call_service("service1"));
+    let mut alice_avm =
-    let mut bob_avm = create_avm_with_key::<NativeAirRunner>(bob_keypair, echo_call_service());
+        create_avm_with_key::<NativeAirRunner>(alice_keypair, fallible_call_service("service1"), <_>::default());
-    let mut mallory_avm = create_avm_with_key::<NativeAirRunner>(mallory_keypair, echo_call_service());
+    let mut bob_avm = create_avm_with_key::<NativeAirRunner>(bob_keypair, echo_call_service(), <_>::default());
+    let mut mallory_avm = create_avm_with_key::<NativeAirRunner>(mallory_keypair, echo_call_service(), <_>::default());
 
     let alice_res = alice_avm.call(&air_script, "", "", test_run_params.clone()).unwrap();
     let mallory_res = mallory_avm

air/tests/test_module/issues/issue_632.rs

@@ -34,7 +34,7 @@ fn issue_310() {
       )
     "#;
 
-    let mut runner = DefaultAirRunner::new(&peer_id);
+    let mut runner = DefaultAirRunner::new(&peer_id, <_>::default());
     let mut call = |prev_data, call_results| {
         runner
             .call(

air/tests/test_module/negative_tests/preparation_step.rs

@@ -18,6 +18,9 @@ use air::PreparationError;
 use air_interpreter_interface::CallResultsFormat;
 use air_interpreter_interface::CallResultsRepr;
 use air_interpreter_interface::RunParameters;
+use air_interpreter_interface::MAX_AIR_SIZE;
+use air_interpreter_interface::MAX_CALL_RESULT_SIZE;
+use air_interpreter_interface::MAX_PARTICLE_SIZE;
 use air_interpreter_sede::FromSerialized;
 use air_test_utils::prelude::*;
 
@@ -96,6 +99,10 @@ fn invalid_callresults() {
     let vec = Vec::<u8>::new();
     let wrong_call_results = CallResultsFormat::default().to_vec(&vec).unwrap();
     let keypair = fluence_keypair::KeyPair::generate_ed25519();
+    let air_size_limit = MAX_AIR_SIZE;
+    let particle_size_limit = MAX_PARTICLE_SIZE;
+    let call_result_size_limit = MAX_CALL_RESULT_SIZE;
+
     let run_parameters = RunParameters::new(
         client_peer_id.clone(),
         client_peer_id.clone(),
@@ -104,6 +111,9 @@ fn invalid_callresults() {
         keypair.key_format().into(),
         keypair.secret().unwrap(),
         "".to_owned(),
+        air_size_limit,
+        particle_size_limit,
+        call_result_size_limit,
     );
 
     let result = air::execute_air(air, prev_data, data, run_parameters, wrong_call_results.clone().into());
@@ -119,44 +129,41 @@ fn invalid_callresults() {
 
 #[test]
 fn air_size_limit() {
-    use air::MAX_AIR_SIZE;
+    let script = "a".repeat((MAX_AIR_SIZE + 1) as usize);
-
-    let script = "a".repeat(MAX_AIR_SIZE + 1);
     let mut vm = create_avm(unit_call_service(), "some_peer_id");
     let result = vm.call(script, "", "", <_>::default()).unwrap();
 
-    let expected_error = PreparationError::AIRSizeLimitReached(MAX_AIR_SIZE + 1, MAX_AIR_SIZE);
+    let expected_error = PreparationError::AIRSizeLimitReached((MAX_AIR_SIZE + 1) as usize, MAX_AIR_SIZE);
 
     assert!(check_error(&result, expected_error));
 }
 
 #[test]
 fn particle_size_limit() {
-    use air::MAX_PARTICLE_SIZE;
-
     let script = "(null)";
     let mut vm = create_avm(unit_call_service(), "some_peer_id");
-    let cur_data = vec![0; MAX_PARTICLE_SIZE + 1];
+    let cur_data = vec![0; (MAX_PARTICLE_SIZE + 1) as usize];
     let result = vm.call(script, "", cur_data, <_>::default()).unwrap();
 
-    let expected_error = PreparationError::ParticleSizeLimitReached(MAX_PARTICLE_SIZE + 1, MAX_PARTICLE_SIZE);
+    let expected_error =
+        PreparationError::ParticleSizeLimitReached((MAX_PARTICLE_SIZE + 1) as usize, MAX_PARTICLE_SIZE);
 
     assert!(check_error(&result, expected_error));
 }
 
 #[test]
-fn call_results_size_limit() {
+fn call_result_size_limit() {
     use maplit::hashmap;
 
     use air::ToErrorCode;
-    use air::MAX_CALL_RESULTS_SIZE;
+    use air_interpreter_interface::MAX_CALL_RESULT_SIZE;
 
     let peer_id = "some_peer_id";
     let mut vm = create_avm(unit_call_service(), "some_peer_id");
 
     let script = "(null)";
-    let result_1 = "a".repeat(MAX_CALL_RESULTS_SIZE / 2 + 1);
+    let result_1 = "a".repeat((MAX_CALL_RESULT_SIZE / 2 + 1) as usize);
-    let result_2 = "b".repeat(MAX_CALL_RESULTS_SIZE / 2 + 1);
+    let result_2 = "b".repeat((MAX_CALL_RESULT_SIZE + 1) as usize);
     let call_results: CallResults =
         hashmap! {0 => CallServiceResult::ok(result_1.into()), 1 => CallServiceResult::ok(result_2.into())};
 
@@ -164,7 +171,7 @@ fn call_results_size_limit() {
         .call_single(script, "", "", peer_id, 0, 64, None, call_results, "particle_id")
         .unwrap();
 
-    let expected_error =
+    let expected_error = PreparationError::CallResultSizeLimitReached(MAX_CALL_RESULT_SIZE);
-        PreparationError::CallResultsSizeLimitReached(MAX_CALL_RESULTS_SIZE + 1, MAX_CALL_RESULTS_SIZE);
+
     assert_eq!(result.ret_code, expected_error.to_error_code());
 }

avm/interface/src/lib.rs

@@ -31,7 +31,6 @@ mod call_service_result;
 mod outcome;
 mod particle_parameters;
 pub mod raw_outcome;
-mod runtime_parameters;
 
 use air_interpreter_interface::CallArgumentsDeserializeError;
 use air_interpreter_interface::CallRequestsDeserializeError;
@@ -82,4 +81,3 @@ pub use call_request_parameters::*;
 pub use call_service_result::*;
 pub use outcome::*;
 pub use particle_parameters::*;
-pub use runtime_parameters::*;

avm/interface/src/particle_parameters.rs

@@ -45,25 +45,3 @@ impl<'ctx> ParticleParameters<'ctx> {
         }
     }
 }
-
-/// Represents parameters obtained from a particle.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct AquaVMRuntimeParameters {
-    air_size_limit: u32,
-    particle_size_limit: u32,
-    call_results_size_limit: u32,
-}
-
-impl AquaVMRuntimeParameters {
-    pub fn new(
-        air_size_limit: u32,
-        particle_size_limit: u32,
-        call_results_size_limit: u32,
-    ) -> Self {
-        Self {
-            air_size_limit,
-            particle_size_limit,
-            call_results_size_limit,
-        }
-    }
-}

avm/server/src/avm.rs

@@ -70,7 +70,7 @@ impl<E> AVM<E> {
 
         data_store.initialize()?;
 
-        let runner = AVMRunner::new(air_wasm_path, max_heap_size, logging_mask)
+        let runner = AVMRunner::new(air_wasm_path, max_heap_size, None, None, None, logging_mask)
             .map_err(AVMError::RunnerError)?;
         let runner = SendSafeRunner(runner);
         let avm = Self { runner, data_store };

avm/server/src/runner.rs

@@ -38,6 +38,12 @@ pub struct AVMRunner {
     wasm_filename: String,
     /// The memory limit provided by constructor
     total_memory_limit: Option<u64>,
+    /// The AIR script size limit.
+    pub air_size_limit: u64,
+    /// The particle data size limit.
+    pub particle_size_limit: u64,
+    // This is the limit for the size of service call result.
+    pub call_result_size_limit: u64,
 }
 
 /// Return statistic of AVM server Wasm module heap footprint.
@@ -57,18 +63,32 @@ impl AVMRunner {
     pub fn new(
         air_wasm_path: PathBuf,
         total_memory_limit: Option<u64>,
+        air_size_limit: Option<u64>,
+        particle_size_limit: Option<u64>,
+        call_result_size_limit: Option<u64>,
         logging_mask: i32,
     ) -> RunnerResult<Self> {
+        use air_interpreter_interface::MAX_AIR_SIZE;
+        use air_interpreter_interface::MAX_CALL_RESULT_SIZE;
+        use air_interpreter_interface::MAX_PARTICLE_SIZE;
+
         let (wasm_dir, wasm_filename) = split_dirname(air_wasm_path)?;
 
         let marine_config =
             make_marine_config(wasm_dir, &wasm_filename, total_memory_limit, logging_mask);
         let marine = Marine::with_raw_config(marine_config)?;
 
+        let air_size_limit = air_size_limit.unwrap_or(MAX_AIR_SIZE);
+        let particle_size_limit = particle_size_limit.unwrap_or(MAX_PARTICLE_SIZE);
+        let call_result_size_limit = call_result_size_limit.unwrap_or(MAX_CALL_RESULT_SIZE);
+
         let avm = Self {
             marine,
             wasm_filename,
             total_memory_limit,
+            air_size_limit,
+            particle_size_limit,
+            call_result_size_limit,
         };
 
         Ok(avm)
@@ -102,6 +122,9 @@ impl AVMRunner {
             init_peer_id.into(),
             timestamp,
             ttl,
+            self.air_size_limit,
+            self.particle_size_limit,
+            self.call_result_size_limit,
             call_results,
             key_format.into(),
             secret_key_bytes,
@@ -150,6 +173,9 @@ impl AVMRunner {
             init_peer_id.into(),
             timestamp,
             ttl,
+            self.air_size_limit,
+            self.particle_size_limit,
+            self.call_result_size_limit,
             call_results,
             key_format,
             secret_key_bytes,
@@ -216,6 +242,9 @@ fn prepare_args(
     init_peer_id: String,
     timestamp: u64,
     ttl: u32,
+    air_size_limit: u64,
+    particle_size_limit: u64,
+    call_result_size_limit: u64,
     call_results: CallResults,
     key_format: u8,
     secret_key_bytes: Vec<u8>,
@@ -229,6 +258,9 @@ fn prepare_args(
         key_format,
         secret_key_bytes,
         particle_id,
+        air_size_limit,
+        particle_size_limit,
+        call_result_size_limit,
     )
     .into_ivalue();
 

crates/air-lib/interpreter-interface/src/lib.rs

@@ -29,9 +29,11 @@
 mod call_request_parameters;
 mod call_service_result;
 mod interpreter_outcome;
+mod run_args_memory_limits;
 mod run_parameters;
 
 pub use call_request_parameters::*;
 pub use call_service_result::*;
 pub use interpreter_outcome::*;
+pub use run_args_memory_limits::*;
 pub use run_parameters::*;

crates/air-lib/interpreter-interface/src/run_args_memory_limits.rs

@@ -14,27 +14,7 @@
  * limitations under the License.
  */
 
-use serde::Deserialize;
+const MB: u64 = 1024 * 1024;
-use serde::Serialize;
+pub static MAX_AIR_SIZE: u64 = 16 * MB;
-
+pub static MAX_PARTICLE_SIZE: u64 = 64 * MB;
-/// Represents runtime parameters to hand over to AquaVM.
+pub static MAX_CALL_RESULT_SIZE: u64 = 32 * MB;
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct RuntimeParameters {
-    air_size_limit: u32,
-    particle_size_limit: u32,
-    call_results_size_limit: u32,
-}
-
-impl RuntimeParameters {
-    pub fn new(
-        air_size_limit: u32,
-        particle_size_limit: u32,
-        call_results_size_limit: u32,
-    ) -> Self {
-        Self {
-            air_size_limit,
-            particle_size_limit,
-            call_results_size_limit,
-        }
-    }
-}

crates/air-lib/interpreter-interface/src/run_parameters.rs

@@ -53,6 +53,15 @@ pub struct RunParameters {
 
     /// Unique particle ID.
     pub particle_id: String,
+
+    /// The AIR script size limit.
+    pub air_size_limit: u64,
+
+    /// The particle data size limit.
+    pub particle_size_limit: u64,
+
+    /// This is the limit for the size of service call result.
+    pub call_result_size_limit: u64,
 }
 
 impl RunParameters {
@@ -64,6 +73,9 @@ impl RunParameters {
         key_format: u8,
         secret_key_bytes: Vec<u8>,
         particle_id: String,
+        air_size_limit: u64,
+        particle_size_limit: u64,
+        call_result_size_limit: u64,
     ) -> Self {
         Self {
             init_peer_id,
@@ -73,6 +85,9 @@ impl RunParameters {
             key_format,
             secret_key_bytes,
             particle_id,
+            air_size_limit,
+            particle_size_limit,
+            call_result_size_limit,
         }
     }
 
@@ -86,6 +101,9 @@ impl RunParameters {
             IValue::U8(self.key_format),
             IValue::ByteArray(self.secret_key_bytes),
             IValue::String(self.particle_id),
+            IValue::U64(self.air_size_limit),
+            IValue::U64(self.particle_size_limit),
+            IValue::U64(self.call_result_size_limit),
         ];
         // unwrap is safe here because run_parameters is non-empty array
         let run_parameters = NEVec::new(run_parameters).unwrap();

crates/air-lib/test-utils/src/native_test_runner.rs

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+use crate::prelude::TestInitParameters;
 use crate::test_runner::AirRunner;
 use air_interpreter_interface::CallResultsRepr;
 use air_interpreter_interface::RunParameters;
@@ -24,12 +25,14 @@ use fluence_keypair::KeyPair;
 
 pub struct NativeAirRunner {
     current_peer_id: String,
+    test_init_parameters: TestInitParameters,
 }
 
 impl AirRunner for NativeAirRunner {
-    fn new(current_peer_id: impl Into<String>) -> Self {
+    fn new(current_peer_id: impl Into<String>, test_init_parameters: TestInitParameters) -> Self {
         Self {
             current_peer_id: current_peer_id.into(),
+            test_init_parameters,
         }
     }
 
@@ -56,6 +59,9 @@ impl AirRunner for NativeAirRunner {
         let key_format = keypair.key_format().into();
         let secret_key_bytes = keypair.secret().unwrap();
 
+        let (air_size_limit, particle_size_limit, call_result_size_limit) =
+            self.test_init_parameters.to_attributes_w_default();
+
         let outcome = air::execute_air(
             air.into(),
             prev_data.into(),
@@ -68,6 +74,9 @@ impl AirRunner for NativeAirRunner {
                 key_format,
                 secret_key_bytes,
                 particle_id,
+                air_size_limit,
+                particle_size_limit,
+                call_result_size_limit,
             },
             raw_call_results,
         );

crates/air-lib/test-utils/src/test_runner.rs

@@ -33,7 +33,7 @@ use std::collections::HashMap;
 use std::collections::HashSet;
 
 pub trait AirRunner {
-    fn new(current_call_id: impl Into<String>) -> Self;
+    fn new(current_call_id: impl Into<String>, test_init_parameters: TestInitParameters) -> Self;
 
     #[allow(clippy::too_many_arguments)]
     fn call(
@@ -68,6 +68,14 @@ pub struct TestRunParameters {
     pub particle_id: String,
 }
 
+/// This struct is used to set limits for the test runner creating AVMRunner.
+#[derive(Debug, Default, Clone)]
+pub struct TestInitParameters {
+    pub air_size_limit: Option<u64>,
+    pub particle_size_limit: Option<u64>,
+    pub call_result_size_limit: Option<u64>,
+}
+
 impl<R: AirRunner> TestRunner<R> {
     pub fn call(
         &mut self,
@@ -169,10 +177,8 @@ pub fn create_custom_avm<R: AirRunner>(
     current_peer_id: impl Into<String>,
 ) -> TestRunner<R> {
     let current_peer_id = current_peer_id.into();
-
     let (keypair, _) = derive_dummy_keypair(&current_peer_id);
-
+    let runner = R::new(current_peer_id, <_>::default());
-    let runner = R::new(current_peer_id);
 
     TestRunner {
         runner,
@@ -184,10 +190,11 @@ pub fn create_custom_avm<R: AirRunner>(
 pub fn create_avm_with_key<R: AirRunner>(
     keypair: impl Into<KeyPair>,
     call_service: CallServiceClosure,
+    test_init_parameters: TestInitParameters,
 ) -> TestRunner<R> {
     let keypair = keypair.into();
     let current_peer_id = keypair.public().to_peer_id().to_string();
-    let runner = R::new(current_peer_id);
+    let runner = R::new(current_peer_id, test_init_parameters);
 
     TestRunner {
         runner,
@@ -239,6 +246,35 @@ impl TestRunParameters {
     }
 }
 
+impl TestInitParameters {
+    pub fn new(air_size_limit: u64, particle_size_limit: u64, call_result_size_limit: u64) -> Self {
+        Self {
+            air_size_limit: Some(air_size_limit),
+            particle_size_limit: Some(particle_size_limit),
+            call_result_size_limit: Some(call_result_size_limit),
+        }
+    }
+
+    pub fn no_limits() -> Self {
+        Self {
+            air_size_limit: Some(u64::MAX),
+            particle_size_limit: Some(u64::MAX),
+            call_result_size_limit: Some(u64::MAX),
+        }
+    }
+
+    pub(crate) fn to_attributes_w_default(&self) -> (u64, u64, u64) {
+        use air_interpreter_interface::MAX_AIR_SIZE;
+        use air_interpreter_interface::MAX_CALL_RESULT_SIZE;
+        use air_interpreter_interface::MAX_PARTICLE_SIZE;
+
+        let air_size_limit = self.air_size_limit.unwrap_or(MAX_AIR_SIZE);
+        let particle_size_limit: u64 = self.particle_size_limit.unwrap_or(MAX_PARTICLE_SIZE);
+        let call_result_size_limit = self.call_result_size_limit.unwrap_or(MAX_CALL_RESULT_SIZE);
+        (air_size_limit, particle_size_limit, call_result_size_limit)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

crates/air-lib/test-utils/src/wasm_test_runner.rs

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+use crate::prelude::TestInitParameters;
 use crate::test_runner::AirRunner;
 
 use avm_server::avm_runner::*;
@@ -32,19 +33,24 @@ pub struct WasmAirRunner {
     runner: object_pool::Reusable<'static, AVMRunner>,
 }
 
-fn make_pooled_avm_runner() -> AVMRunner {
+fn make_pooled_avm_runner(test_init_parameters: TestInitParameters) -> AVMRunner {
     let logging_mask = i32::MAX;
+    let (air_size_limit, particle_size_limit, call_result_size_limit) =
+        test_init_parameters.to_attributes_w_default();
 
     AVMRunner::new(
         PathBuf::from(AIR_WASM_PATH),
         Some(AVM_MAX_HEAP_SIZE),
+        Some(air_size_limit),
+        Some(particle_size_limit),
+        Some(call_result_size_limit),
         logging_mask,
     )
     .expect("vm should be created")
 }
 
 impl AirRunner for WasmAirRunner {
-    fn new(current_peer_id: impl Into<String>) -> Self {
+    fn new(current_peer_id: impl Into<String>, test_init_parameters: TestInitParameters) -> Self {
         static POOL_CELL: OnceCell<object_pool::Pool<AVMRunner>> = OnceCell::new();
 
         let pool = POOL_CELL.get_or_init(|| {
@@ -55,7 +61,7 @@ impl AirRunner for WasmAirRunner {
             )
         });
 
-        let runner = pool.pull(make_pooled_avm_runner);
+        let runner = pool.pull(|| make_pooled_avm_runner(test_init_parameters.clone()));
 
         Self {
             current_peer_id: current_peer_id.into(),
@@ -106,12 +112,17 @@ pub struct ReleaseWasmAirRunner {
 }
 
 impl AirRunner for ReleaseWasmAirRunner {
-    fn new(current_peer_id: impl Into<String>) -> Self {
+    fn new(current_peer_id: impl Into<String>, test_init_parameters: TestInitParameters) -> Self {
         let logging_mask = i32::MAX;
+        let (air_size_limit, particle_size_limit, call_result_size_limit) =
+            test_init_parameters.to_attributes_w_default();
 
         let runner = AVMRunner::new(
             PathBuf::from(RELEASE_AIR_WASM_PATH),
             Some(AVM_MAX_HEAP_SIZE),
+            Some(air_size_limit),
+            Some(particle_size_limit),
+            Some(call_result_size_limit),
             logging_mask,
         )
         .expect("vm should be created");
@@ -135,6 +146,7 @@ impl AirRunner for ReleaseWasmAirRunner {
         keypair: &KeyPair,
         particle_id: String,
     ) -> Result<RawAVMOutcome, Box<dyn std::error::Error>> {
+        println!("running release wasm runner#####");
         let current_peer_id =
             override_current_peer_id.unwrap_or_else(|| self.current_peer_id.clone());
 

crates/testing-framework/src/ephemeral/mod.rs

@@ -25,7 +25,8 @@ use crate::{
 use air_test_utils::{
     key_utils::derive_dummy_keypair,
     test_runner::{
-        create_avm_with_key, AirRunner, DefaultAirRunner, TestRunParameters, TestRunner,
+        create_avm_with_key, AirRunner, DefaultAirRunner, TestInitParameters, TestRunParameters,
+        TestRunner,
     },
     RawAVMOutcome,
 };
@@ -86,10 +87,14 @@ pub struct Peer<R> {
 }
 
 impl<R: AirRunner> Peer<R> {
-    pub fn new(keypair: impl Into<KeyPair>, services: Rc<[MarineServiceHandle]>) -> Self {
+    pub fn new(
+        keypair: impl Into<KeyPair>,
+        services: Rc<[MarineServiceHandle]>,
+        test_init_parameters: TestInitParameters,
+    ) -> Self {
         let call_service = services_to_call_service_closure(services);
 
-        let runner = create_avm_with_key::<R>(keypair, call_service);
+        let runner = create_avm_with_key::<R>(keypair, call_service, test_init_parameters);
         let peer_id = runner.runner.get_current_peer_id().into();
 
         Self { peer_id, runner }
@@ -143,7 +148,8 @@ pub struct Network<R = DefaultAirRunner> {
 //   extencive test code changes
 impl Network<DefaultAirRunner> {
     pub fn empty() -> Rc<Self> {
-        Self::new(std::iter::empty::<PeerId>(), vec![])
+        let test_init_parameters = TestInitParameters::default();
+        Self::new(std::iter::empty::<PeerId>(), vec![], test_init_parameters)
     }
 }
 
@@ -151,6 +157,7 @@ impl<R: AirRunner> Network<R> {
     pub fn new(
         named_peers: impl Iterator<Item = impl Into<PeerId>>,
         common_services: Vec<MarineServiceHandle>,
+        test_init_params: TestInitParameters,
     ) -> Rc<Self> {
         let network = Rc::new(Self {
             peers: Default::default(),
@@ -158,13 +165,13 @@ impl<R: AirRunner> Network<R> {
             resolver: Default::default(),
         });
         for peer_name in named_peers {
-            network.ensure_named_peer(peer_name);
+            network.ensure_named_peer(peer_name, test_init_params.clone());
         }
         network
     }
 
-    pub fn from_peers(nodes: Vec<Peer<R>>) -> Rc<Self> {
+    pub fn from_peers(nodes: Vec<Peer<R>>, test_init_params: TestInitParameters) -> Rc<Self> {
-        let network = Self::new(std::iter::empty::<PeerId>(), vec![]);
+        let network = Self::new(std::iter::empty::<PeerId>(), vec![], test_init_params);
         let neighborhood: PeerSet = nodes.iter().map(|peer| peer.peer_id.clone()).collect();
         for peer in nodes {
             network.add_peer_env(peer, neighborhood.iter().cloned());
@@ -183,7 +190,11 @@ impl<R: AirRunner> Network<R> {
         self.insert_peer_env_entry(peer_id, peer_env);
     }
 
-    pub fn ensure_named_peer(self: &Rc<Self>, name: impl Into<PeerId>) -> PeerId {
+    pub fn ensure_named_peer(
+        self: &Rc<Self>,
+        name: impl Into<PeerId>,
+        test_init_params: TestInitParameters,
+    ) -> PeerId {
         use std::collections::hash_map::Entry;
 
         let name = name.into();
@@ -192,7 +203,7 @@ impl<R: AirRunner> Network<R> {
             Entry::Occupied(entry) => entry.get().clone(),
             Entry::Vacant(empty) => {
                 let (keypair, _) = derive_dummy_keypair(&name);
-                let peer = Peer::new(keypair, self.services.get_services());
+                let peer = Peer::new(keypair, self.services.get_services(), test_init_params);
                 let peer_id = peer.get_peer_id().clone();
                 self.add_peer(peer);
 

crates/testing-framework/src/ephemeral/neighborhood.rs

@@ -243,9 +243,13 @@ mod tests {
         let (_other_pk1, other_id) = derive_dummy_keypair(other_name);
         let peer_id = PeerId::from(peer_id);
         let other_id = PeerId::from(other_id);
-        let network = Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![]);
+        let network =
+            Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![], <_>::default());
 
-        let penv = PeerEnv::new(Peer::new(peer_pk, Rc::from(vec![])), &network);
+        let penv = PeerEnv::new(
+            Peer::new(peer_pk, Rc::from(vec![]), <_>::default()),
+            &network,
+        );
         assert!(penv.is_reachable(&peer_id));
         assert!(!penv.is_reachable(&other_id));
     }
@@ -258,9 +262,13 @@ mod tests {
         let (_other_pk, other_id) = derive_dummy_keypair(other_name);
         let peer_id = PeerId::from(peer_id);
         let other_id = PeerId::from(other_id);
-        let network = Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![]);
+        let network =
+            Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![], <_>::default());
 
-        let mut penv = PeerEnv::new(Peer::new(peer_pk, Rc::from(vec![])), &network);
+        let mut penv = PeerEnv::new(
+            Peer::new(peer_pk, Rc::from(vec![]), <_>::default()),
+            &network,
+        );
         {
             let nei = penv.get_neighborhood_mut();
 
@@ -286,15 +294,19 @@ mod tests {
         let (_other_pk2, other_id2) = derive_dummy_keypair(other_name2);
         let other_id1 = PeerId::from(other_id1);
         let other_id2 = PeerId::from(other_id2);
-        let network = Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![]);
+        let network =
+            Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![], <_>::default());
 
-        let penv = PeerEnv::new(Peer::new(peer_pk, Rc::from(vec![])), &network);
+        let penv = PeerEnv::new(
+            Peer::new(peer_pk, Rc::from(vec![]), <_>::default()),
+            &network,
+        );
         // iter is empty
         assert!(penv.iter().next().is_none());
 
-        network.ensure_named_peer(other_name1);
+        network.ensure_named_peer(other_name1, <_>::default());
-        network.ensure_named_peer(other_name1);
+        network.ensure_named_peer(other_name1, <_>::default());
-        network.ensure_named_peer(other_name2);
+        network.ensure_named_peer(other_name2, <_>::default());
         let expected_neighborhood = PeerSet::from([other_id1, other_id2]);
         assert_eq!(penv.iter().collect::<PeerSet>(), expected_neighborhood);
     }
@@ -309,15 +321,19 @@ mod tests {
         let (_other_pk2, other_id2) = derive_dummy_keypair(other_name2);
         let other_id1 = PeerId::from(other_id1);
         let other_id2 = PeerId::from(other_id2);
-        let network = Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![]);
+        let network =
+            Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![], <_>::default());
 
-        let penv = PeerEnv::new(Peer::new(peer_pk, Rc::from(vec![])), &network);
+        let penv = PeerEnv::new(
+            Peer::new(peer_pk, Rc::from(vec![]), <_>::default()),
+            &network,
+        );
 
         // iter is empty
         assert!(penv.iter().next().is_none());
 
-        network.ensure_named_peer(other_name1);
+        network.ensure_named_peer(other_name1, <_>::default());
-        network.ensure_named_peer(other_name2);
+        network.ensure_named_peer(other_name2, <_>::default());
         let expected_neighborhood = PeerSet::from([other_id1, other_id2]);
         assert_eq!(PeerSet::from_iter(penv.iter()), expected_neighborhood);
     }
@@ -332,9 +348,13 @@ mod tests {
         let (_other_pk2, other_id2) = derive_dummy_keypair(other_name2);
         let other_id1 = PeerId::from(other_id1);
         let other_id2 = PeerId::from(other_id2);
-        let network = Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![]);
+        let network =
+            Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![], <_>::default());
 
-        let mut penv = PeerEnv::new(Peer::new(peer_pk, Rc::from(vec![])), &network);
+        let mut penv = PeerEnv::new(
+            Peer::new(peer_pk, Rc::from(vec![]), <_>::default()),
+            &network,
+        );
 
         // iter is empty
         assert!(penv.iter().next().is_none());
@@ -353,9 +373,13 @@ mod tests {
         let (peer_pk, _peer_id) = derive_dummy_keypair(peer_name);
         let (_other_pk1, other_id1) = derive_dummy_keypair(other_name1);
         let other_id1 = PeerId::from(other_id1);
-        let network = Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![]);
+        let network =
+            Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![], <_>::default());
 
-        let mut penv = PeerEnv::new(Peer::new(peer_pk, Rc::from(vec![])), &network);
+        let mut penv = PeerEnv::new(
+            Peer::new(peer_pk, Rc::from(vec![]), <_>::default()),
+            &network,
+        );
 
         // iter is empty
         assert!(penv.iter().next().is_none());
@@ -373,9 +397,13 @@ mod tests {
         let peer_name = "peer";
         let (peer_pk, _peer_id) = derive_dummy_keypair(peer_name);
 
-        let network = Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![]);
+        let network =
+            Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![], <_>::default());
 
-        let mut penv = PeerEnv::new(Peer::new(peer_pk, Rc::from(vec![])), &network);
+        let mut penv = PeerEnv::new(
+            Peer::new(peer_pk, Rc::from(vec![]), <_>::default()),
+            &network,
+        );
         penv.get_neighborhood_mut()
             .alter(PeerId::from("zero"), AlterState::Added);
         penv.extend_neighborhood(IntoIterator::into_iter(["one", "two"]));
@@ -388,10 +416,14 @@ mod tests {
 
     #[test]
     fn test_remove_from_neiborhood() {
-        let network = Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![]);
+        let network =
+            Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![], <_>::default());
         let (peer_pk, _peer_id) = derive_dummy_keypair("someone");
 
-        let mut penv = PeerEnv::new(Peer::new(peer_pk, Rc::from(vec![])), &network);
+        let mut penv = PeerEnv::new(
+            Peer::new(peer_pk, Rc::from(vec![]), <_>::default()),
+            &network,
+        );
         penv.get_neighborhood_mut()
             .alter(PeerId::from("zero"), AlterState::Added);
         penv.extend_neighborhood(IntoIterator::into_iter(["one", "two"]));
@@ -411,8 +443,12 @@ mod tests {
         let (peer_pk, _peer_id) = derive_dummy_keypair(peer_name);
         let (_other_pk, other_id) = derive_dummy_keypair(other_name1);
         let other_id = PeerId::from(other_id);
-        let network = Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![]);
+        let network =
-        let mut penv = PeerEnv::new(Peer::new(peer_pk, Rc::from(vec![])), &network);
+            Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![], <_>::default());
+        let mut penv = PeerEnv::new(
+            Peer::new(peer_pk, Rc::from(vec![]), <_>::default()),
+            &network,
+        );
 
         let nei = penv.get_neighborhood_mut();
         nei.alter(other_id.clone(), AlterState::Added);
@@ -430,9 +466,13 @@ mod tests {
         let (peer_pk, _peer_id) = derive_dummy_keypair(peer_name);
         let (_other_pk, other_id) = derive_dummy_keypair(other_name1);
         let other_id = PeerId::from(other_id);
-        let network = Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![]);
+        let network =
+            Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![], <_>::default());
 
-        let mut penv = PeerEnv::new(Peer::new(peer_pk, Rc::from(vec![])), &network);
+        let mut penv = PeerEnv::new(
+            Peer::new(peer_pk, Rc::from(vec![]), <_>::default()),
+            &network,
+        );
 
         let nei = penv.get_neighborhood_mut();
         nei.alter(other_id.clone(), AlterState::Added);
@@ -455,8 +495,12 @@ mod tests {
         let (peer_pk, _peer_id) = derive_dummy_keypair(peer_name);
         let (_other_pk, other_id) = derive_dummy_keypair(other_name1);
         let other_id = PeerId::from(other_id);
-        let network = Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![]);
+        let network =
-        let mut penv = PeerEnv::new(Peer::new(peer_pk, Rc::from(vec![])), &network);
+            Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![], <_>::default());
+        let mut penv = PeerEnv::new(
+            Peer::new(peer_pk, Rc::from(vec![]), <_>::default()),
+            &network,
+        );
 
         let nei = penv.get_neighborhood_mut();
         nei.alter(other_id.clone(), AlterState::Added);
@@ -479,9 +523,13 @@ mod tests {
         let peer_id = PeerId::from(peer_id);
         let other_id = PeerId::from(other_id);
         let remote_id = PeerId::from(remote_id);
-        let network = Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![]);
+        let network =
+            Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![], <_>::default());
 
-        let mut penv = PeerEnv::new(Peer::new(peer_pk, Rc::from(vec![])), &network);
+        let mut penv = PeerEnv::new(
+            Peer::new(peer_pk, Rc::from(vec![]), <_>::default()),
+            &network,
+        );
         penv.get_neighborhood_mut()
             .alter(other_id.clone(), AlterState::Added);
 

crates/testing-framework/src/execution/mod.rs

@@ -22,7 +22,7 @@ use crate::{
 };
 
 use air_test_utils::{
-    test_runner::{AirRunner, DefaultAirRunner, TestRunParameters},
+    test_runner::{AirRunner, DefaultAirRunner, TestInitParameters, TestRunParameters},
     RawAVMOutcome,
 };
 
@@ -57,11 +57,13 @@ impl AirScriptExecutor<DefaultAirRunner> {
 impl<R: AirRunner> AirScriptExecutor<R> {
     pub fn from_transformed_air_script(
         mut test_parameters: TestRunParameters,
+        test_init_parameters: TestInitParameters,
         transformed_air_script: TransformedAirScript<R>,
     ) -> Result<Self, String> {
         let network = transformed_air_script.get_network();
         let init_peer_id = test_parameters.init_peer_id.clone();
-        let real_init_peer_id = network.ensure_named_peer(init_peer_id.as_str());
+        let real_init_peer_id =
+            network.ensure_named_peer(init_peer_id.as_str(), test_init_parameters);
         test_parameters.init_peer_id = real_init_peer_id.to_string();
 
         let queue = ExecutionQueue::new();
@@ -85,20 +87,40 @@ impl<R: AirRunner> AirScriptExecutor<R> {
         extra_peers: impl IntoIterator<Item = PeerId>,
         annotated_air_script: &str,
     ) -> Result<Self, String> {
-        let network = Network::new(extra_peers.into_iter(), common_services);
+        let network = Network::new(extra_peers.into_iter(), common_services, <_>::default());
-        let transformed = TransformedAirScript::new(annotated_air_script, network)?;
+        let transformed = TransformedAirScript::new(annotated_air_script, network, <_>::default())?;
 
-        Self::from_transformed_air_script(test_parameters, transformed)
+        Self::from_transformed_air_script(test_parameters, <_>::default(), transformed)
     }
 
     pub fn from_network(
         test_parameters: TestRunParameters,
+        test_init_parameters: TestInitParameters,
         network: Rc<Network<R>>,
         annotated_air_script: &str,
     ) -> Result<Self, String> {
-        let transformed = TransformedAirScript::new(annotated_air_script, network)?;
+        let transformed =
+            TransformedAirScript::new(annotated_air_script, network, test_init_parameters.clone())?;
 
-        Self::from_transformed_air_script(test_parameters, transformed)
+        Self::from_transformed_air_script(test_parameters, test_init_parameters, transformed)
+    }
+
+    pub fn new_with_init_parameters(
+        test_parameters: TestRunParameters,
+        test_init_parameters: TestInitParameters,
+        common_services: Vec<MarineServiceHandle>,
+        extra_peers: impl IntoIterator<Item = PeerId>,
+        annotated_air_script: &str,
+    ) -> Result<Self, String> {
+        let network = Network::new(
+            extra_peers.into_iter(),
+            common_services,
+            test_init_parameters.clone(),
+        );
+        let transformed =
+            TransformedAirScript::new(annotated_air_script, network, test_init_parameters.clone())?;
+
+        Self::from_transformed_air_script(test_parameters, test_init_parameters, transformed)
     }
 
     /// Return Iterator for handling all the queued datas
@@ -640,15 +662,18 @@ mod tests {
     #[test]
     fn test_transformed_distinct() {
         let peer_name = "peer1";
-        let network = Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![]);
+        let network =
+            Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![], <_>::default());
 
         let transformed1 = TransformedAirScript::new(
             &format!(r#"(call "{peer_name}" ("service" "function") []) ; ok = 42"#),
             network.clone(),
+            <_>::default(),
         )
         .unwrap();
         let exectution1 = AirScriptExecutor::from_transformed_air_script(
             TestRunParameters::from_init_peer_id(peer_name),
+            <_>::default(),
             transformed1,
         )
         .unwrap();
@@ -656,10 +681,12 @@ mod tests {
         let transformed2 = TransformedAirScript::new(
             &format!(r#"(call "{peer_name}" ("service" "function") []) ; ok = 24"#,),
             network,
+            <_>::default(),
         )
         .unwrap();
         let exectution2 = AirScriptExecutor::from_transformed_air_script(
             TestRunParameters::from_init_peer_id(peer_name),
+            <_>::default(),
             transformed2,
         )
         .unwrap();
@@ -705,20 +732,24 @@ mod tests {
         let network = Network::<NativeAirRunner>::new(
             std::iter::empty::<PeerId>(),
             vec![service.to_handle()],
+            <_>::default(),
         );
 
         let peer_name = "peer1";
         let air_script = format!(r#"(call "{peer_name}" ("service" "function") [])"#);
-        let transformed1 = TransformedAirScript::new(&air_script, network.clone()).unwrap();
+        let transformed1 =
+            TransformedAirScript::new(&air_script, network.clone(), <_>::default()).unwrap();
         let exectution1 = AirScriptExecutor::from_transformed_air_script(
             TestRunParameters::from_init_peer_id(peer_name),
+            <_>::default(),
             transformed1,
         )
         .unwrap();
 
-        let transformed2 = TransformedAirScript::new(&air_script, network).unwrap();
+        let transformed2 = TransformedAirScript::new(&air_script, network, <_>::default()).unwrap();
         let exectution2 = AirScriptExecutor::from_transformed_air_script(
             TestRunParameters::from_init_peer_id(peer_name),
+            <_>::default(),
             transformed2,
         )
         .unwrap();

crates/testing-framework/src/transform/walker.rs

@@ -18,7 +18,9 @@ use super::{Call, Canon, Sexp};
 use crate::ephemeral::Network;
 
 use air_test_utils::key_utils::at;
-use air_test_utils::test_runner::{AirRunner, DefaultAirRunner};
+use air_test_utils::test_runner::AirRunner;
+use air_test_utils::test_runner::DefaultAirRunner;
+use air_test_utils::test_runner::TestInitParameters;
 
 use std::{borrow::Cow, fmt::Write, ops::Deref, rc::Rc, str::FromStr};
 
@@ -33,22 +35,27 @@ pub struct TransformedAirScript<R = DefaultAirRunner> {
 
 impl<R: AirRunner> TransformedAirScript<R> {
     // TODO peer transformation mode
-    pub fn new(annotated_air_script: &str, network: Rc<Network<R>>) -> Result<Self, String> {
+    pub fn new(
+        annotated_air_script: &str,
+        network: Rc<Network<R>>,
+        test_init_parameters: TestInitParameters,
+    ) -> Result<Self, String> {
         let at_transformed_air_script = at_transform(annotated_air_script);
 
         // validate the AIR script with the standard parser first
         air_parser::parse(&at_transformed_air_script)?;
 
-        Self::new_unvalidated(&at_transformed_air_script, network)
+        Self::new_unvalidated(&at_transformed_air_script, network, test_init_parameters)
     }
 
     pub(crate) fn new_unvalidated(
         at_transformed_air_script: &str,
         network: Rc<Network<R>>,
+        test_init_parameters: TestInitParameters,
     ) -> Result<Self, String> {
         let transformer = Transformer { network: &network };
         let mut sexp = Sexp::from_str(at_transformed_air_script)?;
-        transformer.transform(&mut sexp);
+        transformer.transform(&mut sexp, test_init_parameters);
 
         Ok(Self {
             network,
@@ -74,25 +81,25 @@ struct Transformer<'net, R> {
 }
 
 impl<R: AirRunner> Transformer<'_, R> {
-    pub(crate) fn transform(&self, sexp: &mut Sexp) {
+    pub(crate) fn transform(&self, sexp: &mut Sexp, test_init_parameters: TestInitParameters) {
         match sexp {
-            Sexp::Call(call) => self.handle_call(call),
+            Sexp::Call(call) => self.handle_call(call, test_init_parameters.clone()),
-            Sexp::Canon(canon) => self.handle_canon(canon),
+            Sexp::Canon(canon) => self.handle_canon(canon, test_init_parameters.clone()),
             Sexp::List(children) => {
                 for child in children.iter_mut().skip(1) {
-                    self.transform(child);
+                    self.transform(child, test_init_parameters.clone());
                 }
             }
             Sexp::Symbol(_) | Sexp::String(_) => {}
         }
     }
 
-    fn handle_call(&self, call: &mut Call) {
+    fn handle_call(&self, call: &mut Call, test_init_parameters: TestInitParameters) {
         // collect peers...
         if let Sexp::String(ref mut peer_name) = &mut call.triplet.0 {
             *peer_name = self
                 .network
-                .ensure_named_peer(peer_name.as_str())
+                .ensure_named_peer(peer_name.as_str(), test_init_parameters)
                 .to_string();
         }
 
@@ -111,11 +118,11 @@ impl<R: AirRunner> Transformer<'_, R> {
         }
     }
 
-    fn handle_canon(&self, canon: &mut Canon) {
+    fn handle_canon(&self, canon: &mut Canon, test_init_parameters: TestInitParameters) {
         if let Sexp::String(ref mut peer_name) = &mut canon.peer {
             *peer_name = self
                 .network
-                .ensure_named_peer(peer_name.as_str())
+                .ensure_named_peer(peer_name.as_str(), test_init_parameters)
                 .to_string();
         }
     }
@@ -156,33 +163,39 @@ mod tests {
 
     #[test]
     fn test_translate_null() {
-        let network = Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![]);
+        let network =
-        let transformed = TransformedAirScript::new("(null)", network).unwrap();
+            Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![], <_>::default());
+        let transformed = TransformedAirScript::new("(null)", network, <_>::default()).unwrap();
         assert_eq!(&*transformed, "(null)");
     }
 
     #[test]
     fn test_translate_call_no_result() {
-        let network = Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![]);
+        let network =
+            Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![], <_>::default());
         let script = r#"(call peer_id ("service_id" func) [])"#;
-        let transformed = TransformedAirScript::new_unvalidated(script, network).unwrap();
+        let transformed =
+            TransformedAirScript::new_unvalidated(script, network, <_>::default()).unwrap();
         assert_eq!(&*transformed, script);
     }
 
     #[test]
     #[should_panic]
     fn test_translate_call_no_string() {
-        let network = Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![]);
+        let network =
+            Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![], <_>::default());
         let script = r#"(call "peer_id" (service_id func) [])"#;
-        let transformed = TransformedAirScript::new(script, network);
+        let transformed = TransformedAirScript::new(script, network, <_>::default());
         assert_eq!(transformed.as_deref(), Ok(script));
     }
 
     #[test]
     fn test_translate_call_result() {
-        let network = Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![]);
+        let network =
+            Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![], <_>::default());
         let script = r#"(call "peer_id" ("service_id" func) []) ; ok = 42"#;
-        let transformer = TransformedAirScript::new_unvalidated(script, network.clone()).unwrap();
+        let transformer =
+            TransformedAirScript::new_unvalidated(script, network.clone(), <_>::default()).unwrap();
 
         let peer_id = at("peer_id");
 
@@ -215,8 +228,10 @@ mod tests {
       (call peer_id ("service_id" func) [1]) ; ok=true
 ))"#;
 
-        let network = Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![]);
+        let network =
-        let transformed = TransformedAirScript::new_unvalidated(script, network.clone()).unwrap();
+            Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![], <_>::default());
+        let transformed =
+            TransformedAirScript::new_unvalidated(script, network.clone(), <_>::default()).unwrap();
         assert_eq!(
             &*transformed,
             concat!(
@@ -255,8 +270,10 @@ mod tests {
       (canon "peer_id4" $stream #canon)
 ))"#;
 
-        let network = Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![]);
+        let network =
-        let t = TransformedAirScript::new_unvalidated(script, network.clone()).unwrap();
+            Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![], <_>::default());
+        let t =
+            TransformedAirScript::new_unvalidated(script, network.clone(), <_>::default()).unwrap();
 
         let peer_id1 = at("peer_id1");
         let peer_id2 = at("peer_id2");
@@ -292,8 +309,9 @@ mod tests {
     fn test_at_transform() {
         let script = r#"(call "peer_id1" ("service_id" "func") [1 @"peer_id3"] x) ; ok={"test":@"peer_id2"}"#;
 
-        let network = Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![]);
+        let network =
-        let t = TransformedAirScript::new(script, network.clone()).unwrap();
+            Network::<NativeAirRunner>::new(std::iter::empty::<PeerId>(), vec![], <_>::default());
+        let t = TransformedAirScript::new(script, network.clone(), <_>::default()).unwrap();
 
         let peer_id1 = at("peer_id1");
         let peer_id2 = at("peer_id2");
@@ -309,6 +327,7 @@ mod tests {
         let peer_name1 = "peer_id1";
         let exec = AirScriptExecutor::from_transformed_air_script(
             TestRunParameters::from_init_peer_id(peer_name1),
+            <_>::default(),
             t,
         )
         .unwrap();

junk/gen-bench-data/src/calls.rs

@@ -24,6 +24,7 @@ pub(crate) fn call_requests(size: usize) -> Data {
         init_peer_keypair.clone(),
         // actually, is not used
         set_variable_call_service(data.clone()),
+        <_>::default(),
     );
 
     let init_call_results: CallResults = <_>::default();
@@ -75,6 +76,7 @@ pub(crate) fn call_results(size: usize) -> Data {
         init_peer_keypair.clone(),
         // actually, is not used
         set_variable_call_service(data.clone()),
+        <_>::default(),
     );
 
     let call_results: CallResults = <_>::default();

junk/gen-bench-data/src/dashboard.rs

@@ -165,10 +165,12 @@ pub(crate) fn dashboard() -> super::Data {
     let (host_function, all_info) =
         client_host_function(known_peer_ids.clone(), client_id.clone(), relay_id.clone());
 
-    let mut client = create_avm_with_key::<NativeAirRunner>(client_key, host_function);
+    let mut client =
+        create_avm_with_key::<NativeAirRunner>(client_key, host_function, <_>::default());
     let mut relay = create_avm_with_key::<NativeAirRunner>(
         relay_key.clone(),
         create_peer_host_function(relay_id.clone(), known_peer_ids.clone()),
+        <_>::default(),
     );
 
     let mut known_peers = known_peer_keys
@@ -178,6 +180,7 @@ pub(crate) fn dashboard() -> super::Data {
             let vm = create_avm_with_key::<NativeAirRunner>(
                 peer_key,
                 create_peer_host_function(peer_id.clone(), known_peer_ids.clone()),
+                <_>::default(),
             );
             AVMState {
                 vm,

junk/gen-bench-data/src/main.rs

@@ -778,8 +778,9 @@ fn mem_consumption_with_size_in_mb(data_size: usize) -> Data {
         data = format_args!("\"{}\"", hex::encode(random_data))
     );
 
-    let exec = AirScriptExecutor::<NativeAirRunner>::new(
+    let exec = AirScriptExecutor::<NativeAirRunner>::new_with_init_parameters(
         TestRunParameters::from_init_peer_id("init_peer_id").with_particle_id(PARTICLE_ID),
+        TestInitParameters::no_limits(),
         vec![],
         vec![],
         &air_script,
@@ -823,8 +824,9 @@ fn mem_consumption_w_lense_with_size_in_mb(data_size: usize) -> Data {
         data = format_args!("{{\"attrib\": \"{}\"}}", hex::encode(random_data))
     );
 
-    let exec = AirScriptExecutor::<NativeAirRunner>::new(
+    let exec = AirScriptExecutor::<NativeAirRunner>::new_with_init_parameters(
         TestRunParameters::from_init_peer_id("init_peer_id").with_particle_id(PARTICLE_ID),
+        TestInitParameters::no_limits(),
         vec![],
         vec![],
         &air_script,
@@ -868,8 +870,9 @@ fn mem_consumption_w_map_2_scalar_with_size_in_mb(data_size: usize) -> Data {
         data = format_args!("\"{}\"", hex::encode(random_data))
     );
 
-    let exec = AirScriptExecutor::<NativeAirRunner>::new(
+    let exec = AirScriptExecutor::<NativeAirRunner>::new_with_init_parameters(
         TestRunParameters::from_init_peer_id("init_peer_id").with_particle_id(PARTICLE_ID),
+        TestInitParameters::no_limits(),
         vec![],
         vec![],
         &air_script,
@@ -913,8 +916,9 @@ fn mem_consumption_w_canon_map_with_size_in_mb(data_size: usize) -> Data {
         data = format_args!("\"{}\"", hex::encode(random_data))
     );
 
-    let exec = AirScriptExecutor::<NativeAirRunner>::new(
+    let exec = AirScriptExecutor::<NativeAirRunner>::new_with_init_parameters(
         TestRunParameters::from_init_peer_id("init_peer_id").with_particle_id(PARTICLE_ID),
+        TestInitParameters::no_limits(),
         vec![],
         vec![],
         &air_script,
@@ -958,8 +962,9 @@ fn mem_consumption_hybrid_with_size_in_mb(data_size: usize) -> Data {
         data = format_args!("{{\"attrib\": \"{}\"}}", hex::encode(random_data))
     );
 
-    let exec = AirScriptExecutor::<NativeAirRunner>::new(
+    let exec = AirScriptExecutor::<NativeAirRunner>::new_with_init_parameters(
         TestRunParameters::from_init_peer_id("init_peer_id").with_particle_id(PARTICLE_ID),
+        TestInitParameters::no_limits(),
         vec![],
         vec![],
         &air_script,

junk/gen-bench-data/src/network_explore.rs

@@ -41,23 +41,31 @@ pub(crate) fn network_explore() -> Data {
 
     let client_call_service =
         set_variables_call_service(set_variables_state, VariableOptionSource::Argument(0));
-    let mut client = create_avm_with_key::<NativeAirRunner>(client_key, client_call_service);
+    let mut client =
+        create_avm_with_key::<NativeAirRunner>(client_key, client_call_service, <_>::default());
 
     let relay_call_service =
         set_variable_call_service(json!([&client_1_id, &client_2_id, &client_3_id, &relay_id]));
-    let mut relay = create_avm_with_key::<NativeAirRunner>(relay_key.clone(), relay_call_service);
+    let mut relay = create_avm_with_key::<NativeAirRunner>(
+        relay_key.clone(),
+        relay_call_service,
+        <_>::default(),
+    );
 
     let client_1_call_service =
         set_variable_call_service(json!([&client_1_id, &client_3_id, &relay_id, &client_2_id]));
-    let mut client_1 = create_avm_with_key::<NativeAirRunner>(client_1_key, client_1_call_service);
+    let mut client_1 =
+        create_avm_with_key::<NativeAirRunner>(client_1_key, client_1_call_service, <_>::default());
 
     let client_2_call_service =
         set_variable_call_service(json!([&relay_id, &client_3_id, &client_1_id, &client_2_id]));
-    let mut client_2 = create_avm_with_key::<NativeAirRunner>(client_2_key, client_2_call_service);
+    let mut client_2 =
+        create_avm_with_key::<NativeAirRunner>(client_2_key, client_2_call_service, <_>::default());
 
     let client_3_call_service =
         set_variable_call_service(json!([&relay_id, &client_3_id, &client_1_id, &client_2_id]));
-    let mut client_3 = create_avm_with_key::<NativeAirRunner>(client_3_key, client_3_call_service);
+    let mut client_3 =
+        create_avm_with_key::<NativeAirRunner>(client_3_key, client_3_call_service, <_>::default());
 
     let raw_script = include_str!("network_explore.air");
 
@@ -66,9 +74,11 @@ pub(crate) fn network_explore() -> Data {
         let network = air_test_framework::Network::<NativeAirRunner>::new(
             std::iter::empty::<air_test_framework::ephemeral::PeerId>(),
             vec![],
+            <_>::default(),
         );
         let transformed_script =
-            air_test_framework::TransformedAirScript::new(raw_script, network).unwrap();
+            air_test_framework::TransformedAirScript::new(raw_script, network, <_>::default())
+                .unwrap();
         &(*transformed_script).to_string()
     };
 

tools/cli/air/src/trace/run/native.rs

@@ -16,6 +16,7 @@
 
 use super::runner::AirRunner;
 use super::runner::DataToHumanReadable;
+
 use air_interpreter_interface::CallResultsRepr;
 use air_interpreter_interface::RunParameters;
 use avm_interface::raw_outcome::RawAVMOutcome;
@@ -42,6 +43,9 @@ impl AirRunner for NativeAvmRunner {
         keypair: &KeyPair,
         particle_id: String,
     ) -> eyre::Result<RawAVMOutcome> {
+        use air_interpreter_interface::MAX_AIR_SIZE;
+        use air_interpreter_interface::MAX_CALL_RESULT_SIZE;
+        use air_interpreter_interface::MAX_PARTICLE_SIZE;
         use air_interpreter_sede::ToSerialized;
         use avm_interface::into_raw_result;
 
@@ -61,6 +65,9 @@ impl AirRunner for NativeAvmRunner {
                 current_peer_id,
                 timestamp,
                 ttl,
+                air_size_limit: MAX_AIR_SIZE,
+                particle_size_limit: MAX_PARTICLE_SIZE,
+                call_result_size_limit: MAX_CALL_RESULT_SIZE,
                 key_format,
                 secret_key_bytes,
                 particle_id,

tools/cli/air/src/trace/run/wasm.rs

@@ -75,6 +75,9 @@ pub(crate) fn create_wasm_avm_runner(
     Ok(Box::new(WasmAvmRunner(AVMRunner::new(
         air_interpreter_wasm_path.to_owned(),
         max_heap_size,
+        None,
+        None,
+        None,
         0,
     )?)))
 }