Merge branch 'master' into ap/lim-tree-max-encoded-len

.github/workflows/check.yml

@@ -44,11 +44,7 @@ jobs:
         run: |
           npm cache clean --force
           # version from ethexe/contracts/lib/openzeppelin-foundry-upgrades/src/internal/Versions.sol
-          # npx @openzeppelin/upgrades-core@^1.37.0
-
-          # temp fix for CI
-          npx @openzeppelin/upgrades-core@=1.41.0
-          sed -i 's/\^1\.37\.0/=1.41.0/' ethexe/contracts/lib/openzeppelin-foundry-upgrades/src/internal/Versions.sol
+          npx @openzeppelin/upgrades-core@^1.37.0
 
           cd ethexe/contracts
           forge fmt --check

.gitmodules

@@ -5,18 +5,20 @@
 [submodule "ethexe/contracts/lib/openzeppelin-contracts"]
 	path = ethexe/contracts/lib/openzeppelin-contracts
 	url = https://github.com/OpenZeppelin/openzeppelin-contracts
-	branch = "release-v5.1"
+	branch = "release-v5.2"
 [submodule "ethexe/contracts/lib/openzeppelin-foundry-upgrades"]
 	path = ethexe/contracts/lib/openzeppelin-foundry-upgrades
 	url = https://github.com/OpenZeppelin/openzeppelin-foundry-upgrades
 	branch = "main"
 [submodule "ethexe/contracts/lib/openzeppelin-contracts-upgradeable"]
 	path = ethexe/contracts/lib/openzeppelin-contracts-upgradeable
 	url = https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable
-	branch = "release-v5.1"
+	branch = "release-v5.2"
 [submodule "ethexe/contracts/lib/symbiotic-core"]
 	path = ethexe/contracts/lib/symbiotic-core
-	url = https://github.com/grishasobol/symbiotic-core
+	url = https://github.com/gear-tech/symbiotic-core
+	branch = "gear-main"
 [submodule "ethexe/contracts/lib/frost-secp256k1-evm"]
 	path = ethexe/contracts/lib/frost-secp256k1-evm
 	url = https://github.com/StackOverflowExcept1on/frost-secp256k1-evm
+	branch = "master"

core-errors/src/simple.rs

@@ -226,7 +226,6 @@ impl ErrorReplyReason {
         bytes
     }
 
-    // TODO: add test this method works correctly for all possible variants #3715
     fn from_bytes(bytes: [u8; 3]) -> Self {
         match bytes[0] {
             b if Self::Execution(Default::default()).discriminant() == b => {
@@ -410,10 +409,35 @@ impl SignalCode {
             v if Self::Execution(SimpleExecutionError::StackLimitExceeded).to_u32() == v => {
                 Self::Execution(SimpleExecutionError::StackLimitExceeded)
             }
+            v if Self::Execution(SimpleExecutionError::Unsupported).to_u32() == v => {
+                Self::Execution(SimpleExecutionError::Unsupported)
+            }
             v if Self::RemovedFromWaitlist.to_u32() == v => Self::RemovedFromWaitlist,
             _ => return None,
         };
 
         Some(res)
     }
 }
+
+#[cfg(feature = "codec")]
+#[cfg(test)]
+mod tests {
+    use super::{ReplyCode, SignalCode};
+
+    #[test]
+    fn test_reply_code_encode_decode() {
+        for code in enum_iterator::all::<ReplyCode>() {
+            let bytes = code.to_bytes();
+            assert_eq!(code, ReplyCode::from_bytes(bytes));
+        }
+    }
+
+    #[test]
+    fn test_signal_code_encode_decode() {
+        for signal in enum_iterator::all::<SignalCode>() {
+            let code = signal.to_u32();
+            assert_eq!(signal, SignalCode::from_u32(code).unwrap());
+        }
+    }
+}

ethexe/cli/src/commands/tx.rs

@@ -187,9 +187,14 @@ impl TxCommand {
 
                 println!("Uploading {} to Ethereum", path_to_wasm.display(),);
 
-                let (tx, code_id) = router
+                let pending_builder = router
                     .request_code_validation_with_sidecar(&code)
                     .await
+                    .with_context(|| "failed to create code validation request")?;
+
+                let (tx, code_id) = pending_builder
+                    .send()
+                    .await
                     .with_context(|| "failed to request code validation")?;
 
                 println!("Completed in transaction {tx:?}");

ethexe/common/src/db.rs

@@ -120,7 +120,7 @@ pub trait CodesStorage: Send + Sync {
     fn set_instrumented_code(&self, runtime_id: u32, code_id: CodeId, code: InstrumentedCode);
 
     fn code_blob_tx(&self, code_id: CodeId) -> Option<H256>;
-    fn set_code_blob_tx(&self, code_id: CodeId, blob_tx_hash: H256);
+    fn set_code_blob_tx(&self, code_id: CodeId, tx_hash: H256);
 
     fn code_valid(&self, code_id: CodeId) -> Option<bool>;
     fn set_code_valid(&self, code_id: CodeId, valid: bool);

ethexe/common/src/events/router.rs

@@ -31,8 +31,7 @@ pub enum Event {
     },
     CodeValidationRequested {
         code_id: CodeId,
-        /// This field is replaced with tx hash in case of zero.
-        blob_tx_hash: H256,
+        tx_hash: H256,
     },
     ComputationSettingsChanged {
         threshold: u64,
@@ -51,13 +50,9 @@ pub enum Event {
 impl Event {
     pub fn to_request(self) -> Option<RequestEvent> {
         Some(match self {
-            Self::CodeValidationRequested {
-                code_id,
-                blob_tx_hash,
-            } => RequestEvent::CodeValidationRequested {
-                code_id,
-                blob_tx_hash,
-            },
+            Self::CodeValidationRequested { code_id, tx_hash } => {
+                RequestEvent::CodeValidationRequested { code_id, tx_hash }
+            }
             Self::ComputationSettingsChanged {
                 threshold,
                 wvara_per_second,
@@ -82,8 +77,7 @@ pub enum RequestEvent {
     CodeValidationRequested {
         code_id: CodeId,
         // TODO (breathx): replace with `code: Vec<u8>`
-        /// This field is replaced with tx hash in case of zero.
-        blob_tx_hash: H256,
+        tx_hash: H256,
     },
     ComputationSettingsChanged {
         threshold: u64,

ethexe/contracts/src/IRouter.sol

@@ -45,8 +45,7 @@ interface IRouter {
     /// @notice Emitted when a new code validation request is submitted.
     /// @dev This is a *requesting* event, signaling that validators need to download and validate the code from the transaction blob.
     /// @param codeId The expected code ID of the applied WASM blob, represented as a Blake2 hash.
-    /// @param blobTxHash The transaction hash that contains the WASM blob. Set to zero if applied to the current transaction.
-    event CodeValidationRequested(bytes32 codeId, bytes32 blobTxHash);
+    event CodeValidationRequested(bytes32 codeId);
 
     /// @notice Emitted when validators for the next era has been set.
     /// @dev This is an *informational* and *request* event, signaling that validators has been set for the next era.
@@ -104,7 +103,7 @@ interface IRouter {
     function lookupGenesisHash() external;
 
     /// @dev CodeValidationRequested Emitted on success.
-    function requestCodeValidation(bytes32 codeId, bytes32 blobTxHash) external;
+    function requestCodeValidation(bytes32 codeId) external;
     /// @dev ProgramCreated Emitted on success.
     function createProgram(bytes32 codeId, bytes32 salt) external returns (address);
     /// @dev ProgramCreated Emitted on success.

ethexe/contracts/src/Router.sol

@@ -229,8 +229,8 @@ contract Router is IRouter, OwnableUpgradeable, ReentrancyGuardTransient {
         router.genesisBlock.hash = blockhash(router.genesisBlock.number);
     }
 
-    function requestCodeValidation(bytes32 _codeId, bytes32 _blobTxHash) external {
-        require(_blobTxHash != 0 || blobhash(0) != 0, "blob can't be found");
+    function requestCodeValidation(bytes32 _codeId) external {
+        require(blobhash(0) != 0, "blob can't be found, router expected EIP-4844 transaction with WASM blob");
 
         Storage storage router = _router();
         require(router.genesisBlock.hash != bytes32(0), "router genesis is zero; call `lookupGenesisHash()` first");
@@ -242,7 +242,7 @@ contract Router is IRouter, OwnableUpgradeable, ReentrancyGuardTransient {
 
         router.protocolData.codes[_codeId] = Gear.CodeState.ValidationRequested;
 
-        emit CodeValidationRequested(_codeId, _blobTxHash);
+        emit CodeValidationRequested(_codeId);
     }
 
     function createProgram(bytes32 _codeId, bytes32 _salt) external returns (address) {

ethexe/contracts/test/POC.t.sol

@@ -65,9 +65,12 @@ contract POCTest is Base {
 
     function test_POC() public {
         bytes32 _codeId = bytes32(uint256(1));
-        bytes32 _blobTxHash = bytes32(uint256(2));
 
-        router.requestCodeValidation(_codeId, _blobTxHash);
+        bytes32[] memory hashes = new bytes32[](1);
+        hashes[0] = bytes32(uint256(1));
+        vm.blobhashes(hashes);
+
+        router.requestCodeValidation(_codeId);
 
         address[] memory _validators = router.validators();
         assertEq(_validators.length, maxValidators);

ethexe/db/src/database.rs

@@ -386,9 +386,9 @@ impl CodesStorage for Database {
             })
     }
 
-    fn set_code_blob_tx(&self, code_id: CodeId, blob_tx_hash: H256) {
+    fn set_code_blob_tx(&self, code_id: CodeId, tx_hash: H256) {
         self.kv
-            .put(&KeyPrefix::CodeUpload.one(code_id), blob_tx_hash.encode());
+            .put(&KeyPrefix::CodeUpload.one(code_id), tx_hash.encode());
     }
 
     fn code_valid(&self, code_id: CodeId) -> Option<bool> {

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

@@ -36,15 +36,6 @@ impl From<IRouter::CodeGotValidated> for RouterEvent {
     }
 }
 
-impl From<IRouter::CodeValidationRequested> for RouterEvent {
-    fn from(value: IRouter::CodeValidationRequested) -> Self {
-        Self::CodeValidationRequested {
-            code_id: bytes32_to_code_id(value.codeId),
-            blob_tx_hash: bytes32_to_h256(value.blobTxHash),
-        }
-    }
-}
-
 impl From<IRouter::ComputationSettingsChanged> for RouterEvent {
     fn from(value: IRouter::ComputationSettingsChanged) -> Self {
         Self::ComputationSettingsChanged {

ethexe/ethereum/src/router/events.rs

@@ -16,7 +16,10 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-use crate::{abi::utils::bytes32_to_h256, decode_log, IRouter};
+use crate::{
+    abi::utils::{bytes32_to_code_id, bytes32_to_h256},
+    decode_log, IRouter,
+};
 use alloy::{primitives::B256, rpc::types::eth::Log, sol_types::SolEvent};
 use anyhow::{anyhow, Result};
 use ethexe_common::events::{RouterEvent, RouterRequestEvent};
@@ -58,14 +61,12 @@ pub fn try_extract_event(log: &Log) -> Result<Option<RouterEvent>> {
             let tx_hash = log
                 .transaction_hash
                 .ok_or_else(|| anyhow!("Tx hash not found"))?;
+            let event = decode_log::<IRouter::CodeValidationRequested>(log)?;
 
-            let mut event = decode_log::<IRouter::CodeValidationRequested>(log)?;
-
-            if event.blobTxHash.is_zero() {
-                event.blobTxHash = tx_hash;
+            RouterEvent::CodeValidationRequested {
+                code_id: bytes32_to_code_id(event.codeId),
+                tx_hash: bytes32_to_h256(tx_hash),
             }
-
-            event.into()
         }
         COMPUTATION_SETTINGS_CHANGED => {
             decode_log::<IRouter::ComputationSettingsChanged>(log)?.into()

ethexe/ethereum/src/router/mod.rs

@@ -19,12 +19,12 @@
 use crate::{
     abi::{utils::uint256_to_u256, Gear::CodeState, IRouter},
     wvara::WVara,
-    AlloyProvider, AlloyTransport, TryGetReceipt,
+    AlloyEthereum, AlloyProvider, AlloyTransport, TryGetReceipt,
 };
 use alloy::{
     consensus::{SidecarBuilder, SimpleCoder},
-    primitives::{Address, Bytes, B256, U256},
-    providers::{Provider, ProviderBuilder, RootProvider},
+    primitives::{Address, Bytes, U256},
+    providers::{PendingTransactionBuilder, Provider, ProviderBuilder, RootProvider},
     rpc::types::Filter,
     transports::BoxTransport,
 };
@@ -46,6 +46,26 @@ type Instance = IRouter::IRouterInstance<AlloyTransport, InstanceProvider>;
 
 type QueryInstance = IRouter::IRouterInstance<AlloyTransport, Arc<RootProvider<BoxTransport>>>;
 
+pub struct PendingCodeRequestBuilder {
+    code_id: CodeId,
+    pending_builder: PendingTransactionBuilder<AlloyTransport, AlloyEthereum>,
+}
+
+impl PendingCodeRequestBuilder {
+    pub fn code_id(&self) -> CodeId {
+        self.code_id
+    }
+
+    pub fn tx_hash(&self) -> H256 {
+        H256(self.pending_builder.tx_hash().0)
+    }
+
+    pub async fn send(self) -> Result<(H256, CodeId)> {
+        let receipt = self.pending_builder.try_get_receipt().await?;
+        Ok(((*receipt.transaction_hash).into(), self.code_id))
+    }
+}
+
 #[derive(Clone)]
 pub struct Router {
     instance: Instance,
@@ -81,33 +101,22 @@ impl Router {
         WVara::new(self.wvara_address, self.instance.provider().clone())
     }
 
-    pub async fn request_code_validation(
-        &self,
-        code_id: CodeId,
-        blob_tx_hash: H256,
-    ) -> Result<H256> {
-        let builder = self.instance.requestCodeValidation(
-            code_id.into_bytes().into(),
-            blob_tx_hash.to_fixed_bytes().into(),
-        );
-        let receipt = builder.send().await?.try_get_receipt().await?;
-
-        Ok((*receipt.transaction_hash).into())
-    }
-
     pub async fn request_code_validation_with_sidecar(
         &self,
         code: &[u8],
-    ) -> Result<(H256, CodeId)> {
+    ) -> Result<PendingCodeRequestBuilder> {
         let code_id = CodeId::generate(code);
 
         let builder = self
             .instance
-            .requestCodeValidation(code_id.into_bytes().into(), B256::ZERO)
+            .requestCodeValidation(code_id.into_bytes().into())
             .sidecar(SidecarBuilder::<SimpleCoder>::from_slice(code).build()?);
-        let receipt = builder.send().await?.try_get_receipt().await?;
+        let pending_builder = builder.send().await?;
 
-        Ok(((*receipt.transaction_hash).into(), code_id))
+        Ok(PendingCodeRequestBuilder {
+            code_id,
+            pending_builder,
+        })
     }
 
     pub async fn wait_code_validation(&self, code_id: CodeId) -> Result<bool> {

ethexe/observer/src/lib.rs

@@ -156,11 +156,11 @@ impl ObserverService {
         }
     }
 
-    pub fn lookup_code(&mut self, code_id: CodeId, blob_tx_hash: H256) {
+    pub fn lookup_code(&mut self, code_id: CodeId, tx_hash: H256) {
         self.codes_futures.push(Box::pin(read_code_from_tx_hash(
             self.blobs.clone(),
             code_id,
-            blob_tx_hash,
+            tx_hash,
             Some(3),
         )));
     }
@@ -200,8 +200,8 @@ impl ObserverService {
 
                 // TODO: replace me with proper processing of all events, including commitments.
                 for event in &events {
-                    if let BlockEvent::Router(RouterEvent::CodeValidationRequested { code_id, blob_tx_hash }) = event {
-                        self.lookup_code(*code_id, *blob_tx_hash);
+                    if let BlockEvent::Router(RouterEvent::CodeValidationRequested { code_id, tx_hash }) = event {
+                        self.lookup_code(*code_id, *tx_hash);
                     }
                 }
 

ethexe/observer/src/query.rs

@@ -439,15 +439,11 @@ impl Query {
         Ok(events)
     }
 
-    pub async fn download_code(
-        &self,
-        expected_code_id: CodeId,
-        blob_tx_hash: H256,
-    ) -> Result<Vec<u8>> {
+    pub async fn download_code(&self, expected_code_id: CodeId, tx_hash: H256) -> Result<Vec<u8>> {
         let blob_reader = self.blob_reader.clone();
         let attempts = Some(3);
 
-        crate::read_code_from_tx_hash(blob_reader, expected_code_id, blob_tx_hash, attempts)
+        crate::read_code_from_tx_hash(blob_reader, expected_code_id, tx_hash, attempts)
             .await
             .map(|res| res.1)
     }