Address a bug with message during instantiation. (#4366)

## Motivation

The scenario of a smart contract emitting a message during instantiation
breaks the `TestValidator` framework.
We address the problem here.

Fixes #3539 

## Proposal

The correction pointed out in the issue is exactly what is needed.
A smart contract has been created that demonstrates that the correction
works and also test
in the end-to-end test, which is nice to check.

## Test Plan

CI.

## Release Plan

- Nothing to do / These changes follow the usual release cycle.

## Links

None.

Author: MathieuDutSik

Cargo.lock

@@ -315,6 +315,7 @@ native-fungible = { path = "./examples/native-fungible" }
 non-fungible = { path = "./examples/non-fungible" }
 publish-read-data-blob = { path = "./examples/publish-read-data-blob" }
 social = { path = "./examples/social" }
+track-instantiation = { path = "./examples/track-instantiation" }
 
 [workspace.dependencies.aws-config]
 default-features = false

Cargo.toml

@@ -21,6 +21,7 @@ members = [
     "publish-read-data-blob",
     "rfq",
     "social",
+    "track-instantiation",
 ]
 
 [workspace.dependencies]

examples/Cargo.lock

@@ -0,0 +1,21 @@
+[package]
+name = "track-instantiation"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+linera-sdk = { path = "../../linera-sdk" }
+serde = { version = "1.0", features = ["derive"] }
+
+[target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
+futures = "0.3"
+linera-sdk = { workspace = true, features = ["test", "wasmer"] }
+tokio.workspace = true
+
+[[bin]]
+name = "track_instantiation_contract"
+path = "src/contract.rs"
+
+[[bin]]
+name = "track_instantiation_service"
+path = "src/service.rs"

examples/Cargo.toml

@@ -0,0 +1,65 @@
+// Copyright (c) Zefchain Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+#![cfg_attr(target_arch = "wasm32", no_main)]
+
+mod state;
+
+use linera_sdk::{
+    linera_base_types::WithContractAbi,
+    views::{RootView, View},
+    Contract, ContractRuntime,
+};
+use track_instantiation::TrackInstantiationAbi;
+
+use self::state::TrackInstantiationState;
+
+pub struct TrackInstantiationContract {
+    state: TrackInstantiationState,
+    runtime: ContractRuntime<Self>,
+}
+
+linera_sdk::contract!(TrackInstantiationContract);
+
+impl WithContractAbi for TrackInstantiationContract {
+    type Abi = TrackInstantiationAbi;
+}
+
+impl Contract for TrackInstantiationContract {
+    type Message = ();
+    type InstantiationArgument = ();
+    type Parameters = ();
+    type EventValue = ();
+
+    async fn load(runtime: ContractRuntime<Self>) -> Self {
+        let state = TrackInstantiationState::load(runtime.root_view_storage_context())
+            .await
+            .expect("Failed to load state");
+
+        TrackInstantiationContract { state, runtime }
+    }
+
+    async fn instantiate(&mut self, _argument: ()) {
+        self.runtime.application_parameters();
+
+        // Send message to creator chain about instantiation
+        let creator_chain = self.runtime.application_creator_chain_id();
+        self.runtime
+            .prepare_message(())
+            .with_authentication()
+            .send_to(creator_chain);
+    }
+
+    async fn execute_operation(&mut self, _operation: ()) {
+        panic!("No operation being executed");
+    }
+
+    async fn execute_message(&mut self, _message: ()) {
+        let count = self.state.stats.get_mut();
+        *count += 1;
+    }
+
+    async fn store(mut self) {
+        self.state.save().await.expect("Failed to save state");
+    }
+}

examples/track-instantiation/Cargo.toml

@@ -0,0 +1,24 @@
+// Copyright (c) Zefchain Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/*! ABI of the Track Instantiation Load Operation Application */
+
+use linera_sdk::linera_base_types::{ContractAbi, ServiceAbi};
+use serde::{Deserialize, Serialize};
+
+pub struct TrackInstantiationAbi;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum Query {
+    GetCount,
+}
+
+impl ContractAbi for TrackInstantiationAbi {
+    type Operation = ();
+    type Response = ();
+}
+
+impl ServiceAbi for TrackInstantiationAbi {
+    type Query = Query;
+    type QueryResponse = u64;
+}

examples/track-instantiation/src/contract.rs

@@ -0,0 +1,38 @@
+// Copyright (c) Zefchain Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+#![cfg_attr(target_arch = "wasm32", no_main)]
+
+mod state;
+
+use linera_sdk::{linera_base_types::WithServiceAbi, views::View, Service, ServiceRuntime};
+use track_instantiation::{Query, TrackInstantiationAbi};
+
+use self::state::TrackInstantiationState;
+
+pub struct TrackInstantiationService {
+    state: TrackInstantiationState,
+}
+
+linera_sdk::service!(TrackInstantiationService);
+
+impl WithServiceAbi for TrackInstantiationService {
+    type Abi = TrackInstantiationAbi;
+}
+
+impl Service for TrackInstantiationService {
+    type Parameters = ();
+
+    async fn new(runtime: ServiceRuntime<Self>) -> Self {
+        let state = TrackInstantiationState::load(runtime.root_view_storage_context())
+            .await
+            .expect("Failed to load state");
+        TrackInstantiationService { state }
+    }
+
+    async fn handle_query(&self, query: Query) -> u64 {
+        match query {
+            Query::GetCount => *self.state.stats.get(),
+        }
+    }
+}

examples/track-instantiation/src/lib.rs

@@ -0,0 +1,11 @@
+// Copyright (c) Zefchain Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+use linera_sdk::views::{linera_views, RegisterView, RootView, ViewStorageContext};
+
+/// The application state.
+#[derive(RootView)]
+#[view(context = ViewStorageContext)]
+pub struct TrackInstantiationState {
+    pub stats: RegisterView<u64>,
+}

examples/track-instantiation/src/service.rs

@@ -0,0 +1,30 @@
+// Copyright (c) Zefchain Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+//! Integration tests for the Fungible Token application.
+
+#![cfg(not(target_arch = "wasm32"))]
+
+use linera_sdk::test::TestValidator;
+use track_instantiation::{Query, TrackInstantiationAbi};
+
+/// Test transferring tokens across microchains.
+///
+/// Creates the application on a `sender_chain`, initializing it with a single account with some
+/// tokens for that chain's owner. Transfers some of those tokens to a new `receiver_chain`, and
+/// checks that the balances on each microchain are correct.
+#[tokio::test]
+async fn test_instantiation_messages() {
+    let (validator, module_id) =
+        TestValidator::with_current_module::<TrackInstantiationAbi, (), ()>().await;
+    let mut sender_chain = validator.new_chain().await;
+
+    let application_id = sender_chain
+        .create_application(module_id, (), (), vec![])
+        .await;
+
+    sender_chain.handle_received_messages().await;
+
+    let query = Query::GetCount;
+    assert_eq!(sender_chain.query(application_id, query).await.response, 1);
+}