Merge transactions into a single collection in blocks. (#4272)

## Motivation

Blocks contain operations and incoming message bundles as separate
collections. It's impossible to process e.g. a message in between two
operations. Also, transactions are not properly exposed in GraphQL.

## Proposal

Merge the two collections, expose more information via GraphQL.

(Note: This was almost entirely written using Claude Code.)

## Test Plan

CI; tests have been updated.

## Release Plan

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

## Links

- Closes #1200 
- [reviewer
checklist](https://github.com/linera-io/linera-protocol/blob/main/CONTRIBUTING.md#reviewer-checklist)

Author: afck

Cargo.lock

@@ -22,7 +22,7 @@ use thiserror::Error;
 use crate::{
     data_types::{
         BlockExecutionOutcome, IncomingBundle, MessageBundle, OperationResult, OutgoingMessageExt,
-        ProposedBlock,
+        ProposedBlock, Transaction,
     },
     types::CertificateValue,
 };
@@ -258,15 +258,14 @@ impl<'de> Deserialize<'de> for Block {
         }
         let inner = Inner::deserialize(deserializer)?;
 
-        let bundles_hash = hashing::hash_vec(&inner.body.incoming_bundles);
+        let transactions_hash = hashing::hash_vec(&inner.body.transactions);
         let messages_hash = hashing::hash_vec_vec(&inner.body.messages);
         let previous_message_blocks_hash = CryptoHash::new(&PreviousMessageBlocksMap {
             inner: Cow::Borrowed(&inner.body.previous_message_blocks),
         });
         let previous_event_blocks_hash = CryptoHash::new(&PreviousEventBlocksMap {
             inner: Cow::Borrowed(&inner.body.previous_event_blocks),
         });
-        let operations_hash = hashing::hash_vec(&inner.body.operations);
         let oracle_responses_hash = hashing::hash_vec_vec(&inner.body.oracle_responses);
         let events_hash = hashing::hash_vec_vec(&inner.body.events);
         let blobs_hash = hashing::hash_vec_vec(&inner.body.blobs);
@@ -280,8 +279,7 @@ impl<'de> Deserialize<'de> for Block {
             state_hash: inner.header.state_hash,
             previous_block_hash: inner.header.previous_block_hash,
             authenticated_signer: inner.header.authenticated_signer,
-            bundles_hash,
-            operations_hash,
+            transactions_hash,
             messages_hash,
             previous_message_blocks_hash,
             previous_event_blocks_hash,
@@ -322,10 +320,8 @@ pub struct BlockHeader {
     pub authenticated_signer: Option<AccountOwner>,
 
     // Inputs to the block, chosen by the block proposer.
-    /// Cryptographic hash of all the incoming bundles in the block.
-    pub bundles_hash: CryptoHash,
-    /// Cryptographic hash of all the operations in the block.
-    pub operations_hash: CryptoHash,
+    /// Cryptographic hash of all the transactions in the block.
+    pub transactions_hash: CryptoHash,
 
     // Outcome of the block execution.
     /// Cryptographic hash of all the messages in the block.
@@ -346,12 +342,12 @@ pub struct BlockHeader {
 
 /// The body of a block containing all the data included in the block.
 #[derive(Debug, PartialEq, Eq, Hash, Clone, Serialize, Deserialize, SimpleObject)]
+#[graphql(complex)]
 pub struct BlockBody {
-    /// A selection of incoming messages to be executed first. Successive messages of the same
-    /// sender and height are grouped together for conciseness.
-    pub incoming_bundles: Vec<IncomingBundle>,
-    /// The operations to execute.
-    pub operations: Vec<Operation>,
+    /// The transactions to execute in this block. Each transaction can be either
+    /// incoming messages or an operation.
+    #[graphql(skip)]
+    pub transactions: Vec<Transaction>,
     /// The list of outgoing messages for each transaction.
     pub messages: Vec<Vec<OutgoingMessage>>,
     /// The hashes and heights of previous blocks that sent messages to the same recipients.
@@ -368,17 +364,45 @@ pub struct BlockBody {
     pub operation_results: Vec<OperationResult>,
 }
 
+impl BlockBody {
+    /// Returns all operations in this block body.
+    pub fn operations(&self) -> impl Iterator<Item = &Operation> {
+        self.transactions.iter().filter_map(|tx| match tx {
+            Transaction::ExecuteOperation(operation) => Some(operation),
+            Transaction::ReceiveMessages(_) => None,
+        })
+    }
+
+    /// Returns all incoming bundles in this block body.
+    pub fn incoming_bundles(&self) -> impl Iterator<Item = &IncomingBundle> {
+        self.transactions.iter().filter_map(|tx| match tx {
+            Transaction::ReceiveMessages(bundle) => Some(bundle),
+            Transaction::ExecuteOperation(_) => None,
+        })
+    }
+}
+
+#[async_graphql::ComplexObject]
+impl BlockBody {
+    /// Metadata about the transactions in this block.
+    async fn transaction_metadata(&self) -> Vec<crate::data_types::TransactionMetadata> {
+        self.transactions
+            .iter()
+            .map(crate::data_types::TransactionMetadata::from_transaction)
+            .collect()
+    }
+}
+
 impl Block {
     pub fn new(block: ProposedBlock, outcome: BlockExecutionOutcome) -> Self {
-        let bundles_hash = hashing::hash_vec(&block.incoming_bundles);
+        let transactions_hash = hashing::hash_vec(&block.transactions);
         let messages_hash = hashing::hash_vec_vec(&outcome.messages);
         let previous_message_blocks_hash = CryptoHash::new(&PreviousMessageBlocksMap {
             inner: Cow::Borrowed(&outcome.previous_message_blocks),
         });
         let previous_event_blocks_hash = CryptoHash::new(&PreviousEventBlocksMap {
             inner: Cow::Borrowed(&outcome.previous_event_blocks),
         });
-        let operations_hash = hashing::hash_vec(&block.operations);
         let oracle_responses_hash = hashing::hash_vec_vec(&outcome.oracle_responses);
         let events_hash = hashing::hash_vec_vec(&outcome.events);
         let blobs_hash = hashing::hash_vec_vec(&outcome.blobs);
@@ -392,8 +416,7 @@ impl Block {
             state_hash: outcome.state_hash,
             previous_block_hash: block.previous_block_hash,
             authenticated_signer: block.authenticated_signer,
-            bundles_hash,
-            operations_hash,
+            transactions_hash,
             messages_hash,
             previous_message_blocks_hash,
             previous_event_blocks_hash,
@@ -404,8 +427,7 @@ impl Block {
         };
 
         let body = BlockBody {
-            incoming_bundles: block.incoming_bundles,
-            operations: block.operations,
+            transactions: block.transactions,
             messages: outcome.messages,
             previous_message_blocks: outcome.previous_message_blocks,
             previous_event_blocks: outcome.previous_event_blocks,
@@ -483,8 +505,7 @@ impl Block {
     /// Returns all the published blob IDs in this block's operations.
     pub fn published_blob_ids(&self) -> BTreeSet<BlobId> {
         self.body
-            .operations
-            .iter()
+            .operations()
             .flat_map(Operation::published_blob_ids)
             .collect()
     }
@@ -550,17 +571,15 @@ impl Block {
         let ProposedBlock {
             chain_id,
             epoch,
-            incoming_bundles,
-            operations,
+            transactions,
             height,
             timestamp,
             authenticated_signer,
             previous_block_hash,
         } = block;
         *chain_id == self.header.chain_id
             && *epoch == self.header.epoch
-            && *incoming_bundles == self.body.incoming_bundles
-            && *operations == self.body.operations
+            && *transactions == self.body.transactions
             && *height == self.header.height
             && *timestamp == self.header.timestamp
             && *authenticated_signer == self.header.authenticated_signer
@@ -571,8 +590,7 @@ impl Block {
         let proposed_block = ProposedBlock {
             chain_id: self.header.chain_id,
             epoch: self.header.epoch,
-            incoming_bundles: self.body.incoming_bundles,
-            operations: self.body.operations,
+            transactions: self.body.transactions,
             height: self.header.height,
             timestamp: self.header.timestamp,
             authenticated_signer: self.header.authenticated_signer,

linera-chain/src/block.rs

@@ -95,22 +95,22 @@ impl<'resources, 'blobs> BlockExecutionTracker<'resources, 'blobs> {
             operation_results: Vec::new(),
             transaction_index: 0,
             published_blobs,
-            expected_outcomes_count: proposal.incoming_bundles.len() + proposal.operations.len(),
+            expected_outcomes_count: proposal.transactions.len(),
         })
     }
 
     /// Executes a transaction in the context of the block.
     pub async fn execute_transaction<C>(
         &mut self,
-        transaction: Transaction<'_>,
+        transaction: &Transaction,
         round: Option<u32>,
         chain: &mut ExecutionStateView<C>,
     ) -> Result<(), ChainError>
     where
         C: Context + Clone + Send + Sync + 'static,
         C::Extra: ExecutionRuntimeContext,
     {
-        let chain_execution_context = self.chain_execution_context(&transaction);
+        let chain_execution_context = self.chain_execution_context(transaction);
         let mut txn_tracker = self.new_transaction_tracker()?;
 
         match transaction {
@@ -357,7 +357,7 @@ impl<'resources, 'blobs> BlockExecutionTracker<'resources, 'blobs> {
     }
 
     /// Returns the execution context for the current transaction.
-    pub fn chain_execution_context(&self, transaction: &Transaction<'_>) -> ChainExecutionContext {
+    pub fn chain_execution_context(&self, transaction: &Transaction) -> ChainExecutionContext {
         match transaction {
             Transaction::ReceiveMessages(_) => {
                 ChainExecutionContext::IncomingBundle(self.transaction_index)