Simplify block execution code; remove redundant arguments. (#3641)

## Motivation

There are several methods in the block execution code with too many
arguments (according to Clippy), and some with redundant arguments.

## Proposal

Remove the redundant arguments; move more information into the
`TransactionTracker`; add `TransactionTracker` test constructors to
deduplicate some code.

## Test Plan

CI

## Release Plan

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

## Links

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

Author: afck

linera-chain/src/chain.rs

@@ -801,6 +801,8 @@ where
                 None => None,
             };
             let mut txn_tracker = TransactionTracker::new(
+                local_time,
+                txn_index,
                 next_message_index,
                 next_application_index,
                 maybe_responses,
@@ -817,8 +819,6 @@ where
                             incoming_bundle,
                             block,
                             round,
-                            txn_index,
-                            local_time,
                             &mut txn_tracker,
                             &mut resource_controller,
                         ))
@@ -841,7 +841,6 @@ where
                     };
                     Box::pin(self.execution_state.execute_operation(
                         context,
-                        local_time,
                         operation.clone(),
                         &mut txn_tracker,
                         &mut resource_controller,
@@ -993,8 +992,6 @@ where
         incoming_bundle: &IncomingBundle,
         block: &ProposedBlock,
         round: Option<u32>,
-        txn_index: u32,
-        local_time: Timestamp,
         txn_tracker: &mut TransactionTracker,
         resource_controller: &mut ResourceController<Option<AccountOwner>>,
     ) -> Result<(), ChainError> {
@@ -1013,29 +1010,24 @@ where
         let mut grant = posted_message.grant;
         match incoming_bundle.action {
             MessageAction::Accept => {
+                let chain_execution_context =
+                    ChainExecutionContext::IncomingBundle(txn_tracker.transaction_index());
                 // Once a chain is closed, accepting incoming messages is not allowed.
                 ensure!(!self.is_closed(), ChainError::ClosedChain);
 
                 Box::pin(self.execution_state.execute_message(
                     context,
-                    local_time,
                     posted_message.message.clone(),
                     (grant > Amount::ZERO).then_some(&mut grant),
                     txn_tracker,
                     resource_controller,
                 ))
                 .await
-                .with_execution_context(ChainExecutionContext::IncomingBundle(txn_index))?;
-                if grant > Amount::ZERO {
-                    if let Some(refund_grant_to) = posted_message.refund_grant_to {
-                        self.execution_state
-                            .send_refund(context, grant, refund_grant_to, txn_tracker)
-                            .await
-                            .with_execution_context(ChainExecutionContext::IncomingBundle(
-                                txn_index,
-                            ))?;
-                    }
-                }
+                .with_execution_context(chain_execution_context)?;
+                self.execution_state
+                    .send_refund(context, grant, txn_tracker)
+                    .await
+                    .with_execution_context(chain_execution_context)?;
             }
             MessageAction::Reject => {
                 // If rejecting a message fails, the entire block proposal should be
@@ -1054,17 +1046,10 @@ where
                         .bounce_message(context, grant, posted_message.message.clone(), txn_tracker)
                         .await
                         .with_execution_context(ChainExecutionContext::Block)?;
-                } else if grant > Amount::ZERO {
+                } else {
                     // Nothing to do except maybe refund the grant.
-                    let Some(refund_grant_to) = posted_message.refund_grant_to else {
-                        // See OperationContext::refund_grant_to()
-                        return Err(ChainError::InternalError(
-                            "Messages with grants should have a non-empty `refund_grant_to`".into(),
-                        ));
-                    };
-                    // Refund grant.
                     self.execution_state
-                        .send_refund(context, posted_message.grant, refund_grant_to, txn_tracker)
+                        .send_refund(context, grant, txn_tracker)
                         .await
                         .with_execution_context(ChainExecutionContext::Block)?;
                 }

linera-core/src/unit_tests/wasm_worker_tests.rs

@@ -282,12 +282,13 @@ where
     creator_state
         .execute_operation(
             operation_context,
-            Timestamp::from(3),
             Operation::User {
                 application_id,
                 bytes: user_operation,
             },
             &mut TransactionTracker::new(
+                Timestamp::from(3),
+                0,
                 0,
                 0,
                 Some(vec![OracleResponse::Blob(application_description_blob_id)]),

linera-execution/src/execution.rs

@@ -5,8 +5,8 @@ use std::{mem, vec};
 
 use futures::{FutureExt, StreamExt};
 use linera_base::{
-    data_types::{Amount, BlockHeight, Timestamp},
-    identifiers::{Account, AccountOwner, BlobType, ChainId, Destination},
+    data_types::{Amount, BlockHeight},
+    identifiers::{Account, AccountOwner, BlobType, Destination},
 };
 use linera_views::{
     context::Context,
@@ -60,13 +60,14 @@ where
     pub async fn simulate_instantiation(
         &mut self,
         contract: UserContractCode,
-        local_time: Timestamp,
+        local_time: linera_base::data_types::Timestamp,
         application_description: ApplicationDescription,
         instantiation_argument: Vec<u8>,
         contract_blob: Blob,
         service_blob: Blob,
     ) -> Result<(), ExecutionError> {
         let chain_id = application_description.creator_chain_id;
+        assert_eq!(chain_id, self.context().extra().chain_id);
         let context = OperationContext {
             chain_id,
             authenticated_signer: None,
@@ -106,13 +107,16 @@ where
             tracker,
             account: None,
         };
-        let mut txn_tracker =
-            TransactionTracker::new(next_message_index, next_application_index, None);
+        let mut txn_tracker = TransactionTracker::new(
+            local_time,
+            0,
+            next_message_index,
+            next_application_index,
+            None,
+        );
         txn_tracker.add_created_blob(Blob::new_application_description(&application_description));
         self.run_user_action(
             application_id,
-            chain_id,
-            local_time,
             action,
             context.refund_grant_to(),
             None,
@@ -163,12 +167,9 @@ where
     C: Context + Clone + Send + Sync + 'static,
     C::Extra: ExecutionRuntimeContext,
 {
-    #[expect(clippy::too_many_arguments)]
     async fn run_user_action(
         &mut self,
         application_id: ApplicationId,
-        chain_id: ChainId,
-        local_time: Timestamp,
         action: UserAction,
         refund_grant_to: Option<Account>,
         grant: Option<&mut Amount>,
@@ -178,8 +179,6 @@ where
         let ExecutionRuntimeConfig {} = self.context().extra().execution_runtime_config();
         self.run_user_action_with_runtime(
             application_id,
-            chain_id,
-            local_time,
             action,
             refund_grant_to,
             grant,
@@ -189,18 +188,16 @@ where
         .await
     }
 
-    #[expect(clippy::too_many_arguments)]
     async fn run_user_action_with_runtime(
         &mut self,
         application_id: ApplicationId,
-        chain_id: ChainId,
-        local_time: Timestamp,
         action: UserAction,
         refund_grant_to: Option<Account>,
         grant: Option<&mut Amount>,
         txn_tracker: &mut TransactionTracker,
         resource_controller: &mut ResourceController<Option<AccountOwner>>,
     ) -> Result<(), ExecutionError> {
+        let chain_id = self.context().extra().chain_id();
         let mut cloned_grant = grant.as_ref().map(|x| **x);
         let initial_balance = resource_controller
             .with_state_and_grant(&mut self.system, cloned_grant.as_mut())
@@ -219,7 +216,6 @@ where
             let runtime = ContractSyncRuntime::new(
                 execution_state_sender,
                 chain_id,
-                local_time,
                 refund_grant_to,
                 controller,
                 &action,
@@ -257,7 +253,6 @@ where
     pub async fn execute_operation(
         &mut self,
         context: OperationContext,
-        local_time: Timestamp,
         operation: Operation,
         txn_tracker: &mut TransactionTracker,
         resource_controller: &mut ResourceController<Option<AccountOwner>>,
@@ -273,8 +268,6 @@ where
                     let user_action = UserAction::Instantiate(context, argument);
                     self.run_user_action(
                         application_id,
-                        context.chain_id,
-                        local_time,
                         user_action,
                         context.refund_grant_to(),
                         None,
@@ -290,8 +283,6 @@ where
             } => {
                 self.run_user_action(
                     application_id,
-                    context.chain_id,
-                    local_time,
                     UserAction::Operation(context, bytes),
                     context.refund_grant_to(),
                     None,
@@ -307,7 +298,6 @@ where
     pub async fn execute_message(
         &mut self,
         context: MessageContext,
-        local_time: Timestamp,
         message: Message,
         grant: Option<&mut Amount>,
         txn_tracker: &mut TransactionTracker,
@@ -325,8 +315,6 @@ where
             } => {
                 self.run_user_action(
                     application_id,
-                    context.chain_id,
-                    local_time,
                     UserAction::Message(context, bytes),
                     context.refund_grant_to,
                     grant,
@@ -362,10 +350,17 @@ where
         &self,
         context: MessageContext,
         amount: Amount,
-        account: Account,
         txn_tracker: &mut TransactionTracker,
     ) -> Result<(), ExecutionError> {
         assert_eq!(context.chain_id, self.context().extra().chain_id());
+        if amount.is_zero() {
+            return Ok(());
+        }
+        let Some(account) = context.refund_grant_to else {
+            return Err(ExecutionError::InternalError(
+                "Messages with grants should have a non-empty `refund_grant_to`",
+            ));
+        };
         let message = SystemMessage::Credit {
             amount,
             source: context.authenticated_signer.unwrap_or(AccountOwner::CHAIN),

linera-execution/src/lib.rs

@@ -330,6 +330,8 @@ pub enum ExecutionError {
     InactiveChain,
     #[error("No recorded response for oracle query")]
     MissingOracleResponse,
+    #[error("Internal error: {0}")]
+    InternalError(&'static str),
 }
 
 impl From<ViewError> for ExecutionError {

linera-execution/src/runtime.rs

@@ -69,8 +69,6 @@ pub struct SyncRuntimeInternal<UserInstance> {
     height: BlockHeight,
     /// The current consensus round. Only available during block validation in multi-leader rounds.
     round: Option<u32>,
-    /// The current local time.
-    local_time: Timestamp,
     /// The authenticated signer of the operation or message, if any.
     #[debug(skip_if = Option::is_none)]
     authenticated_signer: Option<AccountOwner>,
@@ -293,7 +291,6 @@ impl<UserInstance> SyncRuntimeInternal<UserInstance> {
         chain_id: ChainId,
         height: BlockHeight,
         round: Option<u32>,
-        local_time: Timestamp,
         authenticated_signer: Option<AccountOwner>,
         executing_message: Option<ExecutingMessage>,
         execution_state_sender: ExecutionStateSender,
@@ -306,7 +303,6 @@ impl<UserInstance> SyncRuntimeInternal<UserInstance> {
             chain_id,
             height,
             round,
-            local_time,
             authenticated_signer,
             executing_message,
             execution_state_sender,
@@ -478,7 +474,7 @@ impl SyncRuntimeInternal<UserContractInstance> {
         let context = QueryContext {
             chain_id: self.chain_id,
             next_block_height: self.height,
-            local_time: self.local_time,
+            local_time: self.transaction_tracker.local_time(),
         };
         let sender = self.execution_state_sender.clone();
 
@@ -886,11 +882,12 @@ where
             .replay_oracle_response(OracleResponse::Assert)?
         {
             // There are no recorded oracle responses, so we check the local time.
+            let local_time = this.transaction_tracker.local_time();
             ensure!(
-                this.local_time < timestamp,
+                local_time < timestamp,
                 ExecutionError::AssertBefore {
                     timestamp,
-                    local_time: this.local_time,
+                    local_time,
                 }
             );
         }
@@ -955,7 +952,6 @@ impl ContractSyncRuntime {
     pub(crate) fn new(
         execution_state_sender: ExecutionStateSender,
         chain_id: ChainId,
-        local_time: Timestamp,
         refund_grant_to: Option<Account>,
         resource_controller: ResourceController,
         action: &UserAction,
@@ -966,7 +962,6 @@ impl ContractSyncRuntime {
                 chain_id,
                 action.height(),
                 action.round(),
-                local_time,
                 action.signer(),
                 if let UserAction::Message(context, _) = action {
                     Some(context.into())
@@ -1488,12 +1483,9 @@ impl ContractRuntime for ContractSyncRuntimeHandle {
 impl ServiceSyncRuntime {
     /// Creates a new [`ServiceSyncRuntime`] ready to execute using a provided [`QueryContext`].
     pub fn new(execution_state_sender: ExecutionStateSender, context: QueryContext) -> Self {
-        Self::new_with_txn_tracker(
-            execution_state_sender,
-            context,
-            None,
-            TransactionTracker::default(),
-        )
+        let mut txn_tracker = TransactionTracker::default();
+        txn_tracker.set_local_time(context.local_time);
+        Self::new_with_txn_tracker(execution_state_sender, context, None, txn_tracker)
     }
 
     /// Creates a new [`ServiceSyncRuntime`] ready to execute using a provided [`QueryContext`].
@@ -1508,7 +1500,6 @@ impl ServiceSyncRuntime {
                 context.chain_id,
                 context.next_block_height,
                 None,
-                context.local_time,
                 None,
                 None,
                 execution_state_sender,
@@ -1579,7 +1570,10 @@ impl ServiceSyncRuntime {
             let execution_state_sender = self.handle_mut().inner().execution_state_sender.clone();
             *self = ServiceSyncRuntime::new(execution_state_sender, new_context);
         } else {
-            self.handle_mut().inner().local_time = new_context.local_time;
+            self.handle_mut()
+                .inner()
+                .transaction_tracker
+                .set_local_time(new_context.local_time);
         }
     }
 
@@ -1623,7 +1617,7 @@ impl ServiceRuntime for ServiceSyncRuntimeHandle {
             let query_context = QueryContext {
                 chain_id: this.chain_id,
                 next_block_height: this.height,
-                local_time: this.local_time,
+                local_time: this.transaction_tracker.local_time(),
             };
             this.push_application(ApplicationStatus {
                 caller_id: None,