refactor(core): Add nonce to program id generation

core-backend/common/src/funcs.rs

@@ -732,8 +732,13 @@ where
         let salt = Self::read_message_payload(ctx, read_salt)?;
         let payload = Self::read_message_payload(ctx, read_payload)?;
 
+        let message_id = ctx.ext_mut().message_id()?;
+
         ctx.ext_mut()
-            .create_program(InitPacket::new(code_id.into(), salt, payload, value), delay)
+            .create_program(
+                InitPacket::new(code_id.into(), salt, payload, Some(message_id), value),
+                delay,
+            )
             .map_err(Into::into)
     }
 

core-processor/src/ext.rs

@@ -1070,7 +1070,8 @@ impl Externalities for Ext {
         packet: InitPacket,
         delay: u32,
     ) -> Result<(MessageId, ProgramId), Self::FallibleError> {
-        self.check_forbidden_destination(packet.destination())?;
+        // We don't check for forbidden destination here, since dest is always unique and almost impossible to match SYSTEM_ID
+
         self.safe_gasfull_sends(&packet)?;
         self.charge_expiring_resources(&packet, true)?;
         self.charge_sending_fee(delay)?;

core/src/ids.rs

@@ -204,12 +204,20 @@ impl ProgramId {
     pub const SYSTEM: Self = Self(*b"geargeargeargeargeargeargeargear");
 
     /// Generate ProgramId from given CodeId and salt
-    pub fn generate(code_id: CodeId, salt: &[u8]) -> Self {
-        const SALT: &[u8] = b"program";
+    pub fn generate_from_user(code_id: CodeId, salt: &[u8]) -> Self {
+        const SALT: &[u8] = b"program_from_user";
 
         let argument = [SALT, code_id.as_ref(), salt].concat();
         hash(&argument).into()
     }
+
+    /// Generate ProgramId from given CodeId, MessageId and salt
+    pub fn generate_from_program(code_id: CodeId, salt: &[u8], message_id: MessageId) -> Self {
+        const SALT: &[u8] = b"program_from_wasm";
+
+        let argument = [SALT, message_id.as_ref(), code_id.as_ref(), salt].concat();
+        hash(&argument).into()
+    }
 }
 
 declare_id!(ReservationId: "Reservation identifier");
@@ -229,36 +237,36 @@ fn formatting_test() {
     use alloc::format;
 
     let code_id = CodeId::generate(&[0, 1, 2]);
-    let id = ProgramId::generate(code_id, &[2, 1, 0]);
+    let id = ProgramId::generate_from_user(code_id, &[2, 1, 0]);
 
     // `Debug`/`Display`.
     assert_eq!(
         format!("{id:?}"),
-        "0x227e53192dc14699539c44608810a8202d6a2bee92078e6913b1bdf38925fa67"
+        "0x6a519a19ffdfd8f45c310b44aecf156b080c713bf841a8cb695b0ea5f765ed3e"
     );
     // `Debug`/`Display` with precision 0.
     assert_eq!(format!("{id:.0?}"), "0x..");
     // `Debug`/`Display` with precision 1.
-    assert_eq!(format!("{id:.1?}"), "0x22..67");
+    assert_eq!(format!("{id:.1?}"), "0x6a..3e");
     // `Debug`/`Display` with precision 2.
-    assert_eq!(format!("{id:.2?}"), "0x227e..fa67");
+    assert_eq!(format!("{id:.2?}"), "0x6a51..ed3e");
     // `Debug`/`Display` with precision 4.
-    assert_eq!(format!("{id:.4?}"), "0x227e5319..8925fa67");
+    assert_eq!(format!("{id:.4?}"), "0x6a519a19..f765ed3e");
     // `Debug`/`Display` with precision 15.
     assert_eq!(
         format!("{id:.15?}"),
-        "0x227e53192dc14699539c44608810a8..6a2bee92078e6913b1bdf38925fa67"
+        "0x6a519a19ffdfd8f45c310b44aecf15..0c713bf841a8cb695b0ea5f765ed3e"
     );
     // `Debug`/`Display` with precision 30 (the same for any case >= 16).
     assert_eq!(
         format!("{id:.30?}"),
-        "0x227e53192dc14699539c44608810a8202d6a2bee92078e6913b1bdf38925fa67"
+        "0x6a519a19ffdfd8f45c310b44aecf156b080c713bf841a8cb695b0ea5f765ed3e"
     );
     // Alternate formatter.
     assert_eq!(
         format!("{id:#}"),
-        "ProgramId(0x227e53192dc14699539c44608810a8202d6a2bee92078e6913b1bdf38925fa67)"
+        "ProgramId(0x6a519a19ffdfd8f45c310b44aecf156b080c713bf841a8cb695b0ea5f765ed3e)"
     );
     // Alternate formatter with precision 2.
-    assert_eq!(format!("{id:#.2}"), "ProgramId(0x227e..fa67)");
+    assert_eq!(format!("{id:#.2}"), "ProgramId(0x6a51..ed3e)");
 }

core/src/message/init.rs

@@ -110,6 +110,7 @@ impl InitMessage {
     }
 }
 
+// TODO: #issue 3320
 /// Init message packet.
 ///
 /// This structure is preparation for future init message sending. Has no message id.
@@ -131,9 +132,20 @@ pub struct InitPacket {
 
 impl InitPacket {
     /// Create new InitPacket without gas.
-    pub fn new(code_id: CodeId, salt: Salt, payload: Payload, value: Value) -> Self {
+    pub fn new(
+        code_id: CodeId,
+        salt: Salt,
+        payload: Payload,
+        message_id: Option<MessageId>,
+        value: Value,
+    ) -> Self {
+        let program_id = if let Some(id) = message_id {
+            ProgramId::generate_from_program(code_id, salt.inner(), id)
+        } else {
+            ProgramId::generate_from_user(code_id, salt.inner())
+        };
         Self {
-            program_id: ProgramId::generate(code_id, salt.inner()),
+            program_id,
             code_id,
             salt,
             payload,
@@ -147,11 +159,17 @@ impl InitPacket {
         code_id: CodeId,
         salt: Salt,
         payload: Payload,
+        message_id: Option<MessageId>,
         gas_limit: GasLimit,
         value: Value,
     ) -> Self {
+        let program_id = if let Some(id) = message_id {
+            ProgramId::generate_from_program(code_id, salt.inner(), id)
+        } else {
+            ProgramId::generate_from_user(code_id, salt.inner())
+        };
         Self {
-            program_id: ProgramId::generate(code_id, salt.inner()),
+            program_id,
             code_id,
             salt,
             payload,

examples/program-factory/src/lib.rs

@@ -93,10 +93,13 @@ mod tests {
         sys.init_logger();
         let factory = prepare_factory(&sys);
 
-        let child_id_expected = calculate_program_id(CHILD_CODE_HASH.into(), &0i32.to_le_bytes());
-
         // Send `handle` msg to factory to create a new child
         let res = factory.send_bytes(10001, CreateProgram::Default.encode());
+        let child_id_expected = calculate_program_id(
+            CHILD_CODE_HASH.into(),
+            &0i32.to_le_bytes(),
+            Some(res.sent_message_id()),
+        );
         assert!(!res.main_failed());
         assert!(sys.is_active_program(child_id_expected));
     }
@@ -108,20 +111,26 @@ mod tests {
         let factory = prepare_factory(&sys);
 
         let salt = 0i32.to_be_bytes();
-        let child_id_expected = calculate_program_id(CHILD_CODE_HASH.into(), &salt);
         let payload = CreateProgram::Custom(vec![(CHILD_CODE_HASH, salt.to_vec(), 100_000_000)]);
 
         // Send `handle` msg to factory to create a new child
         let res = factory.send_bytes(10001, payload.encode());
+
+        let child_id_expected =
+            calculate_program_id(CHILD_CODE_HASH.into(), &salt, Some(res.sent_message_id()));
+
         assert!(!res.main_failed());
         assert!(sys.is_active_program(child_id_expected));
 
         // Send `handle` msg to create a duplicate
         let res = factory.send_bytes(10001, payload.encode());
+
+        let child_id_expected =
+            calculate_program_id(CHILD_CODE_HASH.into(), &salt, Some(res.sent_message_id()));
+
         assert!(!res.main_failed());
-        // Init message, which is not processed. Error reply for that init is generated.
-        // Dispatch message is processed, no error replies, because message is sent to
-        // the original program.
+        assert!(sys.is_active_program(child_id_expected));
+
         assert_eq!(res.total_processed(), 3 + 1 + 1); // +1 for the original message, initiated by user +1 for auto generated replies
     }
 
@@ -134,9 +143,13 @@ mod tests {
         // Non existing code hash provided
         let non_existing_code_hash = [10u8; 32];
         let salt = b"some_salt";
-        let fictional_program_id = calculate_program_id(non_existing_code_hash.into(), salt);
         let payload = CreateProgram::Custom(vec![(non_existing_code_hash, salt.to_vec(), 100_000)]);
         let res = factory.send_bytes(10001, payload.encode());
+        let fictional_program_id = calculate_program_id(
+            non_existing_code_hash.into(),
+            salt,
+            Some(res.sent_message_id()),
+        );
         assert!(!res.main_failed());
         // No new program with fictional id
         assert!(sys.is_active_program(fictional_program_id));

gcli/tests/common/mod.rs

@@ -102,7 +102,7 @@ pub fn login_as_alice() -> Result<()> {
 
 /// Generate program id from code id and salt
 pub fn program_id(bin: &[u8], salt: &[u8]) -> ProgramId {
-    ProgramId::generate(CodeId::generate(bin), salt)
+    ProgramId::generate_from_user(CodeId::generate(bin), salt)
 }
 
 /// AccountId32 of `addr`

gsdk/tests/rpc.rs

@@ -109,7 +109,7 @@ async fn test_calculate_handle_gas() -> Result<()> {
     let node = dev_node();
 
     let salt = vec![];
-    let pid = ProgramId::generate(CodeId::generate(demo_messager::WASM_BINARY), &salt);
+    let pid = ProgramId::generate_from_user(CodeId::generate(demo_messager::WASM_BINARY), &salt);
 
     // 1. upload program.
     let signer = Api::new(Some(&node_uri(&node)))
@@ -150,7 +150,8 @@ async fn test_calculate_reply_gas() -> Result<()> {
     let alice: [u8; 32] = *alice_account_id().as_ref();
 
     let salt = vec![];
-    let pid = ProgramId::generate(CodeId::generate(demo_waiter::WASM_BINARY), &salt);
+
+    let pid = ProgramId::generate_from_user(CodeId::generate(demo_waiter::WASM_BINARY), &salt);
     let payload = demo_waiter::Command::SendUpTo(alice, 10);
 
     // 1. upload program.
@@ -294,7 +295,7 @@ async fn test_original_code_storage() -> Result<()> {
     let node = dev_node();
 
     let salt = vec![];
-    let pid = ProgramId::generate(CodeId::generate(demo_messager::WASM_BINARY), &salt);
+    let pid = ProgramId::generate_from_user(CodeId::generate(demo_messager::WASM_BINARY), &salt);
 
     let signer = Api::new(Some(&node_uri(&node)))
         .await?

gtest/src/program.rs

@@ -649,8 +649,12 @@ fn read_file<P: AsRef<Path>>(path: P, extension: &str) -> Vec<u8> {
     fs::read(&path).unwrap_or_else(|_| panic!("Failed to read file {:?}", path))
 }
 
-pub fn calculate_program_id(code_id: CodeId, salt: &[u8]) -> ProgramId {
-    ProgramId::generate(code_id, salt)
+pub fn calculate_program_id(code_id: CodeId, salt: &[u8], id: Option<MessageId>) -> ProgramId {
+    if let Some(id) = id {
+        ProgramId::generate_from_program(code_id, salt, id)
+    } else {
+        ProgramId::generate_from_user(code_id, salt)
+    }
 }
 
 #[cfg(test)]

pallets/gear-debug/src/tests/mod.rs

@@ -144,8 +144,8 @@ fn debug_mode_works() {
         let code_1 = utils::parse_wat(wat_1);
         let code_2 = utils::parse_wat(wat_2);
 
-        let program_id_1 = ProgramId::generate(CodeId::generate(&code_1), DEFAULT_SALT);
-        let program_id_2 = ProgramId::generate(CodeId::generate(&code_2), DEFAULT_SALT);
+        let program_id_1 = ProgramId::generate_from_user(CodeId::generate(&code_1), DEFAULT_SALT);
+        let program_id_2 = ProgramId::generate_from_user(CodeId::generate(&code_2), DEFAULT_SALT);
 
         PalletGear::<Test>::upload_program(
             RuntimeOrigin::signed(1),
@@ -200,19 +200,19 @@ fn debug_mode_works() {
                 dispatch_queue: vec![],
                 programs: vec![
                     crate::ProgramDetails {
-                        id: program_id_1,
+                        id: program_id_2,
                         state: crate::ProgramState::Active(crate::ProgramInfo {
                             static_pages,
                             persistent_pages: Default::default(),
-                            code_hash: utils::h256_code_hash(&code_1),
+                            code_hash: utils::h256_code_hash(&code_2),
                         }),
                     },
                     crate::ProgramDetails {
-                        id: program_id_2,
+                        id: program_id_1,
                         state: crate::ProgramState::Active(crate::ProgramInfo {
                             static_pages,
                             persistent_pages: Default::default(),
-                            code_hash: utils::h256_code_hash(&code_2),
+                            code_hash: utils::h256_code_hash(&code_1),
                         }),
                     },
                 ],
@@ -278,19 +278,19 @@ fn debug_mode_works() {
                 ],
                 programs: vec![
                     crate::ProgramDetails {
-                        id: program_id_1,
+                        id: program_id_2,
                         state: crate::ProgramState::Active(crate::ProgramInfo {
                             static_pages,
                             persistent_pages: Default::default(),
-                            code_hash: utils::h256_code_hash(&code_1),
+                            code_hash: utils::h256_code_hash(&code_2),
                         }),
                     },
                     crate::ProgramDetails {
-                        id: program_id_2,
+                        id: program_id_1,
                         state: crate::ProgramState::Active(crate::ProgramInfo {
                             static_pages,
                             persistent_pages: Default::default(),
-                            code_hash: utils::h256_code_hash(&code_2),
+                            code_hash: utils::h256_code_hash(&code_1),
                         }),
                     },
                 ],
@@ -307,19 +307,19 @@ fn debug_mode_works() {
                 dispatch_queue: vec![],
                 programs: vec![
                     crate::ProgramDetails {
-                        id: program_id_1,
+                        id: program_id_2,
                         state: crate::ProgramState::Active(crate::ProgramInfo {
                             static_pages,
                             persistent_pages: Default::default(),
-                            code_hash: utils::h256_code_hash(&code_1),
+                            code_hash: utils::h256_code_hash(&code_2),
                         }),
                     },
                     crate::ProgramDetails {
-                        id: program_id_2,
+                        id: program_id_1,
                         state: crate::ProgramState::Active(crate::ProgramInfo {
                             static_pages,
                             persistent_pages: Default::default(),
-                            code_hash: utils::h256_code_hash(&code_2),
+                            code_hash: utils::h256_code_hash(&code_1),
                         }),
                     },
                 ],
@@ -513,7 +513,7 @@ fn check_not_allocated_pages() {
     init_logger();
     new_test_ext().execute_with(|| {
         let code = parse_wat(wat);
-        let program_id = ProgramId::generate(CodeId::generate(&code), DEFAULT_SALT);
+        let program_id = ProgramId::generate_from_user(CodeId::generate(&code), DEFAULT_SALT);
         let origin = RuntimeOrigin::signed(1);
 
         assert_ok!(PalletGear::<Test>::upload_program(
@@ -732,7 +732,7 @@ fn check_changed_pages_in_storage() {
     init_logger();
     new_test_ext().execute_with(|| {
         let code = parse_wat(wat);
-        let program_id = ProgramId::generate(CodeId::generate(&code), DEFAULT_SALT);
+        let program_id = ProgramId::generate_from_user(CodeId::generate(&code), DEFAULT_SALT);
         let origin = RuntimeOrigin::signed(1);
 
         // Code info. Must be in consensus with wasm code.
@@ -870,7 +870,7 @@ fn check_gear_stack_end() {
     init_logger();
     new_test_ext().execute_with(|| {
         let code = utils::parse_wat(wat.as_str());
-        let program_id = ProgramId::generate(CodeId::generate(&code), DEFAULT_SALT);
+        let program_id = ProgramId::generate_from_user(CodeId::generate(&code), DEFAULT_SALT);
         let origin = RuntimeOrigin::signed(1);
 
         assert_ok!(PalletGear::<Test>::upload_program(
@@ -926,7 +926,8 @@ fn disabled_program_rent() {
     init_logger();
     new_test_ext().execute_with(|| {
         let salt = b"salt".to_vec();
-        let pay_rent_id = ProgramId::generate(CodeId::generate(TEST_SYSCALLS_BINARY), &salt);
+        let pay_rent_id =
+            ProgramId::generate_from_user(CodeId::generate(TEST_SYSCALLS_BINARY), &salt);
 
         let program_value = 10_000_000;
         assert_ok!(Gear::upload_program(