Resolve the blob persistence problem (#4356)

## Motivation

Following PR #4247, PR #4278, and PR #3382, we face the scenario where a
contract can create a blob
but not have it available right away. This concerns the access to Blob
Bytecode, Blob ApplicationDescription, and
Blob Data.

This PR addresses those problems.

Fixes #4287 
Fixes #4279 

## Proposal

This PR addresses the problem with the data blob. But it also addresses
the issues for the ApplicationDescription blob
and the contract blobs.

There are three scenarios to cover:
* The blob is created in one block and read in another block.
* The blob is created in one operation and read in the same operation.
* The blob is created in two different operations of the same block.

The first scenario is already working correctly.

The second scenario is addressed with the addition of the test of
`created_blobs` in `ReadBlobContent`. This is done
in the same way as for access to the ApplicationDescription and the
Contract/Service.

The third scenario is addressed by the change in how the
TransactionTracker is built in `block_tracker`.

## Test Plan

The CI and the test in `test_wasm_end_to_end_publish_read_data_blob`,
which considers all 3 scenarios.

## Release Plan

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

## Links

None

Author: MathieuDutSik

Cargo.lock

@@ -313,6 +313,7 @@ matching-engine = { path = "./examples/matching-engine" }
 meta-counter = { path = "./examples/meta-counter" }
 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" }
 
 [workspace.dependencies.aws-config]

Cargo.toml

@@ -17,6 +17,7 @@ members = [
     "meta-counter",
     "native-fungible",
     "non-fungible",
+    "publish-read-data-blob",
     "rfq",
     "social",
 ]

examples/Cargo.lock

@@ -0,0 +1,25 @@
+[package]
+name = "publish-read-data-blob"
+version = "0.1.0"
+authors = ["Linera <[email protected]>"]
+edition = "2021"
+
+[dependencies]
+linera-sdk.workspace = true
+serde.workspace = true
+
+[target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
+linera-sdk = { workspace = true, features = ["test", "wasmer"] }
+tokio = { workspace = true, features = ["rt", "sync"] }
+
+[dev-dependencies]
+assert_matches.workspace = true
+linera-sdk = { workspace = true, features = ["test"] }
+
+[[bin]]
+name = "publish_read_data_blob_contract"
+path = "src/contract.rs"
+
+[[bin]]
+name = "publish_read_data_blob_service"
+path = "src/service.rs"

examples/Cargo.toml

@@ -0,0 +1,11 @@
+# Publish and read a data blob
+
+This example shows how to create a blob and how to read it.
+This example should be read in conjunction with the end-to-end
+test `test_wasm_end_to_end_publish_read_data_blob`.
+
+It shows 3 scenarios:
+* Publishing and reading blobs with the publishing and reading in different
+blocks.
+* Publishing and reading blobs in the same transaction.
+* Publishing and reqding blobs in the same block but not the same transaction

examples/publish-read-data-blob/Cargo.toml

@@ -0,0 +1,64 @@
+// 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::{DataBlobHash, WithContractAbi},
+    Contract, ContractRuntime,
+};
+use publish_read_data_blob::{Operation, PublishReadDataBlobAbi};
+
+pub struct PublishReadDataBlobContract {
+    runtime: ContractRuntime<Self>,
+}
+
+linera_sdk::contract!(PublishReadDataBlobContract);
+
+impl WithContractAbi for PublishReadDataBlobContract {
+    type Abi = PublishReadDataBlobAbi;
+}
+
+impl Contract for PublishReadDataBlobContract {
+    type Message = ();
+    type InstantiationArgument = ();
+    type Parameters = ();
+    type EventValue = ();
+
+    async fn load(runtime: ContractRuntime<Self>) -> Self {
+        PublishReadDataBlobContract { runtime }
+    }
+
+    async fn instantiate(&mut self, _argument: ()) {
+        // Validate that the application parameters were configured correctly.
+        self.runtime.application_parameters();
+    }
+
+    async fn execute_operation(&mut self, operation: Operation) {
+        match operation {
+            Operation::CreateDataBlob(data) => {
+                self.runtime.create_data_blob(data);
+            }
+            Operation::ReadDataBlob(hash, expected_data) => {
+                let data = self.runtime.read_data_blob(hash);
+                assert_eq!(
+                    data, expected_data,
+                    "Read data does not match expected data"
+                );
+            }
+            Operation::CreateAndReadDataBlob(data) => {
+                let hash: DataBlobHash = self.runtime.create_data_blob(data.clone());
+                let data_read = self.runtime.read_data_blob(hash);
+                assert_eq!(data_read, data);
+            }
+        }
+    }
+
+    async fn execute_message(&mut self, _message: ()) {
+        panic!("Publish-Read Data Blob application doesn't support any cross-chain messages");
+    }
+
+    async fn store(self) {}
+}

examples/publish-read-data-blob/README.md

@@ -0,0 +1,34 @@
+// Copyright (c) Zefchain Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/*! ABI of the Publish-Read Data Blob Example Application */
+
+use linera_sdk::linera_base_types::{ContractAbi, DataBlobHash, ServiceAbi};
+use serde::{Deserialize, Serialize};
+
+pub struct PublishReadDataBlobAbi;
+
+#[derive(Debug, Deserialize, Serialize)]
+pub enum Operation {
+    CreateDataBlob(Vec<u8>),
+    ReadDataBlob(DataBlobHash, Vec<u8>),
+    CreateAndReadDataBlob(Vec<u8>),
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub enum ServiceQuery {
+    PublishDataBlob(Vec<u8>),
+    ReadDataBlob(DataBlobHash, Vec<u8>),
+    PublishAndCreateOneOperation(Vec<u8>),
+    PublishAndCreateTwoOperations(Vec<u8>),
+}
+
+impl ContractAbi for PublishReadDataBlobAbi {
+    type Operation = Operation;
+    type Response = ();
+}
+
+impl ServiceAbi for PublishReadDataBlobAbi {
+    type Query = ServiceQuery;
+    type QueryResponse = Vec<u8>;
+}

examples/publish-read-data-blob/src/contract.rs

@@ -0,0 +1,68 @@
+// Copyright (c) Zefchain Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+#![cfg_attr(target_arch = "wasm32", no_main)]
+
+mod state;
+
+use std::sync::Arc;
+
+use linera_sdk::{
+    linera_base_types::{BlobContent, CryptoHash, DataBlobHash, WithServiceAbi},
+    Service, ServiceRuntime,
+};
+use publish_read_data_blob::{Operation, PublishReadDataBlobAbi, ServiceQuery};
+
+pub struct PublishReadDataBlobService {
+    runtime: Arc<ServiceRuntime<Self>>,
+}
+
+linera_sdk::service!(PublishReadDataBlobService);
+
+impl WithServiceAbi for PublishReadDataBlobService {
+    type Abi = PublishReadDataBlobAbi;
+}
+
+impl Service for PublishReadDataBlobService {
+    type Parameters = ();
+
+    async fn new(runtime: ServiceRuntime<Self>) -> Self {
+        PublishReadDataBlobService {
+            runtime: Arc::new(runtime),
+        }
+    }
+
+    async fn handle_query(&self, query: ServiceQuery) -> Vec<u8> {
+        match query {
+            ServiceQuery::PublishDataBlob(data) => {
+                self.runtime
+                    .schedule_operation(&Operation::CreateDataBlob(data));
+                Vec::new()
+            }
+            ServiceQuery::ReadDataBlob(hash, expected_data) => {
+                self.runtime
+                    .schedule_operation(&Operation::ReadDataBlob(hash, expected_data));
+                Vec::new()
+            }
+            ServiceQuery::PublishAndCreateOneOperation(data) => {
+                self.runtime
+                    .schedule_operation(&Operation::CreateAndReadDataBlob(data));
+                Vec::new()
+            }
+            ServiceQuery::PublishAndCreateTwoOperations(data) => {
+                // First operation: create the blob
+                self.runtime
+                    .schedule_operation(&Operation::CreateDataBlob(data.clone()));
+
+                // Compute the blob_id from the data
+                let content = BlobContent::new_data(data.clone());
+                let hash = DataBlobHash(CryptoHash::new(&content));
+
+                // Second operation: read the blob with verification
+                self.runtime
+                    .schedule_operation(&Operation::ReadDataBlob(hash, data));
+                Vec::new()
+            }
+        }
+    }
+}

examples/publish-read-data-blob/src/lib.rs

@@ -0,0 +1,13 @@
+// Copyright (c) Zefchain Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+use linera_sdk::{
+    linera_base_types::DataBlobHash,
+    views::{linera_views, RegisterView, RootView, ViewStorageContext},
+};
+
+#[derive(RootView)]
+#[view(context = ViewStorageContext)]
+pub struct PublishReadDataBlobState {
+    pub hash: RegisterView<Option<DataBlobHash>>,
+}