feat(ethexe): add Router.protocolVersion to contracts & client

ethexe/common/src/db.rs

@@ -265,7 +265,7 @@ mod tests {
     #[test]
     fn ensure_types_unchanged() {
         const EXPECTED_TYPE_INFO_HASH: &str =
-            "d43d8ab319fb6d934231dba55950c9825e28c6ecf603e8076a90e0cab3855671";
+            "75cc4a2bcd0cc559bad7a587812b336e4f44ea7b5d8576ebfe6426dbbef2ca8e";
 
         let types = [
             meta_type::<BlockMeta>(),

ethexe/common/src/events/router.rs

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
 
 use crate::Digest;
-use gprimitives::{ActorId, CodeId, H256};
+use gprimitives::{ActorId, CodeId, H256, U256};
 use parity_scale_codec::{Decode, Encode};
 use scale_info::TypeInfo;
 
@@ -22,6 +22,11 @@ pub struct MBCommittedEvent(pub H256);
 #[derive(Clone, Debug, Encode, Decode, TypeInfo, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct EBCommittedEvent(pub H256);
 
+#[derive(Clone, Debug, Encode, Decode, TypeInfo, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct ProtocolVersionChangedEvent {
+    pub new_protocol_version: U256,
+}
+
 #[derive(Clone, Debug, Encode, Decode, TypeInfo, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct CodeGotValidatedEvent {
     pub code_id: CodeId,
@@ -74,6 +79,7 @@ pub enum Event {
     // TODO: on review ask about backward compatibility
     StorageSlotChanged(StorageSlotChangedEvent),
     ValidatorsCommittedForEra(ValidatorsCommittedForEraEvent),
+    ProtocolVersionChanged(ProtocolVersionChangedEvent),
 }
 
 impl Event {
@@ -91,7 +97,8 @@ impl Event {
             Self::CodeGotValidated { .. }
             | Self::MBCommitted(_)
             | Self::EBCommitted(_)
-            | Self::BatchCommitted { .. } => return None,
+            | Self::BatchCommitted { .. }
+            | Self::ProtocolVersionChanged { .. } => return None,
         })
     }
 }

ethexe/contracts/src/IRouter.sol

@@ -66,6 +66,10 @@ interface IRouter {
          *         This extra fee is paid in WVARA ERC20 token.
          */
         uint256 requestCodeValidationExtraFee;
+        /**
+         * @notice The version of the protocol, used by nodes.
+         */
+        uint256 protocolVersion;
     }
 
     /**
@@ -143,6 +147,13 @@ interface IRouter {
      */
     event EBCommitted(bytes32 ethBlockHash);
 
+    /**
+     * @notice Emitted when the protocol version is changed.
+     * @dev This is an *informational* event, signaling that the protocol version has been changed.
+     * @param newProtocolVersion The new version of the protocol.
+     */
+    event ProtocolVersionChanged(uint256 newProtocolVersion);
+
     /**
      * @notice Emitted when a code, previously requested for validation, receives validation results, so its `Gear.CodeState` changed.
      * @dev This is an *informational* event, signaling the results of code validation.
@@ -470,6 +481,12 @@ interface IRouter {
      */
     function requestCodeValidationExtraFee() external view returns (uint256);
 
+    /**
+     * @dev Returns the current protocol version.
+     * @return protocolVersion The current protocol version.
+     */
+    function protocolVersion() external view returns (uint256);
+
     /**
      * @dev Returns the timelines.
      * @return timelines The timelines.
@@ -502,6 +519,12 @@ interface IRouter {
      */
     function setRequestCodeValidationExtraFee(uint256 newExtraFee) external;
 
+    /**
+     * @dev Bumps the version of the protocol, used by nodes.
+     *      Emits `ProtocolVersionChanged` event.
+     */
+    function bumpProtocolVersion() external;
+
     /**
      * @dev Pauses the contract.
      */

ethexe/contracts/src/Router.sol

@@ -48,6 +48,8 @@ contract Router is
     bytes32 private constant REQUEST_CODE_VALIDATION_ON_BEHALF_TYPEHASH =
         0x375d2ef9b9e33c640a295f53873dc74833c3d019f349464ce2fe8899962b8097;
 
+    uint256 private constant PROTOCOL_VERSION = 1;
+
     /**
      * @custom:oz-upgrades-unsafe-allow constructor
      */
@@ -121,6 +123,8 @@ contract Router is
             block.timestamp
         );
         // forge-lint: disable-end(block-timestamp)
+
+        router.protocolData.protocolVersion = PROTOCOL_VERSION;
     }
 
     /**
@@ -190,6 +194,7 @@ contract Router is
         uint256 decimalsFactor = 10 ** IWrappedVara(router.implAddresses.wrappedVara).decimals();
         router.protocolData.requestCodeValidationBaseFee = DEFAULT_REQUEST_CODE_VALIDATION_BASE_FEE * decimalsFactor;
         router.protocolData.requestCodeValidationExtraFee = DEFAULT_REQUEST_CODE_VALIDATION_EXTRA_FEE * decimalsFactor;
+        router.protocolData.protocolVersion = PROTOCOL_VERSION;
     }
 
     /**
@@ -218,7 +223,8 @@ contract Router is
             validatedCodesCount: router.protocolData.validatedCodesCount,
             maxValidators: router.protocolData.maxValidators,
             requestCodeValidationBaseFee: router.protocolData.requestCodeValidationBaseFee,
-            requestCodeValidationExtraFee: router.protocolData.requestCodeValidationExtraFee
+            requestCodeValidationExtraFee: router.protocolData.requestCodeValidationExtraFee,
+            protocolVersion: router.protocolData.protocolVersion
         });
     }
 
@@ -455,6 +461,14 @@ contract Router is
         return _router().protocolData.requestCodeValidationExtraFee;
     }
 
+    /**
+     * @dev Returns the current protocol version.
+     * @return protocolVersion The current protocol version.
+     */
+    function protocolVersion() external view returns (uint256) {
+        return _router().protocolData.protocolVersion;
+    }
+
     /**
      * @dev Returns the timelines.
      * @return timelines The timelines.
@@ -497,6 +511,17 @@ contract Router is
         _router().protocolData.requestCodeValidationExtraFee = newExtraFee;
     }
 
+    /**
+     * @dev Bumps the version of the protocol, used by nodes.
+     *      Emits `ProtocolVersionChanged` event.
+     */
+    function bumpProtocolVersion() external onlyOwner {
+        uint256 newProtocolVersion = _router().protocolData.protocolVersion + 1;
+        _router().protocolData.protocolVersion = newProtocolVersion;
+
+        emit ProtocolVersionChanged(newProtocolVersion);
+    }
+
     /**
      * @dev Pauses the contract.
      */

ethexe/contracts/src/libraries/Gear.sol

@@ -405,6 +405,11 @@ library Gear {
          *      This extra fee is paid in WVARA ERC20 token.
          */
         uint256 requestCodeValidationExtraFee;
+        /**
+         * @notice The version of the protocol, used by nodes.
+         * @dev This contains the version of the protocol, which can be used by nodes.
+         */
+        uint256 protocolVersion;
     }
 
     /**

ethexe/ethereum/src/abi/events/router.rs

@@ -24,6 +24,14 @@ impl From<IRouter::EBCommitted> for EBCommittedEvent {
     }
 }
 
+impl From<IRouter::ProtocolVersionChanged> for ProtocolVersionChangedEvent {
+    fn from(value: IRouter::ProtocolVersionChanged) -> Self {
+        Self {
+            new_protocol_version: uint256_to_u256(value.newProtocolVersion),
+        }
+    }
+}
+
 impl From<IRouter::CodeGotValidated> for CodeGotValidatedEvent {
     fn from(value: IRouter::CodeGotValidated) -> Self {
         Self {

ethexe/ethereum/src/lib.rs

@@ -289,6 +289,9 @@ pub struct Ethereum {
 }
 
 impl Ethereum {
+    /// Client protocol version.
+    pub const CLIENT_PROTOCOL_VERSION: u64 = 1;
+
     /// Default Ethereum RPC.
     pub const DEFAULT_ETHEREUM_RPC: &str = "ws://localhost:8545";
     /// Default Ethereum router contract address.
@@ -337,6 +340,14 @@ impl Ethereum {
         let router_query = RouterQuery::from_provider(router_address, provider.root().clone());
         let router = router_address.into();
         let (wvara, middleware) = if initialize_addresses {
+            let protocol_version = router_query.protocol_version().await?;
+            if protocol_version > Self::CLIENT_PROTOCOL_VERSION {
+                return Err(anyhow!(
+                    "Client protocol version mismatch. Expected {client_protocol_version}, got {protocol_version}. \
+                    Please make sure to use compatible version of Ethereum client with `Router` contract.",
+                    client_protocol_version = Self::CLIENT_PROTOCOL_VERSION,
+                ));
+            }
             (
                 router_query.wvara_address().await?.into(),
                 router_query.middleware_address().await?.into(),

ethexe/ethereum/src/mirror/events.rs

@@ -11,7 +11,7 @@ use alloy::{
 };
 use anyhow::Result;
 use ethexe_common::events::{
-    MirrorEvent, MirrorRequestEvent,
+    MirrorEvent,
     mirror::{
         ExecutableBalanceTopUpRequestedEvent, MessageCallFailedEvent, MessageEvent,
         MessageQueueingRequestedEvent, OwnedBalanceTopUpRequestedEvent, ReplyCallFailedEvent,
@@ -107,18 +107,6 @@ pub fn try_extract_event(log: &Log) -> Result<Option<MirrorEvent>> {
     Ok(Some(event))
 }
 
-pub fn try_extract_request_event(log: &Log) -> Result<Option<MirrorRequestEvent>> {
-    if log.topic0().filter(|&v| REQUESTS.contains(v)).is_none() {
-        return Ok(None);
-    }
-
-    let request_event = try_extract_event(log)?
-        .and_then(|v| v.to_request())
-        .expect("filtered above");
-
-    Ok(Some(request_event))
-}
-
 pub struct AllEventsBuilder<'a> {
     query: &'a MirrorQuery,
 }

ethexe/ethereum/src/router/events.rs

@@ -16,7 +16,7 @@ use alloy::{
 };
 use anyhow::{Result, anyhow};
 use ethexe_common::events::{
-    RouterEvent, RouterRequestEvent,
+    RouterEvent,
     router::{
         BatchCommittedEvent, CodeGotValidatedEvent, CodeValidationRequestedEvent,
         ComputationSettingsChangedEvent, EBCommittedEvent, MBCommittedEvent, ProgramCreatedEvent,
@@ -35,6 +35,7 @@ pub mod signatures {
         BATCH_COMMITTED: BatchCommitted,
         MB_COMMITTED: MBCommitted,
         EB_COMMITTED: EBCommitted,
+        PROTOCOL_VERSION_CHANGED: ProtocolVersionChanged,
         CODE_GOT_VALIDATED: CodeGotValidated,
         CODE_VALIDATION_REQUESTED: CodeValidationRequested,
         COMPUTATION_SETTINGS_CHANGED: ComputationSettingsChanged,
@@ -63,6 +64,9 @@ pub fn try_extract_event(log: &Log) -> Result<Option<RouterEvent>> {
         }
         MB_COMMITTED => RouterEvent::MBCommitted(decode_log::<IRouter::MBCommitted>(log)?.into()),
         EB_COMMITTED => RouterEvent::EBCommitted(decode_log::<IRouter::EBCommitted>(log)?.into()),
+        PROTOCOL_VERSION_CHANGED => RouterEvent::ProtocolVersionChanged(
+            decode_log::<IRouter::ProtocolVersionChanged>(log)?.into(),
+        ),
         CODE_GOT_VALIDATED => {
             RouterEvent::CodeGotValidated(decode_log::<IRouter::CodeGotValidated>(log)?.into())
         }
@@ -99,18 +103,6 @@ pub fn try_extract_event(log: &Log) -> Result<Option<RouterEvent>> {
     Ok(Some(event))
 }
 
-pub fn try_extract_request_event(log: &Log) -> Result<Option<RouterRequestEvent>> {
-    if log.topic0().filter(|&v| REQUESTS.contains(v)).is_none() {
-        return Ok(None);
-    }
-
-    let request_event = try_extract_event(log)?
-        .and_then(|v| v.to_request())
-        .expect("filtered above");
-
-    Ok(Some(request_event))
-}
-
 pub struct AllEventsBuilder<'a> {
     query: &'a RouterQuery,
 }

ethexe/ethereum/src/router/mod.rs

@@ -908,6 +908,15 @@ impl RouterQuery {
         Ok(extra_fee.try_into().expect("infallible"))
     }
 
+    pub async fn protocol_version(&self) -> Result<u64> {
+        self.instance
+            .protocolVersion()
+            .call()
+            .await
+            .map(|res| res.to())
+            .map_err(Into::into)
+    }
+
     pub async fn timelines(&self) -> Result<Timelines> {
         self.instance
             .timelines()

ethexe/observer/src/lib.rs

@@ -235,6 +235,13 @@ impl Stream for ObserverService {
                     cx.waker().wake_by_ref();
                     return Poll::Pending;
                 }
+                Err(SyncError::ProtocolVersionMismatch { expected, got }) => {
+                    return Poll::Ready(Some(Err(SyncError::ProtocolVersionMismatch {
+                        expected,
+                        got,
+                    }
+                    .into())));
+                }
                 Err(SyncError::Fatal(err)) => {
                     return Poll::Ready(Some(Err(err)));
                 }