Implement the fees for the events. (#4592)

## Motivation

Events costs need to be accounted for.

Fixes #4259

## Proposal

Since events are implemented as blobs, it makes sense to have their
costs identical to those of blobs.
In that way, we avoid having some economic imbalance.

## Test Plan

The CI.

## Release Plan

This does change the costs for validators and so it is a breaking
change.

## Links

None.

Author: MathieuDutSik

linera-execution/src/execution_state_actor.rs

@@ -493,6 +493,10 @@ where
                     .await?;
                 let index = *count;
                 *count = count.checked_add(1).ok_or(ArithmeticError::Overflow)?;
+                self.resource_controller
+                    .with_state(&mut self.state.system)
+                    .await?
+                    .track_event_published(&value)?;
                 self.txn_tracker.add_event(stream_id, index, value);
                 callback.respond(index)
             }
@@ -510,6 +514,10 @@ where
                     })
                     .await?
                     .to_event(&event_id)?;
+                self.resource_controller
+                    .with_state(&mut self.state.system)
+                    .await?
+                    .track_event_read(event.len() as u64)?;
                 callback.respond(event);
             }
 

linera-execution/src/resources.rs

@@ -132,6 +132,14 @@ pub struct ResourceTracker {
     pub blob_bytes_read: u64,
     /// The number of blob bytes published.
     pub blob_bytes_published: u64,
+    /// The number of events read.
+    pub events_read: u32,
+    /// The number of events published.
+    pub events_published: u32,
+    /// The number of event bytes read.
+    pub event_bytes_read: u64,
+    /// The number of event bytes published.
+    pub event_bytes_published: u64,
     /// The change in the number of bytes being stored by user applications.
     pub bytes_stored: i32,
     /// The number of operations executed.
@@ -499,6 +507,44 @@ where
         Ok(())
     }
 
+    /// Tracks a number of event bytes read.
+    pub(crate) fn track_event_read(&mut self, count: u64) -> Result<(), ExecutionError> {
+        {
+            let tracker = self.tracker.as_mut();
+            tracker.event_bytes_read = tracker
+                .event_bytes_read
+                .checked_add(count)
+                .ok_or(ArithmeticError::Overflow)?;
+            tracker.events_read = tracker
+                .events_read
+                .checked_add(1)
+                .ok_or(ArithmeticError::Overflow)?;
+        }
+        self.update_balance(self.policy.blob_read_price(count)?)?;
+        Ok(())
+    }
+
+    /// Tracks a number of event bytes published.
+    pub(crate) fn track_event_published(
+        &mut self,
+        event_bytes: &[u8],
+    ) -> Result<(), ExecutionError> {
+        let size = event_bytes.len() as u64;
+        {
+            let tracker = self.tracker.as_mut();
+            tracker.event_bytes_published = tracker
+                .event_bytes_published
+                .checked_add(size)
+                .ok_or(ArithmeticError::Overflow)?;
+            tracker.events_published = tracker
+                .events_published
+                .checked_add(1)
+                .ok_or(ArithmeticError::Overflow)?;
+        }
+        self.update_balance(self.policy.blob_published_price(size)?)?;
+        Ok(())
+    }
+
     /// Tracks a change in the number of bytes stored.
     // TODO(#1536): This is not fully implemented.
     #[allow(dead_code)]