Replace Announce with NetworkAnnounce in network API and related code

Refactor Announce to store only hashes of injected transactions.
Add conversions and mocks for NetworkAnnounce.
Update accept_announce and related functions to use NetworkAnnounce.
Adjust types and imports accordingly throughout the codebase.

Author: Lazark0x

ethexe/common/src/consensus.rs

@@ -20,14 +20,15 @@ use crate::{
     Announce, Digest, HashOf, ToDigest,
     ecdsa::{ContractSignature, VerifiedData},
     gear::BatchCommitment,
+    network::NetworkAnnounce,
 };
 use alloc::vec::Vec;
 use gprimitives::CodeId;
 use k256::sha2::Digest as _;
 use parity_scale_codec::{Decode, Encode};
 use sha3::Keccak256;
 
-pub type VerifiedAnnounce = VerifiedData<Announce>;
+pub type VerifiedAnnounce = VerifiedData<NetworkAnnounce>;
 pub type VerifiedValidationRequest = VerifiedData<BatchCommitmentValidationRequest>;
 pub type VerifiedValidationReply = VerifiedData<BatchCommitmentValidationReply>;
 

ethexe/common/src/gear.rs

@@ -368,7 +368,7 @@ pub struct StateTransition {
     /// and each zero byte costs 4 gas (see <https://evm.codes/about#gascosts>).
     ///
     /// Negative numbers will be stored like this:
-    /// ```
+    /// ```text
     /// $ cast
     /// > -1 ether
     /// Type: int256

ethexe/common/src/mock.rs

@@ -27,6 +27,7 @@ use crate::{
     events::BlockEvent,
     gear::{BatchCommitment, ChainCommitment, CodeCommitment, Message, StateTransition},
     injected::{AddressedInjectedTransaction, InjectedTransaction},
+    network::NetworkAnnounce,
 };
 use alloc::{collections::BTreeMap, vec};
 use gear_core::code::{CodeMetadata, InstrumentedCode};
@@ -91,6 +92,29 @@ impl Mock<()> for Announce {
     }
 }
 
+impl Mock<(H256, HashOf<Announce>)> for NetworkAnnounce {
+    fn mock((block_hash, parent): (H256, HashOf<Announce>)) -> Self {
+        NetworkAnnounce {
+            block_hash,
+            parent,
+            gas_allowance: Some(100),
+            injected_transactions: vec![],
+        }
+    }
+}
+
+impl Mock<H256> for NetworkAnnounce {
+    fn mock(block_hash: H256) -> Self {
+        NetworkAnnounce::mock((block_hash, HashOf::random()))
+    }
+}
+
+impl Mock<()> for NetworkAnnounce {
+    fn mock(_args: ()) -> Self {
+        NetworkAnnounce::mock(H256::random())
+    }
+}
+
 impl Mock<()> for CodeCommitment {
     fn mock(_args: ()) -> Self {
         CodeCommitment {

ethexe/common/src/network.rs

@@ -26,7 +26,9 @@ use core::{hash::Hash, num::NonZeroU32};
 use parity_scale_codec::{Decode, Encode};
 use sha3::Keccak256;
 
-pub type ValidatorAnnounce = ValidatorMessage<Announce>;
+pub use crate::primitives::{NetworkAnnounce, NetworkAnnounceFromAnnounceError};
+
+pub type ValidatorAnnounce = ValidatorMessage<NetworkAnnounce>;
 pub type ValidatorRequest = ValidatorMessage<BatchCommitmentValidationRequest>;
 pub type ValidatorReply = ValidatorMessage<BatchCommitmentValidationReply>;
 
@@ -115,26 +117,26 @@ pub struct AnnouncesResponse {
     /// Corresponding request for this response
     request: AnnouncesRequest,
     /// List of announces
-    announces: Vec<Announce>,
+    announces: Vec<NetworkAnnounce>,
 }
 
 impl AnnouncesResponse {
     /// # Safety
     ///
     /// Response must be only created by network service
-    pub unsafe fn from_parts(request: AnnouncesRequest, announces: Vec<Announce>) -> Self {
+    pub unsafe fn from_parts(request: AnnouncesRequest, announces: Vec<NetworkAnnounce>) -> Self {
         Self { request, announces }
     }
 
     pub fn request(&self) -> &AnnouncesRequest {
         &self.request
     }
 
-    pub fn announces(&self) -> &[Announce] {
+    pub fn announces(&self) -> &[NetworkAnnounce] {
         &self.announces
     }
 
-    pub fn into_parts(self) -> (AnnouncesRequest, Vec<Announce>) {
+    pub fn into_parts(self) -> (AnnouncesRequest, Vec<NetworkAnnounce>) {
         (self.request, self.announces)
     }
 }