fix

aquamarine/src/aqua_runtime.rs

@@ -18,7 +18,9 @@ use std::str::FromStr;
 use std::{error::Error, task::Waker};
 
 use avm_server::avm_runner::{AVMRunner, RawAVMOutcome};
-use avm_server::{AVMMemoryStats, CallResults,AVMRuntimeLimits, ParticleParameters, RunnerError};
+use avm_server::{
+    AVMMemoryStats, AVMRuntimeLimits, CallRequests, CallResults, ParticleParameters, RunnerError,
+};
 use fluence_keypair::KeyPair;
 use libp2p::PeerId;
 use tracing::Level;

aquamarine/src/config.rs

@@ -19,42 +19,58 @@ use libp2p::PeerId;
 use std::path::PathBuf;
 use std::time::Duration;
 
-#[derive(Debug, Clone)]
-pub struct VmPoolConfig {
-    /// Number of VMs to create
-    pub pool_size: usize,
-    /// Timeout of a particle execution
-    pub execution_timeout: Duration,
-}
-
 #[derive(Debug, Clone)]
 pub struct VmConfig {
     pub current_peer_id: PeerId,
     /// Path to AIR interpreter .wasm file (aquamarine.wasm)
     pub air_interpreter: PathBuf,
     /// Maximum heap size in bytes available for the interpreter.
     pub max_heap_size: Option<u64>,
+    /// Maximum AIR script size in bytes.
+    pub air_size_limit: Option<u64>,
+    /// Maximum particle size in bytes.
+    pub particle_size_limit: Option<u64>,
+    /// Maximum call result size in bytes.
+    pub call_result_size_limit: Option<u64>,
+    /// A knob to enable/disable hard limits behavior in AquaVM.
+    pub hard_limit_enabled: bool,
 }
 
-impl VmPoolConfig {
-    pub fn new(pool_size: usize, execution_timeout: Duration) -> Self {
-        Self {
-            pool_size,
-            execution_timeout,
-        }
-    }
+#[derive(Debug, Clone)]
+pub struct VmPoolConfig {
+    /// Number of VMs to create
+    pub pool_size: usize,
+    /// Timeout of a particle execution
+    pub execution_timeout: Duration,
 }
 
 impl VmConfig {
     pub fn new(
         current_peer_id: PeerId,
         air_interpreter: PathBuf,
         max_heap_size: Option<u64>,
+        air_size_limit: Option<u64>,
+        particle_size_limit: Option<u64>,
+        call_result_size_limit: Option<u64>,
+        hard_limit_enabled: bool,
     ) -> Self {
         Self {
             current_peer_id,
             air_interpreter,
             max_heap_size,
+            air_size_limit,
+            particle_size_limit,
+            call_result_size_limit,
+            hard_limit_enabled,
+        }
+    }
+}
+
+impl VmPoolConfig {
+    pub fn new(pool_size: usize, execution_timeout: Duration) -> Self {
+        Self {
+            pool_size,
+            execution_timeout,
         }
     }
 }

crates/created-swarm/src/swarm.rs

@@ -29,8 +29,8 @@ use libp2p::{core::Multiaddr, PeerId};
 use serde::Deserialize;
 
 use air_interpreter_fs::{air_interpreter_path, write_default_air_interpreter};
-use aquamarine::{AVMRunner, AquamarineApi};
-use aquamarine::{AquaRuntime, DataStoreConfig, VmConfig};
+use aquamarine::{AVMRunner, AquamarineApi, VmConfig};
+use aquamarine::{AquaRuntime, DataStoreConfig};
 use base64::{engine::general_purpose::STANDARD as base64, Engine};
 use cid_utils::Hash;
 use core_manager::manager::DummyCoreManager;