refactor(core): Guarantee system accounts existence for programs

Cargo.toml

@@ -36,6 +36,7 @@ members = [
     "examples/delayed-reservation-sender",
     "examples/compose",
     "examples/constructor",
+    "examples/create-program-reentrance",
     "examples/delayed-sender",
     "examples/distributor",
     "examples/fungible-token",
@@ -69,6 +70,7 @@ members = [
     "examples/sync-duplicate",
     "examples/syscalls",
     "examples/syscall-error",
+    "examples/value-sender",
     "examples/vec",
     "examples/wait",
     "examples/wait-timeout",
@@ -406,6 +408,7 @@ demo-custom = { path = "examples/custom" }
 demo-delayed-reservation-sender = { path = "examples/delayed-reservation-sender" }
 demo-compose = { path = "examples/compose" }
 demo-constructor = { path = "examples/constructor", default-features = false }
+demo-create-program-reentrance = { path = "examples/create-program-reentrance" }
 demo-delayed-sender = { path = "examples/delayed-sender" }
 demo-distributor = { path = "examples/distributor" }
 demo-futures-unordered = { path = "examples/futures-unordered", features = ["debug"] }
@@ -437,6 +440,7 @@ demo-signal-entry = { path = "examples/signal-entry", default-features = false }
 demo-state-rollback = { path = "examples/state-rollback" }
 demo-sync-duplicate = { path = "examples/sync-duplicate" }
 demo-vec = { path = "examples/vec" }
+demo-value-sender = { path = "examples/value-sender" }
 demo-wait = { path = "examples/wait" }
 demo-waiter = { path = "examples/waiter", default-features = false }
 demo-wait-timeout = { path = "examples/wait-timeout" }

common/src/pallet_tests.rs

@@ -25,6 +25,20 @@ use frame_system::limits::BlockWeights;
 
 #[macro_export]
 macro_rules! impl_pallet_balances {
+    ($( $tokens:tt )*) => {
+        #[allow(dead_code)]
+        type BalancesConfigDustRemoval = ();
+
+        mod pallet_tests_balances_config_impl {
+            use super::*;
+
+            $crate::impl_pallet_balances_inner!($( $tokens )*);
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! impl_pallet_balances_inner {
     ($runtime:ty) => {
         impl pallet_balances::Config for $runtime {
             type MaxLocks = ();
@@ -36,13 +50,19 @@ macro_rules! impl_pallet_balances {
             type RuntimeHoldReason = RuntimeHoldReason;
             type ReserveIdentifier = [u8; 8];
             type Balance = Balance;
-            type DustRemoval = ();
+            type DustRemoval = BalancesConfigDustRemoval;
             type RuntimeEvent = RuntimeEvent;
             type ExistentialDeposit = ExistentialDeposit;
             type AccountStore = System;
             type WeightInfo = ();
         }
     };
+
+    ($runtime:ty, DustRemoval = $dust_removal:ty $(, $( $rest:tt )*)?) => {
+        type BalancesConfigDustRemoval = $dust_removal;
+
+        $crate::impl_pallet_balances_inner!($runtime $(, $( $rest )*)?);
+    };
 }
 
 pub const NORMAL_DISPATCH_RATIO: Perbill = Perbill::from_percent(75);

core-processor/src/common.rs

@@ -264,6 +264,8 @@ pub enum JournalNote {
     },
     /// Store programs requested by user to be initialized later
     StoreNewPrograms {
+        /// Current program id.
+        program_id: ProgramId,
         /// Code hash used to create new programs with ids in `candidates` field
         code_id: CodeId,
         /// Collection of program candidate ids and their init message ids.
@@ -386,7 +388,12 @@ pub trait JournalHandler {
     /// Store new programs in storage.
     ///
     /// Program ids are ids of _potential_ (planned to be initialized) programs.
-    fn store_new_programs(&mut self, code_id: CodeId, candidates: Vec<(MessageId, ProgramId)>);
+    fn store_new_programs(
+        &mut self,
+        program_id: ProgramId,
+        code_id: CodeId,
+        candidates: Vec<(MessageId, ProgramId)>,
+    );
     /// Stop processing queue.
     ///
     /// Pushes StoredDispatch back to the top of the queue and decreases gas allowance.

core-processor/src/ext.rs

@@ -484,16 +484,6 @@ impl<LP: LazyPagesInterface> BackendExternalities for Ext<LP> {
 }
 
 impl<LP: LazyPagesInterface> Ext<LP> {
-    fn check_message_value(&mut self, message_value: u128) -> Result<(), FallibleExtError> {
-        let existential_deposit = self.context.existential_deposit;
-        // Sending value should apply the range {0} ∪ [existential_deposit; +inf)
-        if message_value != 0 && message_value < existential_deposit {
-            Err(MessageError::InsufficientValue.into())
-        } else {
-            Ok(())
-        }
-    }
-
     fn check_gas_limit(
         &mut self,
         gas_limit: Option<GasLimit>,
@@ -620,7 +610,6 @@ impl<LP: LazyPagesInterface> Ext<LP> {
         packet: &T,
         check_gas_limit: bool,
     ) -> Result<(), FallibleExtError> {
-        self.check_message_value(packet.value())?;
         // Charge for using expiring resources. Charge for calling syscall was done earlier.
         let gas_limit = if check_gas_limit {
             self.check_gas_limit(packet.gas_limit())?
@@ -902,7 +891,6 @@ impl<LP: LazyPagesInterface> Externalities for Ext<LP> {
         delay: u32,
     ) -> Result<MessageId, Self::FallibleError> {
         self.check_forbidden_destination(msg.destination())?;
-        self.check_message_value(msg.value())?;
         // TODO: unify logic around different source of gas (may be origin msg,
         // or reservation) in order to implement #1828.
         self.check_reservation_gas_limit_for_delayed_sending(&id, delay)?;
@@ -941,7 +929,6 @@ impl<LP: LazyPagesInterface> Externalities for Ext<LP> {
         msg: ReplyPacket,
     ) -> Result<MessageId, Self::FallibleError> {
         self.check_forbidden_destination(self.context.message_context.reply_destination())?;
-        self.check_message_value(msg.value())?;
         // TODO: gasful sending (#1828)
         self.charge_message_value(msg.value())?;
         self.charge_sending_fee(0)?;
@@ -1221,6 +1208,9 @@ impl<LP: LazyPagesInterface> Externalities for Ext<LP> {
         self.charge_sending_fee(delay)?;
         self.charge_for_dispatch_stash_hold(delay)?;
 
+        // Charge ED to value_counter
+        self.charge_message_value(self.context.existential_deposit)?;
+
         let code_hash = packet.code_id();
 
         // Send a message for program creation
@@ -1347,6 +1337,18 @@ mod tests {
 
             self
         }
+
+        fn with_existential_deposit(mut self, ed: u128) -> Self {
+            self.0.existential_deposit = ed;
+
+            self
+        }
+
+        fn with_value(mut self, value: u128) -> Self {
+            self.0.value_counter = ValueCounter::new(value);
+
+            self
+        }
     }
 
     // Invariant: Refund never occurs in `free` call.
@@ -1844,4 +1846,93 @@ mod tests {
             ReservationError::InvalidReservationId.into()
         );
     }
+
+    #[test]
+    // This function tests:
+    //
+    // - `create_program` fails due to lack of value to pay for ED
+    // - `create_program` is successful
+    fn test_create_program() {
+        let mut ext = Ext::new(
+            ProcessorContextBuilder::new()
+                .with_message_context(MessageContextBuilder::new().build())
+                .with_existential_deposit(500)
+                .build(),
+        );
+
+        let data = InitPacket::default();
+
+        let msg = ext.create_program(data.clone(), 0);
+        assert_eq!(
+            msg.unwrap_err(),
+            FallibleExtError::Core(FallibleExtErrorCore::Execution(
+                FallibleExecutionError::NotEnoughValue
+            ))
+        );
+
+        let mut ext = Ext::new(
+            ProcessorContextBuilder::new()
+                .with_gas(GasCounter::new(u64::MAX))
+                .with_message_context(MessageContextBuilder::new().build())
+                .with_existential_deposit(500)
+                .with_value(1500)
+                .build(),
+        );
+
+        let msg = ext.create_program(data.clone(), 0);
+        assert!(msg.is_ok());
+    }
+
+    #[test]
+    // This function tests:
+    //
+    // - `send_commit` with value greater than the ED
+    // - `send_commit` with value below the ED
+    fn test_send_commit_with_value() {
+        let mut ext = Ext::new(
+            ProcessorContextBuilder::new()
+                .with_message_context(
+                    MessageContextBuilder::new()
+                        .with_outgoing_limit(u32::MAX)
+                        .build(),
+                )
+                .with_existential_deposit(500)
+                .build(),
+        );
+
+        let data = HandlePacket::new(ProgramId::default(), Payload::default(), 1000);
+
+        let handle = ext.send_init().expect("No outgoing limit");
+
+        let msg = ext.send_commit(handle, data.clone(), 0);
+        assert_eq!(
+            msg.unwrap_err(),
+            FallibleExtError::Core(FallibleExtErrorCore::Execution(
+                FallibleExecutionError::NotEnoughValue
+            ))
+        );
+
+        let mut ext = Ext::new(
+            ProcessorContextBuilder::new()
+                .with_message_context(
+                    MessageContextBuilder::new()
+                        .with_outgoing_limit(u32::MAX)
+                        .build(),
+                )
+                .with_existential_deposit(500)
+                .with_value(5000)
+                .build(),
+        );
+
+        let handle = ext.send_init().expect("No outgoing limit");
+        // Sending value greater than ED is ok
+        let msg = ext.send_commit(handle, data.clone(), 0);
+        assert!(msg.is_ok());
+
+        let data = HandlePacket::new(ProgramId::default(), Payload::default(), 100);
+        let handle = ext.send_init().expect("No outgoing limit");
+        let msg = ext.send_commit(handle, data, 0);
+        // Sending value below ED is also fine
+        assert!(msg.is_ok());
+    }
 }

core-processor/src/handler.rs

@@ -74,9 +74,10 @@ pub fn handle_journal(
             }
             JournalNote::SendValue { from, to, value } => handler.send_value(from, to, value),
             JournalNote::StoreNewPrograms {
+                program_id,
                 code_id,
                 candidates,
-            } => handler.store_new_programs(code_id, candidates),
+            } => handler.store_new_programs(program_id, code_id, candidates),
             JournalNote::StopProcessing {
                 dispatch,
                 gas_burned,

core-processor/src/processing.rs

@@ -446,6 +446,7 @@ pub fn process_success(
     // Must be handled before handling generated dispatches.
     for (code_id, candidates) in program_candidates {
         journal.push(JournalNote::StoreNewPrograms {
+            program_id,
             code_id,
             candidates,
         });

examples/create-program-reentrance/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "demo-create-program-reentrance"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+homepage.workspace = true
+repository.workspace = true
+
+[dependencies]
+gstd.workspace = true
+hex.workspace = true
+
+[build-dependencies]
+gear-wasm-builder.workspace = true
+
+[features]
+debug = ["gstd/debug"]
+wasm-wrapper = []
+std = ["wasm-wrapper"]
+default = ["std"]

examples/create-program-reentrance/build.rs

@@ -0,0 +1,25 @@
+// This file is part of Gear.
+
+// Copyright (C) 2021-2024 Gear Technologies Inc.
+// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+use gear_wasm_builder::WasmBuilder;
+
+fn main() {
+    WasmBuilder::new()
+        .exclude_features(vec!["std", "wasm-wrapper"])
+        .build();
+}