fix!(pallet-gear): append outgoing bytes limit to prevent runtime allocator overflow

core-errors/src/lib.rs

@@ -157,6 +157,11 @@ pub enum MessageError {
     )]
     IncorrectMessageForReplyDeposit = 310,
 
+    /// The error occurs when program tries to send messages
+    /// with total size bigger than allowed.
+    #[display(fmt = "Outgoing messages bytes limit exceeded")]
+    OutgoingMessagesBytesLimitExceeded = 311,
+
     // TODO: remove after delay refactoring is done
     /// An error occurs in attempt to charge gas for dispatch stash hold.
     #[display(fmt = "Not enough gas to hold dispatch message")]
@@ -262,6 +267,7 @@ impl ExtError {
             308 => Some(MessageError::InsufficientGasLimit.into()),
             309 => Some(MessageError::DuplicateReplyDeposit.into()),
             310 => Some(MessageError::IncorrectMessageForReplyDeposit.into()),
+            311 => Some(MessageError::OutgoingMessagesBytesLimitExceeded.into()),
             399 => Some(MessageError::InsufficientGasForDelayedSending.into()),
             //
             500 => Some(ReservationError::InvalidReservationId.into()),

core-processor/src/common.rs

@@ -462,6 +462,13 @@ pub enum ActorExecutionErrorReplyReason {
     /// Trap explanation
     #[display(fmt = "{_0}")]
     Trap(TrapExplanation),
+    // TODO: move this to SystemExecutionError after runtime upgrade,
+    // if wait-list does not contain messages with total outgoing bytes more than `OutgoingBytesLimit` #3751.
+    /// Message is not supported now
+    #[display(
+        fmt = "Message is not supported: outgoing bytes limit is exceeded after runtime-upgrade"
+    )]
+    UnsupportedMessage,
 }
 
 impl ActorExecutionErrorReplyReason {
@@ -480,6 +487,7 @@ impl ActorExecutionErrorReplyReason {
                 TrapExplanation::StackLimitExceeded => SimpleExecutionError::StackLimitExceeded,
                 TrapExplanation::Unknown => SimpleExecutionError::UnreachableInstruction,
             },
+            Self::UnsupportedMessage => SimpleExecutionError::Unsupported,
         }
     }
 }
@@ -501,6 +509,10 @@ pub enum SystemExecutionError {
     /// Error during `into_ext_info()` call
     #[display(fmt = "`into_ext_info()` error: {_0}")]
     IntoExtInfo(MemoryError),
+    // TODO: uncomment when #3751
+    // /// Incoming dispatch store has too many outgoing messages total bytes.
+    // #[display(fmt = "Incoming dispatch store has too many outgoing messages total bytes")]
+    // MessageStoreOutgoingBytesOverflow,
 }
 
 /// Actor.

core-processor/src/configs.rs

@@ -188,6 +188,8 @@ pub struct BlockConfig {
     pub existential_deposit: u128,
     /// Outgoing limit.
     pub outgoing_limit: u32,
+    /// Outgoing bytes limit.
+    pub outgoing_bytes_limit: u32,
     /// Host function weights.
     pub host_fn_weights: HostFnWeights,
     /// Forbidden functions.

core-processor/src/executor.rs

@@ -182,7 +182,14 @@ where
         AllocationsContext::new(allocations.clone(), static_pages, settings.max_pages);
 
     // Creating message context.
-    let message_context = MessageContext::new(dispatch.clone(), program_id, msg_ctx_settings);
+    let Some(message_context) = MessageContext::new(dispatch.clone(), program_id, msg_ctx_settings)
+    else {
+        return Err(ActorExecutionError {
+            gas_amount: gas_counter.to_amount(),
+            reason: ActorExecutionErrorReplyReason::UnsupportedMessage,
+        }
+        .into());
+    };
 
     // Creating value counter.
     //
@@ -380,30 +387,33 @@ where
         0.into()
     };
 
+    let message_context = MessageContext::new(
+        IncomingDispatch::new(
+            DispatchKind::Handle,
+            IncomingMessage::new(
+                Default::default(),
+                Default::default(),
+                payload
+                    .try_into()
+                    .map_err(|e| format!("Failed to create payload: {e:?}"))?,
+                gas_limit,
+                Default::default(),
+                Default::default(),
+            ),
+            None,
+        ),
+        program.id(),
+        Default::default(),
+    )
+    .ok_or("Incorrect message store context: out of outgoing bytes limit")?;
+
     let context = ProcessorContext {
         gas_counter: GasCounter::new(gas_limit),
         gas_allowance_counter: GasAllowanceCounter::new(gas_limit),
         gas_reserver: GasReserver::new(&Default::default(), Default::default(), Default::default()),
         value_counter: ValueCounter::new(Default::default()),
         allocations_context: AllocationsContext::new(allocations, static_pages, 512.into()),
-        message_context: MessageContext::new(
-            IncomingDispatch::new(
-                DispatchKind::Handle,
-                IncomingMessage::new(
-                    Default::default(),
-                    Default::default(),
-                    payload
-                        .try_into()
-                        .map_err(|e| format!("Failed to create payload: {e:?}"))?,
-                    gas_limit,
-                    Default::default(),
-                    Default::default(),
-                ),
-                None,
-            ),
-            program.id(),
-            ContextSettings::new(0, 0, 0, 0, 0, 0),
-        ),
+        message_context,
         block_info,
         performance_multiplier: gsys::Percent::new(100),
         max_pages: 512.into(),

core-processor/src/ext.rs

@@ -114,7 +114,7 @@ pub struct ProcessorContext {
 impl ProcessorContext {
     /// Create new mock [`ProcessorContext`] for usage in tests.
     pub fn new_mock() -> ProcessorContext {
-        use gear_core::message::{ContextSettings, IncomingDispatch};
+        use gear_core::message::IncomingDispatch;
 
         ProcessorContext {
             gas_counter: GasCounter::new(0),
@@ -134,8 +134,9 @@ impl ProcessorContext {
             message_context: MessageContext::new(
                 Default::default(),
                 Default::default(),
-                ContextSettings::new(0, 0, 0, 0, 0, 0),
-            ),
+                Default::default(),
+            )
+            .unwrap(),
             block_info: Default::default(),
             performance_multiplier: gsys::Percent::new(100),
             max_pages: 512.into(),
@@ -626,13 +627,13 @@ impl Ext {
 
     fn charge_sending_fee(&mut self, delay: u32) -> Result<(), ChargeError> {
         if delay == 0 {
-            self.charge_gas_if_enough(self.context.message_context.settings().sending_fee())
+            self.charge_gas_if_enough(self.context.message_context.settings().sending_fee)
         } else {
             self.charge_gas_if_enough(
                 self.context
                     .message_context
                     .settings()
-                    .scheduled_sending_fee(),
+                    .scheduled_sending_fee,
             )
         }
     }
@@ -1023,7 +1024,7 @@ impl Externalities for Ext {
         amount: u64,
         duration: u32,
     ) -> Result<ReservationId, Self::FallibleError> {
-        self.charge_gas_if_enough(self.context.message_context.settings().reservation_fee())?;
+        self.charge_gas_if_enough(self.context.message_context.settings().reservation_fee)?;
 
         if duration == 0 {
             return Err(ReservationError::ZeroReservationDuration.into());
@@ -1090,7 +1091,7 @@ impl Externalities for Ext {
     }
 
     fn wait(&mut self) -> Result<(), Self::UnrecoverableError> {
-        self.charge_gas_if_enough(self.context.message_context.settings().waiting_fee())?;
+        self.charge_gas_if_enough(self.context.message_context.settings().waiting_fee)?;
 
         if self.context.message_context.reply_sent() {
             return Err(UnrecoverableWaitError::WaitAfterReply.into());
@@ -1107,7 +1108,7 @@ impl Externalities for Ext {
     }
 
     fn wait_for(&mut self, duration: u32) -> Result<(), Self::UnrecoverableError> {
-        self.charge_gas_if_enough(self.context.message_context.settings().waiting_fee())?;
+        self.charge_gas_if_enough(self.context.message_context.settings().waiting_fee)?;
 
         if self.context.message_context.reply_sent() {
             return Err(UnrecoverableWaitError::WaitAfterReply.into());
@@ -1128,7 +1129,7 @@ impl Externalities for Ext {
     }
 
     fn wait_up_to(&mut self, duration: u32) -> Result<bool, Self::UnrecoverableError> {
-        self.charge_gas_if_enough(self.context.message_context.settings().waiting_fee())?;
+        self.charge_gas_if_enough(self.context.message_context.settings().waiting_fee)?;
 
         if self.context.message_context.reply_sent() {
             return Err(UnrecoverableWaitError::WaitAfterReply.into());
@@ -1153,7 +1154,7 @@ impl Externalities for Ext {
     }
 
     fn wake(&mut self, waker_id: MessageId, delay: u32) -> Result<(), Self::FallibleError> {
-        self.charge_gas_if_enough(self.context.message_context.settings().waking_fee())?;
+        self.charge_gas_if_enough(self.context.message_context.settings().waking_fee)?;
 
         self.context.message_context.wake(waker_id, delay)?;
         Ok(())
@@ -1223,45 +1224,30 @@ mod tests {
     struct MessageContextBuilder {
         incoming_dispatch: IncomingDispatch,
         program_id: ProgramId,
-        sending_fee: u64,
-        scheduled_sending_fee: u64,
-        waiting_fee: u64,
-        waking_fee: u64,
-        reservation_fee: u64,
-        outgoing_limit: u32,
+        context_settings: ContextSettings,
     }
 
     impl MessageContextBuilder {
         fn new() -> Self {
             Self {
                 incoming_dispatch: Default::default(),
                 program_id: Default::default(),
-                sending_fee: 0,
-                scheduled_sending_fee: 0,
-                waiting_fee: 0,
-                waking_fee: 0,
-                reservation_fee: 0,
-                outgoing_limit: 0,
+                context_settings: ContextSettings::with_outgoing_limits(u32::MAX, u32::MAX),
             }
         }
 
         fn build(self) -> MessageContext {
             MessageContext::new(
                 self.incoming_dispatch,
                 self.program_id,
-                ContextSettings::new(
-                    self.sending_fee,
-                    self.scheduled_sending_fee,
-                    self.waiting_fee,
-                    self.waking_fee,
-                    self.reservation_fee,
-                    self.outgoing_limit,
-                ),
+                self.context_settings,
             )
+            .unwrap()
         }
 
         fn with_outgoing_limit(mut self, outgoing_limit: u32) -> Self {
-            self.outgoing_limit = outgoing_limit;
+            self.context_settings.outgoing_limit = outgoing_limit;
+
             self
         }
     }
@@ -1461,11 +1447,7 @@ mod tests {
     fn test_send_push() {
         let mut ext = Ext::new(
             ProcessorContextBuilder::new()
-                .with_message_context(
-                    MessageContextBuilder::new()
-                        .with_outgoing_limit(u32::MAX)
-                        .build(),
-                )
+                .with_message_context(MessageContextBuilder::new().build())
                 .build(),
         );
 
@@ -1529,11 +1511,7 @@ mod tests {
     fn test_send_push_input() {
         let mut ext = Ext::new(
             ProcessorContextBuilder::new()
-                .with_message_context(
-                    MessageContextBuilder::new()
-                        .with_outgoing_limit(u32::MAX)
-                        .build(),
-                )
+                .with_message_context(MessageContextBuilder::new().build())
                 .build(),
         );
 
@@ -1595,11 +1573,7 @@ mod tests {
         let mut ext = Ext::new(
             ProcessorContextBuilder::new()
                 .with_gas(GasCounter::new(u64::MAX))
-                .with_message_context(
-                    MessageContextBuilder::new()
-                        .with_outgoing_limit(u32::MAX)
-                        .build(),
-                )
+                .with_message_context(MessageContextBuilder::new().build())
                 .build(),
         );
 
@@ -1636,11 +1610,7 @@ mod tests {
         let mut ext = Ext::new(
             ProcessorContextBuilder::new()
                 .with_gas(GasCounter::new(u64::MAX))
-                .with_message_context(
-                    MessageContextBuilder::new()
-                        .with_outgoing_limit(u32::MAX)
-                        .build(),
-                )
+                .with_message_context(MessageContextBuilder::new().build())
                 .build(),
         );
 
@@ -1691,11 +1661,7 @@ mod tests {
     fn test_reply_push_input() {
         let mut ext = Ext::new(
             ProcessorContextBuilder::new()
-                .with_message_context(
-                    MessageContextBuilder::new()
-                        .with_outgoing_limit(u32::MAX)
-                        .build(),
-                )
+                .with_message_context(MessageContextBuilder::new().build())
                 .build(),
         );
 

core-processor/src/processing.rs

@@ -66,6 +66,7 @@ where
         page_costs,
         existential_deposit,
         outgoing_limit,
+        outgoing_bytes_limit,
         host_fn_weights,
         forbidden_funcs,
         mailbox_threshold,
@@ -117,14 +118,21 @@ where
     //
     // Waking fee: double write cost for removal from waitlist
     // and further enqueueing.
-    let msg_ctx_settings = ContextSettings::new(
-        write_cost.saturating_mul(2),
-        write_cost.saturating_mul(4),
-        write_cost.saturating_mul(3),
-        write_cost.saturating_mul(2),
-        write_cost.saturating_mul(2),
+    let msg_ctx_settings = ContextSettings {
+        sending_fee: write_cost.saturating_mul(2),
+        scheduled_sending_fee: write_cost.saturating_mul(4),
+        waiting_fee: write_cost.saturating_mul(3),
+        waking_fee: write_cost.saturating_mul(2),
+        reservation_fee: write_cost.saturating_mul(2),
         outgoing_limit,
-    );
+        outgoing_bytes_limit,
+    };
+
+    // TODO: add tests that system reservation is successfully unreserved after
+    // actor execution error #3756.
+
+    // Get system reservation context in order to use it if actor execution error occurs.
+    let system_reservation_ctx = SystemReservationContext::from_dispatch(&dispatch);
 
     let exec_result = executor::execute_wasm::<Ext>(
         balance,
@@ -158,12 +166,11 @@ where
                 process_allowance_exceed(dispatch, program_id, res.gas_amount.burned())
             }
         }),
-        // TODO: we must use message reservation context here instead of default #3718
         Err(ExecutionError::Actor(e)) => Ok(process_execution_error(
             dispatch,
             program_id,
             e.gas_amount.burned(),
-            SystemReservationContext::default(),
+            system_reservation_ctx,
             e.reason,
         )),
         Err(ExecutionError::System(e)) => Err(e),