fix(core): Allow waking the same message between waits

common/src/storage/complex/messenger.rs

@@ -59,6 +59,10 @@ pub trait Messenger {
     ///
     /// Present to clarify compiler behavior over associated types.
     type QueuedDispatch;
+    /// Stored values type for `Self::DispatchStash`.
+    ///
+    /// Present to clarify compiler behavior over associated types.
+    type DelayedDispatch;
     /// First key of the waitlist storage.
     ///
     /// Present to clarify compiler behavior over associated types.
@@ -167,7 +171,7 @@ pub trait Messenger {
 
     type DispatchStash: MapStorage<
         Key = Self::DispatchStashKey,
-        Value = (Self::QueuedDispatch, Interval<Self::BlockNumber>),
+        Value = (Self::DelayedDispatch, Interval<Self::BlockNumber>),
     >;
 
     /// Resets all related to messenger storages.

core-processor/src/common.rs

@@ -89,6 +89,8 @@ pub struct DispatchResult {
     pub page_update: BTreeMap<GearPage, PageBuf>,
     /// New allocations set for program if it has been changed.
     pub allocations: BTreeSet<WasmPage>,
+    /// Whether this execution sent out a reply.
+    pub reply_sent: bool,
 }
 
 impl DispatchResult {
@@ -135,6 +137,9 @@ impl DispatchResult {
             system_reservation_context,
             page_update: Default::default(),
             allocations: Default::default(),
+            // This function is only used to generate a dispatch result if nothing is executed,
+            // therefore reply_sent will always be false
+            reply_sent: false,
         }
     }
 }

core-processor/src/executor.rs

@@ -342,6 +342,7 @@ where
         system_reservation_context: info.system_reservation_context,
         page_update,
         allocations: info.allocations,
+        reply_sent: info.reply_sent,
     })
 }
 

core-processor/src/ext.rs

@@ -168,6 +168,7 @@ pub struct ExtInfo {
     pub reply_deposits: Vec<(MessageId, u64)>,
     pub program_candidates_data: BTreeMap<CodeId, Vec<(MessageId, ProgramId)>>,
     pub context_store: ContextStore,
+    pub reply_sent: bool,
 }
 
 /// Trait to which ext must have to work in processor wasm executor.
@@ -394,6 +395,7 @@ impl ProcessorExternalities for Ext {
             outgoing_dispatches: generated_dispatches,
             awakening,
             reply_deposits,
+            reply_sent,
         } = outcome.drain();
 
         let system_reservation_context = SystemReservationContext {
@@ -419,6 +421,7 @@ impl ProcessorExternalities for Ext {
             reply_deposits,
             context_store,
             program_candidates_data,
+            reply_sent,
         };
         Ok(info)
     }

core-processor/src/processing.rs

@@ -382,6 +382,7 @@ pub fn process_success(
         context_store,
         allocations,
         reply_deposits,
+        reply_sent,
         ..
     } = dispatch_result;
 
@@ -453,7 +454,7 @@ pub fn process_success(
 
     // Sending auto-generated reply about success execution.
     if matches!(kind, SuccessfulDispatchResultKind::Success)
-        && !context_store.reply_sent()
+        && !reply_sent
         && !dispatch.is_reply()
         && dispatch.kind() != DispatchKind::Signal
     {

core/src/message/common.rs

@@ -18,7 +18,10 @@
 
 use crate::{
     ids::{MessageId, ProgramId},
-    message::{DispatchKind, GasLimit, Payload, StoredDispatch, StoredMessage, Value},
+    message::{
+        DispatchKind, GasLimit, Payload, StoredDelayedDispatch, StoredDispatch, StoredMessage,
+        Value,
+    },
 };
 use core::ops::Deref;
 use gear_core_errors::{ReplyCode, SignalCode};
@@ -279,6 +282,12 @@ impl From<Dispatch> for StoredDispatch {
     }
 }
 
+impl From<Dispatch> for StoredDelayedDispatch {
+    fn from(dispatch: Dispatch) -> StoredDelayedDispatch {
+        StoredDelayedDispatch::new(dispatch.kind, dispatch.message.into())
+    }
+}
+
 impl From<Dispatch> for (DispatchKind, Message) {
     fn from(dispatch: Dispatch) -> (DispatchKind, Message) {
         (dispatch.kind, dispatch.message)
@@ -296,6 +305,11 @@ impl Dispatch {
         self.into()
     }
 
+    /// Convert Dispatch into gasless StoredDelayedDispatch.
+    pub fn into_stored_delayed(self) -> StoredDelayedDispatch {
+        self.into()
+    }
+
     /// Decompose Dispatch for it's components: DispatchKind and Message.
     pub fn into_parts(self) -> (DispatchKind, Message) {
         self.into()

core/src/message/context.rs

@@ -116,6 +116,8 @@ pub struct ContextOutcomeDrain {
     pub awakening: Vec<(MessageId, u32)>,
     /// Reply deposits to be provided.
     pub reply_deposits: Vec<(MessageId, u64)>,
+    /// Whether this execution sent out a reply.
+    pub reply_sent: bool,
 }
 
 /// Context outcome.
@@ -151,6 +153,7 @@ impl ContextOutcome {
     /// Destructs outcome after execution and returns provided dispatches and awaken message ids.
     pub fn drain(self) -> ContextOutcomeDrain {
         let mut dispatches = Vec::new();
+        let reply_sent = self.reply.is_some();
 
         for (msg, delay, reservation) in self.init.into_iter() {
             dispatches.push((msg.into_dispatch(self.program_id), delay, reservation));
@@ -172,6 +175,7 @@ impl ContextOutcome {
             outgoing_dispatches: dispatches,
             awakening: self.awakening,
             reply_deposits: self.reply_deposits,
+            reply_sent,
         }
     }
 }
@@ -182,13 +186,29 @@ pub struct ContextStore {
     outgoing: BTreeMap<u32, Option<Payload>>,
     reply: Option<Payload>,
     initialized: BTreeSet<ProgramId>,
-    awaken: BTreeSet<MessageId>,
-    reply_sent: bool,
     reservation_nonce: ReservationNonce,
     system_reservation: Option<u64>,
 }
 
 impl ContextStore {
+    // TODO: Remove, only used in migrations (#issue 3721)
+    /// Create a new context store with the provided parameters.
+    pub fn new(
+        outgoing: BTreeMap<u32, Option<Payload>>,
+        reply: Option<Payload>,
+        initialized: BTreeSet<ProgramId>,
+        reservation_nonce: ReservationNonce,
+        system_reservation: Option<u64>,
+    ) -> Self {
+        Self {
+            outgoing,
+            reply,
+            initialized,
+            reservation_nonce,
+            system_reservation,
+        }
+    }
+
     /// Returns stored within message context reservation nonce.
     ///
     /// Will be non zero, if any reservations were created during
@@ -216,11 +236,6 @@ impl ContextStore {
     pub fn system_reservation(&self) -> Option<u64> {
         self.system_reservation
     }
-
-    /// Get info about was reply sent.
-    pub fn reply_sent(&self) -> bool {
-        self.reply_sent
-    }
 }
 
 /// Context of currently processing incoming message.
@@ -266,7 +281,7 @@ impl MessageContext {
 
     /// Return bool defining was reply sent within the execution.
     pub fn reply_sent(&self) -> bool {
-        self.store.reply_sent
+        self.outcome.reply.is_some()
     }
 
     /// Send a new program initialization message.
@@ -434,7 +449,6 @@ impl MessageContext {
             let message = ReplyMessage::from_packet(message_id, packet);
 
             self.outcome.reply = Some((message, reservation));
-            self.store.reply_sent = true;
 
             Ok(message_id)
         } else {
@@ -484,9 +498,8 @@ impl MessageContext {
 
     /// Wake message by it's message id.
     pub fn wake(&mut self, waker_id: MessageId, delay: u32) -> Result<(), Error> {
-        if self.store.awaken.insert(waker_id) {
+        if !self.outcome.awakening.iter().any(|v| v.0 == waker_id) {
             self.outcome.awakening.push((waker_id, delay));
-
             Ok(())
         } else {
             Err(Error::DuplicateWaking)

core/src/message/mod.rs

@@ -43,7 +43,7 @@ pub use incoming::{IncomingDispatch, IncomingMessage};
 pub use init::{InitMessage, InitPacket};
 pub use reply::{ReplyMessage, ReplyPacket};
 pub use signal::SignalMessage;
-pub use stored::{StoredDispatch, StoredMessage};
+pub use stored::{StoredDelayedDispatch, StoredDispatch, StoredMessage};
 pub use user::{UserMessage, UserStoredMessage};
 
 use super::buffer::LimitedVec;

core/src/message/stored.rs

@@ -198,3 +198,58 @@ impl Deref for StoredDispatch {
         self.message()
     }
 }
+
+impl From<StoredDelayedDispatch> for StoredDispatch {
+    fn from(dispatch: StoredDelayedDispatch) -> Self {
+        StoredDispatch::new(dispatch.kind, dispatch.message, None)
+    }
+}
+
+/// Stored message with entry point.
+///
+/// We could use just [`StoredDispatch`]
+/// but delayed messages always don't have [`ContextStore`]
+/// so we designate this fact via new type.
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd, Decode, Encode, TypeInfo)]
+pub struct StoredDelayedDispatch {
+    /// Entry point.
+    kind: DispatchKind,
+    /// Stored message.
+    message: StoredMessage,
+}
+
+impl From<StoredDelayedDispatch> for (DispatchKind, StoredMessage) {
+    fn from(dispatch: StoredDelayedDispatch) -> (DispatchKind, StoredMessage) {
+        (dispatch.kind, dispatch.message)
+    }
+}
+
+impl StoredDelayedDispatch {
+    /// Create new StoredDelayedDispatch.
+    pub fn new(kind: DispatchKind, message: StoredMessage) -> Self {
+        Self { kind, message }
+    }
+
+    /// Decompose StoredDelayedDispatch for it's components: DispatchKind, StoredMessage.
+    pub fn into_parts(self) -> (DispatchKind, StoredMessage) {
+        self.into()
+    }
+
+    /// Entry point for the message.
+    pub fn kind(&self) -> DispatchKind {
+        self.kind
+    }
+
+    /// Dispatch message reference.
+    pub fn message(&self) -> &StoredMessage {
+        &self.message
+    }
+}
+
+impl Deref for StoredDelayedDispatch {
+    type Target = StoredMessage;
+
+    fn deref(&self) -> &Self::Target {
+        self.message()
+    }
+}

gsdk/src/metadata/generated.rs

@@ -796,8 +796,6 @@ pub mod runtime_types {
                             >,
                         >,
                         pub initialized: ::std::vec::Vec<runtime_types::gear_core::ids::ProgramId>,
-                        pub awaken: ::std::vec::Vec<runtime_types::gear_core::ids::MessageId>,
-                        pub reply_sent: ::core::primitive::bool,
                         pub reservation_nonce:
                             runtime_types::gear_core::reservation::ReservationNonce,
                         pub system_reservation: ::core::option::Option<::core::primitive::u64>,
@@ -808,6 +806,13 @@ pub mod runtime_types {
                     #[derive(
                         Debug, crate::gp::Decode, crate::gp::DecodeAsType, crate::gp::Encode,
                     )]
+                    pub struct StoredDelayedDispatch {
+                        pub kind: runtime_types::gear_core::message::DispatchKind,
+                        pub message: runtime_types::gear_core::message::stored::StoredMessage,
+                    }
+                    #[derive(
+                        Debug, crate::gp::Decode, crate::gp::DecodeAsType, crate::gp::Encode,
+                    )]
                     pub struct StoredDispatch {
                         pub kind: runtime_types::gear_core::message::DispatchKind,
                         pub message: runtime_types::gear_core::message::stored::StoredMessage,

pallets/gear-debug/src/lib.rs

@@ -39,7 +39,7 @@ pub mod pallet {
     use gear_core::{
         ids::ProgramId,
         memory::PageBuf,
-        message::{StoredDispatch, StoredMessage},
+        message::{StoredDelayedDispatch, StoredDispatch, StoredMessage},
         pages::{GearPage, PageU32Size, WasmPage},
     };
     use primitive_types::H256;
@@ -62,7 +62,10 @@ pub mod pallet {
         /// Storage with codes for programs.
         type CodeStorage: CodeStorage;
 
-        type Messenger: Messenger<QueuedDispatch = StoredDispatch>;
+        type Messenger: Messenger<
+            QueuedDispatch = StoredDispatch,
+            DelayedDispatch = StoredDelayedDispatch,
+        >;
 
         type ProgramStorage: ProgramStorage
             + IterableMap<(ProgramId, common::Program<BlockNumberFor<Self>>)>;

pallets/gear-messenger/Cargo.toml

@@ -38,6 +38,7 @@ pallet-authorship = { workspace = true, features = ["std"] }
 pallet-timestamp = { workspace = true, features = ["std"] }
 env_logger.workspace = true
 common = { workspace = true, features = ["std"] }
+rand.workspace = true
 
 [features]
 default = ['std']

pallets/gear-messenger/src/lib.rs

@@ -136,6 +136,8 @@
 #![doc(html_logo_url = "https://docs.gear.rs/logo.svg")]
 #![doc(html_favicon_url = "https://gear-tech.io/favicons/favicon.ico")]
 
+pub mod migrations;
+
 // Runtime mock for running tests.
 #[cfg(test)]
 mod mock;
@@ -161,12 +163,12 @@ pub mod pallet {
     use frame_system::pallet_prelude::BlockNumberFor;
     use gear_core::{
         ids::{MessageId, ProgramId},
-        message::{StoredDispatch, UserStoredMessage},
+        message::{StoredDelayedDispatch, StoredDispatch, UserStoredMessage},
     };
     use sp_std::{convert::TryInto, marker::PhantomData};
 
     /// The current storage version.
-    pub(crate) const MESSENGER_STORAGE_VERSION: StorageVersion = StorageVersion::new(2);
+    pub(crate) const MESSENGER_STORAGE_VERSION: StorageVersion = StorageVersion::new(3);
 
     // Gear Messenger Pallet's `Config`.
     #[pallet::config]
@@ -413,14 +415,14 @@ pub mod pallet {
     // Private storage for dispatch stash elements.
     #[pallet::storage]
     pub type DispatchStash<T: Config> =
-        StorageMap<_, Identity, MessageId, (StoredDispatch, Interval<BlockNumberFor<T>>)>;
+        StorageMap<_, Identity, MessageId, (StoredDelayedDispatch, Interval<BlockNumberFor<T>>)>;
 
     // Public wrap of the dispatch stash elements.
     common::wrap_storage_map!(
         storage: DispatchStash,
         name: DispatchStashWrap,
         key: MessageId,
-        value: (StoredDispatch, Interval<BlockNumberFor<T>>)
+        value: (StoredDelayedDispatch, Interval<BlockNumberFor<T>>)
     );
 
     // ----
@@ -591,6 +593,7 @@ pub mod pallet {
         type MailboxSecondKey = MessageId;
         type MailboxedMessage = UserStoredMessage;
         type QueuedDispatch = StoredDispatch;
+        type DelayedDispatch = StoredDelayedDispatch;
         type WaitlistFirstKey = ProgramId;
         type WaitlistSecondKey = MessageId;
         type WaitlistedMessage = StoredDispatch;