sync with draft-v30 + make server compile

Author: StanislavBreadless

.github/workflows/ci-core-reusable.yml

@@ -63,7 +63,6 @@ jobs:
       - name: Install yarn
         run: |
           npm install -g yarn
-
       - name: Check contracts hashes
         working-directory: contracts
         run: |
@@ -151,7 +150,7 @@ jobs:
       # ----------------------------------------------
       matrix:
         use_gateway_chain: [ "WITH_GATEWAY", "WITHOUT_GATEWAY" ]
-        tested_chain_type: [ "era", "validium", "custom_token"]
+        tested_chain_type: [ "era", "validium", "custom_token" ]
       # In some cases it's useful to continue one job even if another fails.
       fail-fast: false
     steps:

.gitignore

@@ -17,6 +17,7 @@ tags
 *.orig
 .direnv
 .cache
+cache
 
 # Yarn files
 .yarn/

bin/build_and_init_ecosystem

@@ -19,7 +19,7 @@ initialize_ecosystem() {
   echo "[initialize_ecosystem] started"
   zkstack ecosystem init \
     --deploy-paymaster --deploy-erc20 --deploy-ecosystem \
-    --l1-rpc-url=http://localhost:8545 \
+    --l1-rpc-url=http://127.0.0.1:8545 \
     --server-db-url=postgres://postgres:notsecurepassword@localhost:5432 \
     --server-db-name=zksync_server_localhost_era \
     --ignore-prerequisites --verbose \

chains/era/ZkStack.yaml

@@ -3,7 +3,6 @@ name: era
 chain_id: 271
 prover_version: NoProofs
 l1_network: Localhost
-link_to_code: .
 configs: ./chains/era/configs/
 rocks_db_path: ./chains/era/db/
 external_node_config_path: ./chains/era/configs/external_node

contracts

@@ -16,7 +16,7 @@ use zksync_dal::{Connection, CoreDal};
 use zksync_object_store::{MockObjectStore, ObjectStore};
 use zksync_types::{
     block::{L1BatchHeader, L1BatchTreeData, L2BlockHeader},
-    settlement::SettlementLayer,
+    commitment::PubdataParams,
     snapshots::{
         SnapshotFactoryDependencies, SnapshotFactoryDependency, SnapshotStorageLog,
         SnapshotStorageLogsChunk, SnapshotStorageLogsStorageKey,
@@ -173,7 +173,7 @@ async fn create_l2_block(
         base_fee_per_gas: 0,
         gas_per_pubdata_limit: 0,
         batch_fee_input: Default::default(),
-        pubdata_params: Default::default(),
+        pubdata_params: PubdataParams::genesis(),
         base_system_contracts_hashes: Default::default(),
         protocol_version: Some(Default::default()),
         virtual_blocks: 0,

core/bin/snapshots_creator/src/tests.rs

@@ -74,7 +74,7 @@ use zksync_state_keeper::node::{
 };
 use zksync_tee_proof_data_handler::node::TeeProofDataHandlerLayer;
 use zksync_types::{
-    commitment::{L1BatchCommitmentMode, PubdataType},
+    commitment::{L1BatchCommitmentMode, L2DACommitmentScheme, PubdataType},
     pubdata_da::PubdataSendingMode,
     Address, L2ChainId,
 };
@@ -129,6 +129,37 @@ impl MainNodeBuilder {
         }
     }
 
+    pub fn l2_da_commitment_scheme(&self) -> L2DACommitmentScheme {
+        let use_dummy_inclusion_data = self
+            .configs
+            .da_dispatcher_config
+            .as_ref()
+            .map(|a| a.use_dummy_inclusion_data)
+            .unwrap_or_default();
+
+        // For DA clients we have two options verify the pubdata inclusion on SL or not.
+        // If we do not verify it, we can use EmptyNoDA commitment scheme in this case
+        // use_dummy_inclusion_data is true.
+        // If the DA client is not specified, we assume that we publish all data to SL
+        // and we have to verify it
+
+        if use_dummy_inclusion_data {
+            return L2DACommitmentScheme::EmptyNoDA;
+        }
+
+        match &self.configs.da_client_config {
+            Some(DAClientConfig::NoDA) => L2DACommitmentScheme::EmptyNoDA,
+            Some(DAClientConfig::ObjectStore(_)) => L2DACommitmentScheme::EmptyNoDA,
+            Some(DAClientConfig::Avail(_)) => L2DACommitmentScheme::PubdataKeccak256,
+            Some(DAClientConfig::Celestia(_)) => L2DACommitmentScheme::PubdataKeccak256,
+            Some(DAClientConfig::Eigen(_)) => L2DACommitmentScheme::PubdataKeccak256,
+            None => {
+                tracing::info!("DAClientConfig is not specified, setting L2DACommitmentScheme to BlobsAndPubdataKeccak256");
+                L2DACommitmentScheme::BlobsAndPubdataKeccak256
+            }
+        }
+    }
+
     fn add_sigint_handler_layer(mut self) -> anyhow::Result<Self> {
         self.node.add_layer(SigintHandlerLayer);
         Ok(self)
@@ -326,6 +357,7 @@ impl MainNodeBuilder {
                     .genesis_config
                     .l1_batch_commit_data_generator_mode,
                 dummy_verifier: self.genesis_config.dummy_verifier,
+                config_l2_da_commitment_scheme: self.l2_da_commitment_scheme(),
             }));
         Ok(self)
     }

core/bin/zksync_server/src/node_builder.rs

@@ -98,8 +98,125 @@ impl FromStr for PubdataType {
     }
 }
 
-#[derive(Default, Copy, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Display)]
+#[repr(u8)]
+pub enum L2DACommitmentScheme {
+    None = 0,
+    EmptyNoDA = 1,
+    PubdataKeccak256 = 2,
+    BlobsAndPubdataKeccak256 = 3,
+}
+
+impl TryFrom<u8> for L2DACommitmentScheme {
+    type Error = &'static str;
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            0 => Ok(L2DACommitmentScheme::None),
+            1 => Ok(L2DACommitmentScheme::EmptyNoDA),
+            2 => Ok(L2DACommitmentScheme::PubdataKeccak256),
+            3 => Ok(L2DACommitmentScheme::BlobsAndPubdataKeccak256),
+            _ => Err("Invalid L2DACommitmentScheme value"),
+        }
+    }
+}
+
+impl FromStr for L2DACommitmentScheme {
+    type Err = &'static str;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "None" => Ok(Self::None),
+            "EmptyNoDA" => Ok(Self::EmptyNoDA),
+            "PubdataKeccak256" => Ok(Self::PubdataKeccak256),
+            "BlobsAndPubdataKeccak256" => Ok(Self::BlobsAndPubdataKeccak256),
+            _ => Err("Incorrect L2 DA commitment scheme; expected one of `None`, `EmptyNoDA`, `PubdataKeccak256`, `BlobsAndPubdataKeccak256`"),
+        }
+    }
+}
+
+#[derive(Copy, Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub enum L2PubdataValidator {
+    Address(Address),
+    CommitmentScheme(L2DACommitmentScheme),
+}
+
+impl TryFrom<(Option<Address>, Option<L2DACommitmentScheme>)> for L2PubdataValidator {
+    type Error = anyhow::Error;
+
+    fn try_from(
+        value: (Option<Address>, Option<L2DACommitmentScheme>),
+    ) -> Result<Self, Self::Error> {
+        match value {
+            (None, Some(scheme)) => Ok(L2PubdataValidator::CommitmentScheme(scheme)),
+            (Some(address), None) => Ok(L2PubdataValidator::Address(address)),
+            (Some(_), Some(_)) => anyhow::bail!(
+                "Address and L2DACommitmentScheme are specified, should be chosen only one"
+            ),
+            (None, None) => anyhow::bail!(
+                "Address and L2DACommitmentScheme are not specified, should be chosen at least one"
+            ),
+        }
+    }
+}
+
+impl L2PubdataValidator {
+    pub fn l2_da_validator(&self) -> Option<Address> {
+        match self {
+            L2PubdataValidator::Address(addr) => Some(*addr),
+            L2PubdataValidator::CommitmentScheme(_) => None,
+        }
+    }
+
+    pub fn l2_da_commitment_scheme(&self) -> Option<L2DACommitmentScheme> {
+        match self {
+            L2PubdataValidator::Address(_) => None,
+            L2PubdataValidator::CommitmentScheme(scheme) => Some(*scheme),
+        }
+    }
+}
+
+#[derive(Copy, Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct PubdataParams {
-    pub l2_da_validator_address: Address,
-    pub pubdata_type: PubdataType,
+    pubdata_validator: L2PubdataValidator,
+    pubdata_type: PubdataType,
+}
+
+impl PubdataParams {
+    pub fn new(
+        pubdata_validator: L2PubdataValidator,
+        pubdata_type: PubdataType,
+    ) -> anyhow::Result<Self> {
+        if L2PubdataValidator::CommitmentScheme(L2DACommitmentScheme::None) == pubdata_validator {
+            anyhow::bail!("L2DACommitmentScheme::None is not allowed as a legit pubdata parameter");
+        };
+
+        Ok(PubdataParams {
+            pubdata_validator,
+            pubdata_type,
+        })
+    }
+
+    pub fn pubdata_validator(&self) -> L2PubdataValidator {
+        self.pubdata_validator
+    }
+
+    pub fn pubdata_type(&self) -> PubdataType {
+        self.pubdata_type
+    }
+
+    pub fn genesis() -> Self {
+        PubdataParams {
+            pubdata_validator: L2PubdataValidator::CommitmentScheme(
+                L2DACommitmentScheme::BlobsAndPubdataKeccak256,
+            ),
+            pubdata_type: PubdataType::Rollup,
+        }
+    }
+
+    pub fn pre_gateway() -> Self {
+        PubdataParams {
+            pubdata_validator: L2PubdataValidator::Address(Address::zero()),
+            pubdata_type: Default::default(),
+        }
+    }
 }

core/lib/basic_types/src/commitment.rs

@@ -132,7 +132,6 @@ impl ProtocolVersionId {
             ProtocolVersionId::Version28 => VmVersion::VmEcPrecompiles,
             ProtocolVersionId::Version29 => VmVersion::VmInterop,
             ProtocolVersionId::Version30 => VmVersion::VmMediumInterop,
-
             // Speculative VM version for the next protocol version to be used in the upgrade integration test etc.
             ProtocolVersionId::Version31 => VmVersion::VmMediumInterop,
         }

core/lib/basic_types/src/protocol_version.rs

@@ -20,12 +20,11 @@ pub trait Detokenize: Sized {
 
 impl<T: Tokenizable> Detokenize for T {
     fn from_tokens(mut tokens: Vec<ethabi::Token>) -> Result<Self, Error> {
-        if tokens.len() != 1 {
-            return Err(Error::InvalidOutputType(format!(
-                "expected array with 1 token, got {tokens:?}"
-            )));
+        if tokens.len() == 1 {
+            Self::from_token(tokens.pop().unwrap())
+        } else {
+            Self::from_token(ethabi::Token::Tuple(tokens))
         }
-        Self::from_token(tokens.pop().unwrap())
     }
 }