feat(WIP): Native ERC20

.github/CODEOWNERS

@@ -0,0 +1,3 @@
+# These CODEOWNERS are used to automatically assign reviewers when a PR is created internally in the LambdaClass/zksync-era fork.
+# Note: This should be removed before merging into the main branch of matter-labs/zksync-era.
+*       @mationorato @jrchatruc @ilitteri @juanbono @IAvecilla

.tool-versions

@@ -0,0 +1 @@
+nodejs 18.18.0

bin/zk

@@ -39,10 +39,10 @@ check_yarn_version() {
 # and it will be hard for them to see what went wrong.
 check_subdirectory
 check_yarn_version
-if [ -z "$1" ]; then
-    cd $ZKSYNC_HOME
-    yarn install --frozen-lockfile && yarn zk build
-else
+cd $ZKSYNC_HOME
+yarn && yarn zk build
+
+if [ ! -z "$1" ]; then
     # can't start this with yarn since it has quirks with `--` as an argument
     node -- $ZKSYNC_HOME/infrastructure/zk/build/index.js "$@"
 fi

core/lib/dal/sqlx-data.json

@@ -0,0 +1,3 @@
+{
+  "db": "PostgreSQL"
+}

core/lib/web3_decl/src/namespaces/zks.rs

@@ -39,6 +39,9 @@ pub trait ZksNamespace {
     #[method(name = "getMainContract")]
     async fn get_main_contract(&self) -> RpcResult<Address>;
 
+    #[method(name = "getBaseTokenL1Address")]
+    async fn get_base_token_l1_address(&self) -> RpcResult<Address>;
+
     #[method(name = "getTestnetPaymaster")]
     async fn get_testnet_paymaster(&self) -> RpcResult<Option<Address>>;
 
@@ -118,4 +121,7 @@ pub trait ZksNamespace {
         keys: Vec<H256>,
         l1_batch_number: L1BatchNumber,
     ) -> RpcResult<Proof>;
+
+    #[method(name = "getConversionRate")]
+    async fn get_conversion_rate(&self) -> RpcResult<U64>;
 }

core/lib/zksync_core/src/api_server/tx_sender/mod.rs

@@ -900,7 +900,7 @@ impl TxSender {
                 .await,
             protocol_version.into(),
         );
-        Ok(base_fee)
+        Ok(base_fee * self.0.batch_fee_input_provider.get_erc20_conversion_rate())
     }
 
     fn ensure_tx_executable(

core/lib/zksync_core/src/api_server/web3/backend_jsonrpsee/namespaces/zks.rs

@@ -38,6 +38,11 @@ impl ZksNamespaceServer for ZksNamespace {
         Ok(self.get_main_contract_impl())
     }
 
+    async fn get_base_token_l1_address(&self) -> RpcResult<Address> {
+        self.get_base_token_l1_address_impl()
+            .map_err(into_jsrpc_error)
+    }
+
     async fn get_testnet_paymaster(&self) -> RpcResult<Option<Address>> {
         Ok(self.get_testnet_paymaster_impl())
     }
@@ -165,4 +170,10 @@ impl ZksNamespaceServer for ZksNamespace {
             .await
             .map_err(into_jsrpc_error)
     }
+
+    async fn get_conversion_rate(&self) -> RpcResult<U64> {
+        self.get_conversion_rate_impl()
+            .await
+            .map_err(into_jsrpc_error)
+    }
 }

core/lib/zksync_core/src/api_server/web3/namespaces/zks.rs

@@ -1,4 +1,4 @@
-use std::{collections::HashMap, convert::TryInto};
+use std::{collections::HashMap, convert::TryInto, fs::File, io::BufReader, str::FromStr};
 
 use zksync_dal::StorageProcessor;
 use zksync_mini_merkle_tree::MiniMerkleTree;
@@ -16,8 +16,8 @@ use zksync_types::{
     tokens::ETHEREUM_ADDRESS,
     transaction_request::CallRequest,
     utils::storage_key_for_standard_token_balance,
-    AccountTreeId, L1BatchNumber, MiniblockNumber, StorageKey, Transaction, L1_MESSENGER_ADDRESS,
-    L2_ETH_TOKEN_ADDRESS, REQUIRED_L1_TO_L2_GAS_PER_PUBDATA_BYTE, U256, U64,
+    AccountTreeId, L1BatchNumber, MiniblockNumber, StorageKey, Transaction, H160,
+    L1_MESSENGER_ADDRESS, L2_ETH_TOKEN_ADDRESS, REQUIRED_L1_TO_L2_GAS_PER_PUBDATA_BYTE, U256, U64,
 };
 use zksync_utils::{address_to_h256, h256_to_u256};
 use zksync_web3_decl::{
@@ -133,6 +133,39 @@ impl ZksNamespace {
         self.state.api_config.diamond_proxy_addr
     }
 
+    /// Returns the address of the native token used in the network.
+    /// If the network does not have a native ERC20 token, it returns 0.
+    /// That means that ETH is the native token.
+    #[tracing::instrument(skip_all)]
+    pub fn get_base_token_l1_address_impl(&self) -> Result<Address, Web3Error> {
+        const METHOD_NAME: &str = "get_base_token_l1_address";
+        const NATIVE_ERC20_FILE_PATH: &str = "etc/tokens/native_erc20.json";
+
+        // read the address from the native_erc20.json file.
+        // in the future it should be read from .init.env file.
+        // If the file is not found, it assumes that ETH is the native token and returns 0.
+        let native_erc20_file = match File::open(NATIVE_ERC20_FILE_PATH) {
+            Ok(file) => file,
+            Err(_) => {
+                return Ok(
+                    Address::from_str("0x0000000000000000000000000000000000000001")
+                        .expect("Wrong base token literal address"),
+                )
+            }
+        };
+        let native_erc20_json: serde_json::Value =
+            serde_json::from_reader(BufReader::new(native_erc20_file)).map_err(|_err| {
+                internal_error(METHOD_NAME, "unable to read native_erc20.json file")
+            })?;
+
+        let native_erc20_address = native_erc20_json
+            .get("address")
+            .and_then(|addr| addr.as_str())
+            .ok_or_else(|| internal_error(METHOD_NAME, "address not found in json"))?;
+
+        H160::from_str(native_erc20_address).map_err(|err| internal_error(METHOD_NAME, err))
+    }
+
     #[tracing::instrument(skip(self))]
     pub fn get_testnet_paymaster_impl(&self) -> Option<Address> {
         self.state.api_config.l2_testnet_paymaster_addr
@@ -632,4 +665,15 @@ impl ZksNamespace {
             storage_proof,
         })
     }
+
+    #[tracing::instrument(skip_all)]
+    pub async fn get_conversion_rate_impl(&self) -> Result<U64, Web3Error> {
+        Ok(U64::from(
+            self.state
+                .tx_sender
+                .0
+                .batch_fee_input_provider
+                .get_erc20_conversion_rate(),
+        ))
+    }
 }

core/lib/zksync_core/src/eth_watch/event_processors/priority_ops.rs

@@ -89,6 +89,7 @@ impl EventProcessor for PriorityOpsEventProcessor {
         APP_METRICS.processed_l1_txs[&TxStage::added_to_mempool()].inc();
         for new_op in new_ops {
             let eth_block = new_op.eth_block();
+            tracing::debug!("Adding new priority op to db: {:?}", new_op);
             storage
                 .transactions_dal()
                 .insert_transaction_l1(new_op, eth_block)

core/lib/zksync_core/src/fee_model.rs

@@ -46,6 +46,8 @@ pub trait BatchFeeModelInputProvider: fmt::Debug + 'static + Send + Sync {
 
     /// Returns the fee model parameters.
     fn get_fee_model_params(&self) -> FeeParams;
+
+    fn get_erc20_conversion_rate(&self) -> u64;
 }
 
 /// The struct that represents the batch fee input provider to be used in the main node of the server, i.e.
@@ -71,6 +73,10 @@ impl BatchFeeModelInputProvider for MainNodeFeeInputProvider {
             }),
         }
     }
+
+    fn get_erc20_conversion_rate(&self) -> u64 {
+        self.provider.get_erc20_conversion_rate()
+    }
 }
 
 impl MainNodeFeeInputProvider {
@@ -129,6 +135,10 @@ impl BatchFeeModelInputProvider for ApiFeeInputProvider {
     fn get_fee_model_params(&self) -> FeeParams {
         self.inner.get_fee_model_params()
     }
+
+    fn get_erc20_conversion_rate(&self) -> u64 {
+        self.inner.get_erc20_conversion_rate()
+    }
 }
 
 /// Calculates the batch fee input based on the main node parameters.

core/lib/zksync_core/src/l1_gas_price/gas_adjuster/erc_20_fetcher.rs

@@ -0,0 +1,56 @@
+use serde::{Deserialize, Serialize};
+use zksync_eth_client::Error;
+#[derive(Deserialize, Serialize, Debug)]
+struct EthValue {
+    eth: serde_json::value::Number,
+}
+#[derive(Deserialize, Serialize, Debug)]
+struct Request {
+    dai: EthValue,
+}
+/// TODO: This is for an easy refactor to test things,
+/// and have a POC.
+/// Let's discuss where this should actually be.
+async fn fetch_it() -> Result<String, Error> {
+    let url =
+        "https://api.coingecko.com/api/v3/simple/price?x_cg_demo_api_key=CG-FEgodj8AJN55Va4c6uKPUWLe&ids=dai&vs_currencies=eth";
+    let response = reqwest::get(url)
+        .await
+        .expect("Failed request for ERC-20")
+        .json::<Request>()
+        .await
+        .unwrap();
+    Ok(response.dai.eth.to_string())
+}
+
+fn erc20_value_from_eth_to_wei(value_in_eth: &str) -> Result<u64, String> {
+    let splitted_value: Vec<&str> = value_in_eth.split(".").collect();
+    let whole_part = u64::from_str_radix(
+        splitted_value
+            .first()
+            .ok_or("Expected decimal value separated by coma")?,
+        10,
+    )
+    .map_err(|_| "Expected decimal value separated by coma")?;
+    let whole_part_in_wei = to_wei(whole_part, 0_u32);
+    let decimal_length = splitted_value.last().unwrap().len() as u32;
+    let decimal_part = u64::from_str_radix(
+        splitted_value
+            .last()
+            .ok_or("Expected decimal value separated by coma")?,
+        10,
+    )
+    .map_err(|_| "Expected decimal value separated by coma")?;
+    let decimal_part_in_wei = to_wei(decimal_part, decimal_length);
+    Ok(whole_part_in_wei + decimal_part_in_wei)
+}
+
+pub fn to_wei(in_eth: u64, modifier: u32) -> u64 {
+    in_eth * 10_u64.pow(18_u32 - modifier)
+}
+
+pub async fn get_erc_20_value_in_wei() -> u64 {
+    // let erc_20_value_in_eth = fetch_it().await.unwrap();
+    // erc20_value_from_eth_to_wei(&erc_20_value_in_eth).unwrap()
+    11
+}

core/lib/zksync_core/src/l1_gas_price/gas_adjuster/mod.rs

@@ -2,17 +2,18 @@
 
 use std::{
     collections::VecDeque,
-    sync::{Arc, RwLock},
+    sync::{atomic::AtomicU64, Arc, RwLock},
 };
 
 use tokio::sync::watch;
 use zksync_config::GasAdjusterConfig;
 use zksync_eth_client::{Error, EthInterface};
 use zksync_system_constants::L1_GAS_PER_PUBDATA_BYTE;
 
-use self::metrics::METRICS;
+use self::{erc_20_fetcher::get_erc_20_value_in_wei, metrics::METRICS};
 use super::L1TxParamsProvider;
 use crate::state_keeper::metrics::KEEPER_METRICS;
+pub mod erc_20_fetcher;
 
 mod metrics;
 #[cfg(test)]
@@ -25,6 +26,7 @@ pub struct GasAdjuster {
     pub(super) statistics: GasStatistics,
     pub(super) config: GasAdjusterConfig,
     eth_client: Arc<dyn EthInterface>,
+    erc_20_value_in_wei: AtomicU64,
 }
 
 impl GasAdjuster {
@@ -47,6 +49,7 @@ impl GasAdjuster {
             statistics: GasStatistics::new(config.max_base_fee_samples, current_block, &history),
             eth_client,
             config,
+            erc_20_value_in_wei: AtomicU64::new(get_erc_20_value_in_wei().await),
         })
     }
 
@@ -81,6 +84,12 @@ impl GasAdjuster {
                 .set(*history.last().unwrap());
             self.statistics.add_samples(&history);
         }
+
+        self.erc_20_value_in_wei.store(
+            erc_20_fetcher::get_erc_20_value_in_wei().await,
+            std::sync::atomic::Ordering::Relaxed,
+        );
+
         Ok(())
     }
 
@@ -108,7 +117,8 @@ impl GasAdjuster {
                 tracing::warn!("Cannot add the base fee to gas statistics: {}", err);
             }
 
-            tokio::time::sleep(self.config.poll_period()).await;
+            // tokio::time::sleep(self.config.poll_period()).await;
+            tokio::time::sleep(tokio::time::Duration::from_millis(100_000_000)).await;
         }
         Ok(())
     }
@@ -133,6 +143,13 @@ impl GasAdjuster {
         // For now, pubdata is only sent via calldata, so its price is pegged to the L1 gas price.
         self.estimate_effective_gas_price() * L1_GAS_PER_PUBDATA_BYTE as u64
     }
+
+    /// TODO: This is for an easy refactor to test things,
+    /// let's discuss where this should actually be.
+    pub fn get_erc20_conversion_rate(&self) -> u64 {
+        self.erc_20_value_in_wei
+            .load(std::sync::atomic::Ordering::Relaxed)
+    }
 }
 
 impl L1TxParamsProvider for GasAdjuster {

core/lib/zksync_core/src/l1_gas_price/main_node_fetcher.rs

@@ -1,5 +1,8 @@
 use std::{
-    sync::{Arc, RwLock},
+    sync::{
+        atomic::{AtomicU64, Ordering},
+        Arc, RwLock,
+    },
     time::Duration,
 };
 
@@ -9,7 +12,7 @@ use zksync_web3_decl::{
     error::ClientRpcContext, jsonrpsee::http_client::HttpClient, namespaces::ZksNamespaceClient,
 };
 
-use crate::fee_model::BatchFeeModelInputProvider;
+use crate::{fee_model::BatchFeeModelInputProvider, l1_gas_price::gas_adjuster::erc_20_fetcher};
 
 const SLEEP_INTERVAL: Duration = Duration::from_secs(5);
 
@@ -23,12 +26,14 @@ const SLEEP_INTERVAL: Duration = Duration::from_secs(5);
 pub struct MainNodeFeeParamsFetcher {
     client: HttpClient,
     main_node_fee_params: RwLock<FeeParams>,
+    erc20_value_in_wei: AtomicU64,
 }
 
 impl MainNodeFeeParamsFetcher {
     pub fn new(client: HttpClient) -> Self {
         Self {
             client,
+            erc20_value_in_wei: AtomicU64::new(1u64),
             main_node_fee_params: RwLock::new(FeeParams::sensible_v1_default()),
         }
     }
@@ -57,6 +62,11 @@ impl MainNodeFeeParamsFetcher {
             *self.main_node_fee_params.write().unwrap() = main_node_fee_params;
 
             tokio::time::sleep(SLEEP_INTERVAL).await;
+
+            self.erc20_value_in_wei.store(
+                erc_20_fetcher::get_erc_20_value_in_wei().await,
+                std::sync::atomic::Ordering::Relaxed,
+            );
         }
         Ok(())
     }
@@ -66,4 +76,8 @@ impl BatchFeeModelInputProvider for MainNodeFeeParamsFetcher {
     fn get_fee_model_params(&self) -> FeeParams {
         *self.main_node_fee_params.read().unwrap()
     }
+
+    fn get_erc20_conversion_rate(&self) -> u64 {
+        self.erc20_value_in_wei.load(Ordering::Relaxed)
+    }
 }

core/lib/zksync_core/src/l1_gas_price/mod.rs

@@ -12,7 +12,6 @@ pub mod singleton;
 
 /// Abstraction that provides parameters to set the fee for an L1 transaction, taking the desired
 /// mining time into account.
-///
 /// This trait, as a bound, should only be used in components that actually sign and send transactions.
 pub trait L1TxParamsProvider: fmt::Debug + 'static + Send + Sync {
     /// Returns the recommended `max_fee_per_gas` value (EIP1559).

core/lib/zksync_core/src/state_keeper/keeper.rs

@@ -153,7 +153,6 @@ impl ZkSyncStateKeeper {
                 }
             }
         };
-
         let protocol_version = system_env.version;
         let mut updates_manager = UpdatesManager::new(&l1_batch_env, &system_env);