Merge branch 'dev' into dvush-add-key-size-test

contracts/scripts/init-faucet-account.ts

@@ -57,7 +57,7 @@ async function main() {
     console.log("Deposit successful");
 
     if (! await faucetWallet.isSigningKeySet()) {
-        const setSigningKey = await faucetWallet.setSigningKey();
+        const setSigningKey = await faucetWallet.setSigningKey({ feeToken: "MLTT" });
         await setSigningKey.awaitReceipt();
         console.log("Signing key is set");
     }

core/bin/data_restore/src/contract_functions.rs

@@ -73,12 +73,12 @@ pub fn get_genesis_account(genesis_transaction: &Transaction) -> Result<Account,
 /// # Arguments
 ///
 /// * `web3` - Web3 provider url
-/// * `franklin_contract` - Rollup contract
+/// * `zksync_contract` - Rollup contract
 ///
 pub async fn get_total_verified_blocks<T: Transport>(
-    franklin_contract: &(ethabi::Contract, Contract<T>),
+    zksync_contract: &(ethabi::Contract, Contract<T>),
 ) -> u32 {
-    franklin_contract
+    zksync_contract
         .1
         .query::<U256, Option<Address>, Option<BlockId>, ()>(
             "totalBlocksVerified",

core/bin/data_restore/src/data_restore_driver.rs

@@ -52,7 +52,7 @@ pub struct DataRestoreDriver<T: Transport> {
     /// Provides Ethereum Governance contract unterface
     pub governance_contract: (ethabi::Contract, Contract<T>),
     /// Provides Ethereum Rollup contract unterface
-    pub franklin_contract: (ethabi::Contract, Contract<T>),
+    pub zksync_contract: (ethabi::Contract, Contract<T>),
     /// Rollup contract events state
     pub events_state: EventsState,
     /// Rollup accounts state
@@ -80,7 +80,7 @@ impl<T: Transport> DataRestoreDriver<T> {
     /// * `connection_pool` - Database connection pool
     /// * `web3_transport` - Web3 provider transport
     /// * `governance_contract_eth_addr` - Governance contract address
-    /// * `franklin_contract_eth_addr` - Rollup contract address
+    /// * `zksync_contract_eth_addr` - Rollup contract address
     /// * `eth_blocks_step` - The step distance of viewing events in the ethereum blocks
     /// * `end_eth_blocks_offset` - The distance to the last ethereum block
     ///
@@ -89,7 +89,7 @@ impl<T: Transport> DataRestoreDriver<T> {
         connection_pool: ConnectionPool,
         web3_transport: T,
         governance_contract_eth_addr: H160,
-        franklin_contract_eth_addr: H160,
+        zksync_contract_eth_addr: H160,
         eth_blocks_step: u64,
         end_eth_blocks_offset: u64,
         available_block_chunk_sizes: Vec<usize>,
@@ -106,11 +106,11 @@ impl<T: Transport> DataRestoreDriver<T> {
             )
         };
 
-        let franklin_contract = {
+        let zksync_contract = {
             let abi = zksync_contract();
             (
                 abi.clone(),
-                Contract::new(web3.eth(), franklin_contract_eth_addr, abi),
+                Contract::new(web3.eth(), zksync_contract_eth_addr, abi),
             )
         };
 
@@ -122,7 +122,7 @@ impl<T: Transport> DataRestoreDriver<T> {
             connection_pool,
             web3,
             governance_contract,
-            franklin_contract,
+            zksync_contract,
             events_state,
             tree_state,
             eth_blocks_step,
@@ -140,12 +140,11 @@ impl<T: Transport> DataRestoreDriver<T> {
     /// # Arguments
     ///
     /// * `governance_contract_genesis_tx_hash` - Governance contract creation tx hash
-    /// * `franklin_contract_genesis_tx_hash` - Rollup contract creation tx hash
     ///
     pub async fn set_genesis_state(&mut self, genesis_tx_hash: H256) {
         let genesis_transaction = get_ethereum_transaction(&self.web3, &genesis_tx_hash)
             .await
-            .expect("Cant get franklin genesis transaction");
+            .expect("Cant get zkSync genesis transaction");
 
         // Setting genesis block number for events state
         let genesis_eth_block_number = self
@@ -230,7 +229,7 @@ impl<T: Transport> DataRestoreDriver<T> {
             }
             StorageUpdateState::None => {}
         }
-        let total_verified_blocks = get_total_verified_blocks(&self.franklin_contract).await;
+        let total_verified_blocks = get_total_verified_blocks(&self.zksync_contract).await;
         let last_verified_block = self.tree_state.state.block_number;
         log::info!(
             "State has been loaded\nProcessed {:?} blocks of total {:?} verified on contract\nRoot hash: {:?}\n",
@@ -257,7 +256,7 @@ impl<T: Transport> DataRestoreDriver<T> {
                     self.update_tree_state(new_ops_blocks).await;
 
                     let total_verified_blocks =
-                        get_total_verified_blocks(&self.franklin_contract).await;
+                        get_total_verified_blocks(&self.zksync_contract).await;
                     let last_verified_block = self.tree_state.state.block_number;
 
                     // We must update the Ethereum stats table to match the actual stored state
@@ -314,7 +313,7 @@ impl<T: Transport> DataRestoreDriver<T> {
             .events_state
             .update_events_state(
                 &self.web3,
-                &self.franklin_contract,
+                &self.zksync_contract,
                 &self.governance_contract,
                 self.eth_blocks_step,
                 self.end_eth_blocks_offset,

core/bin/data_restore/src/events_state.rs

@@ -76,15 +76,15 @@ impl EventsState {
     /// # Arguments
     ///
     /// * `web3` - Web3 provider url
-    /// * `franklin_contract` - Rollup contract
+    /// * `zksync_contract` - Rollup contract
     /// * `governance_contract` - Governance contract
     /// * `eth_blocks_step` - Blocks step for watching
     /// * `end_eth_blocks_offset` - Delta between last eth block and last watched block
     ///
     pub async fn update_events_state<T: Transport>(
         &mut self,
         web3: &Web3<T>,
-        franklin_contract: &(ethabi::Contract, Contract<T>),
+        zksync_contract: &(ethabi::Contract, Contract<T>),
         governance_contract: &(ethabi::Contract, Contract<T>),
         eth_blocks_step: u64,
         end_eth_blocks_offset: u64,
@@ -94,7 +94,7 @@ impl EventsState {
         let (block_events, token_events, to_block_number): (Vec<Log>, Vec<NewTokenEvent>, u64) =
             EventsState::get_new_events_and_last_watched_block(
                 web3,
-                franklin_contract,
+                zksync_contract,
                 governance_contract,
                 self.last_watched_eth_block_number,
                 eth_blocks_step,
@@ -104,7 +104,7 @@ impl EventsState {
 
         self.last_watched_eth_block_number = to_block_number;
 
-        if !self.update_blocks_state(franklin_contract, &block_events) {
+        if !self.update_blocks_state(zksync_contract, &block_events) {
             return Ok((vec![], token_events, self.last_watched_eth_block_number));
         }
 
@@ -133,15 +133,15 @@ impl EventsState {
     /// # Arguments
     ///
     /// * `web3` - Web3 provider url
-    /// * `franklin_contract` - Rollup contract
+    /// * `zksync_contract` - Rollup contract
     /// * `governance_contract` - Governance contract
     /// * `last_watched_block_number` - the current last watched eth block
     /// * `eth_blocks_step` - Ethereum blocks delta step
     /// * `end_eth_blocks_offset` - last block delta
     ///
     async fn get_new_events_and_last_watched_block<T: Transport>(
         web3: &Web3<T>,
-        franklin_contract: &(ethabi::Contract, Contract<T>),
+        zksync_contract: &(ethabi::Contract, Contract<T>),
         governance_contract: &(ethabi::Contract, Contract<T>),
         last_watched_block_number: u64,
         eth_blocks_step: u64,
@@ -168,13 +168,9 @@ impl EventsState {
 
         let from_block_number = BlockNumber::Number(from_block_number_u64.into());
 
-        let block_logs = EventsState::get_block_logs(
-            web3,
-            franklin_contract,
-            from_block_number,
-            to_block_number,
-        )
-        .await?;
+        let block_logs =
+            EventsState::get_block_logs(web3, zksync_contract, from_block_number, to_block_number)
+                .await?;
 
         let token_logs = EventsState::get_token_added_logs(
             web3,

core/bin/data_restore/src/rollup_ops.rs

@@ -2,15 +2,15 @@ use crate::eth_tx_helpers::{get_ethereum_transaction, get_input_data_from_ethere
 use crate::events::BlockEvent;
 use ethabi::ParamType;
 use web3::{Transport, Web3};
-use zksync_types::operations::FranklinOp;
+use zksync_types::operations::ZkSyncOp;
 
 /// Description of a Rollup operations block
 #[derive(Debug, Clone)]
 pub struct RollupOpsBlock {
     /// Rollup block number
     pub block_num: u32,
     /// Rollup operations in block
-    pub ops: Vec<FranklinOp>,
+    pub ops: Vec<ZkSyncOp>,
     /// Fee account
     pub fee_account: u32,
 }
@@ -77,20 +77,20 @@ impl RollupOpsBlock {
     ///
     /// # Arguments
     ///
-    /// * `data` - Franklin Contract event input data
+    /// * `data` - ZkSync Contract event input data
     ///
-    pub fn get_rollup_ops_from_data(data: &[u8]) -> Result<Vec<FranklinOp>, anyhow::Error> {
+    pub fn get_rollup_ops_from_data(data: &[u8]) -> Result<Vec<ZkSyncOp>, anyhow::Error> {
         let mut current_pointer = 0;
         let mut ops = vec![];
         while current_pointer < data.len() {
             let op_type: u8 = data[current_pointer];
 
-            let pub_data_size = FranklinOp::public_data_length(op_type)?;
+            let pub_data_size = ZkSyncOp::public_data_length(op_type)?;
 
             let pre = current_pointer;
             let post = pre + pub_data_size;
 
-            let op = FranklinOp::from_public_data(&data[pre..post])?;
+            let op = ZkSyncOp::from_public_data(&data[pre..post])?;
 
             ops.push(op);
             current_pointer += pub_data_size;
@@ -106,8 +106,8 @@ mod test {
     use zksync_types::operations::ChangePubKeyOp;
     use zksync_types::tx::{ChangePubKey, TxSignature};
     use zksync_types::{
-        Close, CloseOp, Deposit, DepositOp, FranklinOp, FullExit, FullExitOp, PubKeyHash, Transfer,
-        TransferOp, TransferToNewOp, Withdraw, WithdrawOp,
+        Close, CloseOp, Deposit, DepositOp, FullExit, FullExitOp, PubKeyHash, Transfer, TransferOp,
+        TransferToNewOp, Withdraw, WithdrawOp, ZkSyncOp,
     };
 
     #[test]
@@ -118,7 +118,7 @@ mod test {
             amount: 10u32.into(),
             to: "7777777777777777777777777777777777777777".parse().unwrap(),
         };
-        let op1 = FranklinOp::Deposit(Box::new(DepositOp {
+        let op1 = ZkSyncOp::Deposit(Box::new(DepositOp {
             priority_op,
             account_id: 6,
         }));
@@ -143,7 +143,7 @@ mod test {
             2,
             None,
         );
-        let op1 = FranklinOp::Withdraw(Box::new(WithdrawOp { tx, account_id: 3 }));
+        let op1 = ZkSyncOp::Withdraw(Box::new(WithdrawOp { tx, account_id: 3 }));
         let pub_data1 = op1.public_data();
         let op2 = RollupOpsBlock::get_rollup_ops_from_data(&pub_data1)
             .expect("cant get ops from data")
@@ -160,7 +160,7 @@ mod test {
             eth_address: [9u8; 20].into(),
             token: 1,
         };
-        let op1 = FranklinOp::FullExit(Box::new(FullExitOp {
+        let op1 = ZkSyncOp::FullExit(Box::new(FullExitOp {
             priority_op,
             withdraw_amount: Some(BigUint::from(444u32).into()),
         }));
@@ -180,7 +180,7 @@ mod test {
             eth_address: [9u8; 20].into(),
             token: 1,
         };
-        let op1 = FranklinOp::FullExit(Box::new(FullExitOp {
+        let op1 = ZkSyncOp::FullExit(Box::new(FullExitOp {
             priority_op,
             withdraw_amount: None,
         }));
@@ -205,7 +205,7 @@ mod test {
             3,
             None,
         );
-        let op1 = FranklinOp::TransferToNew(Box::new(TransferToNewOp {
+        let op1 = ZkSyncOp::TransferToNew(Box::new(TransferToNewOp {
             tx,
             from: 11,
             to: 12,
@@ -231,7 +231,7 @@ mod test {
             3,
             None,
         );
-        let op1 = FranklinOp::Transfer(Box::new(TransferOp {
+        let op1 = ZkSyncOp::Transfer(Box::new(TransferOp {
             tx,
             from: 11,
             to: 12,
@@ -252,7 +252,7 @@ mod test {
             nonce: 3,
             signature: TxSignature::default(),
         };
-        let op1 = FranklinOp::Close(Box::new(CloseOp { tx, account_id: 11 }));
+        let op1 = ZkSyncOp::Close(Box::new(CloseOp { tx, account_id: 11 }));
         let pub_data1 = op1.public_data();
         let op2 = RollupOpsBlock::get_rollup_ops_from_data(&pub_data1)
             .expect("cant get ops from data")
@@ -274,7 +274,7 @@ mod test {
             None,
             None,
         );
-        let op1 = FranklinOp::ChangePubKeyOffchain(Box::new(ChangePubKeyOp { tx, account_id: 11 }));
+        let op1 = ZkSyncOp::ChangePubKeyOffchain(Box::new(ChangePubKeyOp { tx, account_id: 11 }));
         let pub_data1 = op1.public_data();
         let op2 = RollupOpsBlock::get_rollup_ops_from_data(&pub_data1)
             .expect("cant get ops from data")

core/bin/data_restore/src/storage_interactor.rs

@@ -10,7 +10,7 @@ use zksync_storage::{
 };
 use zksync_types::{
     Action, Operation,
-    {block::Block, AccountMap, AccountUpdate, AccountUpdates, FranklinOp},
+    {block::Block, AccountMap, AccountUpdate, AccountUpdates, ZkSyncOp},
 };
 // Local deps
 use crate::{
@@ -169,7 +169,7 @@ pub fn block_event_into_stored_block_event(event: &BlockEvent) -> NewBlockEvent
 ///
 pub async fn save_rollup_ops(connection_pool: &ConnectionPool, blocks: &[RollupOpsBlock]) {
     let mut storage = connection_pool.access_storage().await.expect("db failed");
-    let mut ops: Vec<(u32, &FranklinOp, u32)> = vec![];
+    let mut ops: Vec<(u32, &ZkSyncOp, u32)> = vec![];
 
     for block in blocks {
         for op in &block.ops {
@@ -206,7 +206,7 @@ pub async fn get_ops_blocks_from_storage(connection_pool: &ConnectionPool) -> Ve
 ///
 /// # Arguments
 ///
-/// * `op_block` - Stored Franklin operations block description
+/// * `op_block` - Stored ZkSync operations block description
 ///
 pub fn stored_ops_block_into_ops_block(op_block: &StoredRollupOpsBlock) -> RollupOpsBlock {
     RollupOpsBlock {
@@ -306,7 +306,7 @@ pub async fn get_block_events_state_from_storage(connection_pool: &ConnectionPoo
 ///
 /// # Arguments
 ///
-/// * `block` - Stored representation of Franklin Contract event
+/// * `block` - Stored representation of ZkSync Contract event
 ///
 pub fn stored_block_event_into_block_event(block: StoredBlockEvent) -> BlockEvent {
     BlockEvent {