avs v0.2.3: support scroll curie v5.5.0

Author: chzyer

Cargo.lock

@@ -27,6 +27,7 @@ pub struct PublicApi {
     pub prover: Arc<Prover>,
     pub verifier: Option<Arc<verifier::Client>>,
     pub l2_el: Option<Arc<ExecutionClient>>,
+    pub l2_chain_id: u64,
     pub l1_el: Option<Arc<L1ExecutionClient>>,
     // pub relay: Option<Secp256k1PrivateKey>,
     pub insecure: bool,
@@ -194,8 +195,14 @@ impl PublicApi {
             Some(poe) => poe,
             None => {
                 let start = Time::now();
-                let result =
-                    App::generate_poe_by_pob(&self.alive, &self.prover, &batch, pob_list, 4);
+                let result = App::generate_poe_by_pob(
+                    &self.alive,
+                    self.l2_chain_id,
+                    &self.prover,
+                    &batch,
+                    pob_list,
+                    4,
+                );
                 self.pobda_task_mgr.update_task(key, result.clone());
                 self.metrics
                     .gauge_prove_ms
@@ -289,15 +296,24 @@ impl PublicApi {
         let poe = match self.task_mgr.process_task(batch_task.clone()) {
             Some(poe) => poe,
             None => {
-                let result =
-                    App::generate_poe(&self.alive, l2_el, &self.prover, batch_task.clone());
+                let result = App::generate_poe(
+                    &self.alive,
+                    self.l2_chain_id,
+                    l2_el,
+                    &self.prover,
+                    batch_task.clone(),
+                );
                 self.task_mgr
                     .update_task(batch_task.clone(), result.clone());
                 result
             }
         }
         .map_err(JsonrpcErrorObj::unknown)?;
 
+        if poe.batch_hash != batch_hash {
+            return Err(JsonrpcErrorObj::client("batch hash mismatch, skip".into()));
+        }
+
         Ok(PoeResponse {
             not_ready: false,
             start_block,
@@ -467,6 +483,7 @@ impl Getter<RpcServer<PublicApi>> for App {
         let api = Arc::new(PublicApi {
             alive: self.alive.clone(),
             l2_el: self.l2_el.option_get(self),
+            l2_chain_id: self.l2_chain_id.get(self).0,
             l1_el: self.l1_el.option_get(self),
             prover: self.prover.get(self),
             verifier: self.verifier.option_get(self),

bin/sgx/Cargo.lock

@@ -9,7 +9,7 @@ use eth_types::SH256;
 use jsonrpc::{MixRpcClient, RpcServer};
 use prometheus::CollectorRegistry;
 use prover::{Database, Pob, Prover};
-use scroll_types::{BatchChunkBlockTx, BatchChunkBuilder, BatchTask, Poe, TransactionInner};
+use scroll_types::{BatchChunkBlockTx, BatchChunkBuilder, BatchTask, Poe, TransactionInner, get_fork};
 use std::collections::btree_map::Entry;
 use std::collections::BTreeMap;
 use std::sync::{Arc, Mutex};
@@ -114,6 +114,7 @@ impl App {
 
     pub fn generate_poe_by_pob(
         alive: &Alive,
+        chain_id: u64,
         prover: &Arc<Prover>,
         batch: &BatchTask,
         pob_list: Arc<Vec<Pob>>,
@@ -162,8 +163,11 @@ impl App {
 
         let reports = Arc::try_unwrap(ctx).unwrap();
         let reports = reports.into_inner().unwrap();
+        let version = get_fork(chain_id, block_numbers[0]);
 
-        let batch_header = batch.build_header(&batch_chunk.chunks).map_err(debug)?;
+        let batch_header = batch
+            .build_header(version, &batch_chunk.chunks)
+            .map_err(debug)?;
         let poe = prover
             .merge_poe(batch_header.hash(), &reports)
             .ok_or(format!("fail to gen poe"))?;
@@ -174,6 +178,7 @@ impl App {
 
     pub fn generate_poe(
         alive: &Alive,
+        chain_id: u64,
         l2: &Arc<ExecutionClient>,
         prover: &Arc<Prover>,
         task: BatchTask,
@@ -247,8 +252,11 @@ impl App {
 
         let ctx = ctx.lock().unwrap();
         let reports = &ctx.0;
+        let fork = get_fork(chain_id, block_numbers[0]);
 
-        let batch_header = task.build_header(&batch_chunk.chunks).map_err(debug)?;
+        let batch_header = task
+            .build_header(fork, &batch_chunk.chunks)
+            .map_err(debug)?;
 
         let poe = prover
             .merge_poe(batch_header.hash(), &reports)
@@ -260,13 +268,14 @@ impl App {
     pub fn commit_batch(
         alive: &Alive,
         l2: &Arc<ExecutionClient>,
+        chain_id: u64,
         prover: &Arc<Prover>,
         relay_acc: &Secp256k1PrivateKey,
         verifier: &verifier::Client,
         task: BatchTask,
     ) -> Result<SH256, String> {
         let batch_id = task.id().into();
-        let poe = Self::generate_poe(alive, l2, prover, task)?;
+        let poe = Self::generate_poe(alive, chain_id, l2, prover, task)?;
         verifier.commit_batch(relay_acc, &batch_id, &poe.encode())
     }
 
@@ -415,7 +424,7 @@ impl OptionGetter<ExecutionClient> for App {
     }
 }
 
-pub struct L2ChainID(u64);
+pub struct L2ChainID(pub u64);
 
 impl Getter<L2ChainID> for App {
     fn generate(&self) -> L2ChainID {

src/apps/prover/src/api.rs

@@ -10,8 +10,8 @@ resolver = "2"
 [features]
 default = ["std"]
 
-std = ["num-bigint/std", "evm/std", "glog/std", "crypto/std", "eth_types/std", "statedb/std", "base/std", "eth_client/std", "scroll_types/std"]
-tstd = ["sgxlib/tstd", "num-bigint/tstd", "evm/tstd", "glog/tstd", "crypto/tstd", "eth_types/tstd", "statedb/tstd", "base/tstd", "eth_client/tstd", "scroll_types/tstd"]
+std = ["num-bigint/std", "evm/std", "glog/std", "crypto/std", "eth_types/std", "statedb/std", "base/std", "eth_client/std", "scroll_types/std", "serde/std", "serde_json/std"]
+tstd = ["sgxlib/tstd", "num-bigint/tstd", "evm/tstd", "glog/tstd", "crypto/tstd", "eth_types/tstd", "statedb/tstd", "base/tstd", "eth_client/tstd", "scroll_types/tstd", "serde/tstd", "serde_json/tstd"]
 
 [dependencies]
 sgxlib = { git = "https://github.com/automata-network/sgxlib", default-features = false }
@@ -25,7 +25,12 @@ base = { git = "https://github.com/automata-network/base-rs", default-features =
 scale-info-derive = "=2.10"
 
 evm = { git = "https://github.com/automata-network/evm-rs", default-features = false }
+serde = { git = "https://github.com/automata-network/sgxlib-thirdparty", default-features = false }
+serde_json = { git = "https://github.com/automata-network/sgxlib-thirdparty", default-features = false }
 num-bigint = { git = "https://github.com/automata-network/sgxlib-thirdparty", default-features = false }
+p256 = { version = "0.11.1", default-features = false, features = [
+    "ecdsa",
+] }
 # revm = { path = "../../revm/crates/revm", default-features = false }
 
 bn = { package = "substrate-bn", version = "0.6", default-features = false }

src/apps/prover/src/app.rs

@@ -12,4 +12,5 @@ pub struct Context<'a> {
     pub tx: &'a PoolTx,
     pub header: &'a BlockHeader,
     pub extra_fee: Option<SU256>,
+    pub burn_base_fee: bool,
 }

src/common/evm_executor/Cargo.toml

@@ -2,6 +2,7 @@ use std::prelude::v1::*;
 
 use super::{Context, StateProxy};
 use base::format::parse_ether;
+use base::thread::PanicContext;
 use eth_types::{HexBytes, Log, Receipt, SH256, SU256, SU64};
 use statedb::StateDB;
 
@@ -42,6 +43,8 @@ impl<'a, D: StateDB> Executor<'a, D> {
         state_db: &'a mut D,
         tx_idx: u64,
     ) -> Result<Receipt, ExecuteError> {
+        let _panic_ctx = PanicContext(ctx.tx.tx.hash());
+
         let mut result = Executor::new(ctx.clone(), state_db).run(false)?;
         for log in &mut result.logs {
             log.transaction_hash = ctx.tx.hash;
@@ -72,11 +75,14 @@ impl<'a, D: StateDB> Executor<'a, D> {
         let config = self.ctx.cfg;
         let tx = &self.ctx.tx.tx;
         let mut base_fee = self.ctx.header.base_fee_per_gas;
-        let gas_fee_cap = tx.max_fee_per_gas();
+        let mut gas_fee_cap = tx.max_fee_per_gas();
 
         if tx.can_check_nonce() {
             self.check_nonce(true, dry_run)?;
         }
+        if !tx.cost_gas() {
+            base_fee = None;
+        }
 
         if let Some(fee) = &base_fee {
             if fee > gas_fee_cap {
@@ -257,9 +263,11 @@ impl<'a, D: StateDB> Executor<'a, D> {
             }
         }
 
-        let gas_tip_cap = tx.max_priority_fee_per_gas();
-        let gas_fee_cap = tx.max_fee_per_gas();
+        let mut gas_tip_cap = tx.max_priority_fee_per_gas();
         if let Some(base_fee) = &base_fee {
+            if !tx.cost_gas() {
+                gas_tip_cap = base_fee;
+            }
             if base_fee > gas_fee_cap {
                 glog::info!(
                     "invalid tx: {:?}, base_fee:{:?}, gas_fee_cap:{:?}",
@@ -269,7 +277,14 @@ impl<'a, D: StateDB> Executor<'a, D> {
                 )
             }
         }
-        let effective_tip = (*gas_tip_cap).min(*gas_fee_cap - base_fee.unwrap_or(SU256::zero()));
+
+        let mut effective_tip =
+            (*gas_tip_cap).min(*gas_fee_cap - base_fee.unwrap_or(SU256::zero()));
+        if !self.ctx.burn_base_fee {
+            if let Some(base_fee) = base_fee {
+                effective_tip += base_fee;
+            }
+        }
         let miner = if dry_run {
             eth_types::zero_addr()
         } else {

src/common/evm_executor/src/context.rs

@@ -1,13 +1,23 @@
 use std::prelude::v1::*;
 
 use eth_types::{SH160, SH256, SU256};
-use scroll_types::TransactionInner;
+use scroll_types::{ScrollFork, TransactionInner};
 use statedb::StateDB;
 
 lazy_static::lazy_static! {
     static ref SLOT_L1_BASE_FEE: SH256 = SU256::from(1).into();
     static ref SLOT_OVERHEAD: SH256 = SU256::from(2).into();
     static ref SLOT_SCALAR: SH256 = SU256::from(3).into();
+
+    // curie
+    static ref SLOT_L1_BLOB_BASE_FEE: SH256 = SU256::from(5).into();
+    static ref SLOT_COMMIT_SCALAR: SH256 = SU256::from(6).into();
+    static ref SLOT_BLOB_SCALAR_SLOT: SH256 = SU256::from(7).into();
+    static ref SLOT_IS_CURIE: SH256 = SU256::from(8).into();
+
+    static ref INITIAL_COMMIT_SCALAR: SU256 = "230759955285".into();
+    static ref INITIAL_BLOB_SCALAR: SU256 = "417565260".into();
+
     static ref GAS_FEE_PRECISION: SU256 = SU256::from(1_000_000_000u64);
     static ref L1_GAS_PRICE_ORACLE_ADDRESS: SH160 = "0x5300000000000000000000000000000000000002".into();
     static ref FEE_VAULT_ADDRESS: SH160 = "0x5300000000000000000000000000000000000005".into();
@@ -23,6 +33,7 @@ where
 }
 
 pub fn calculate_l1_data_fee<S>(
+    fork: ScrollFork,
     cfg: &evm::Config,
     tx: &TransactionInner,
     state: &mut S,
@@ -35,14 +46,20 @@ where
     }
     let raw = tx.to_bytes();
     let l1_fee = read_gpo_storage_slots(&L1_GAS_PRICE_ORACLE_ADDRESS, state)?;
-    let data_fee = l1_fee.data_fee(cfg, &raw);
+    let data_fee = l1_fee.data_fee(fork, cfg, &raw);
     Ok(data_fee)
 }
 
+#[derive(Debug)]
 pub struct L1GasFee {
     pub l1_base_fee: SU256,
     pub overhead: SU256,
     pub scalar: SU256,
+
+    // curie
+    pub l1_blob_base_fee: SU256,
+    pub commit_scalar: SU256,
+    pub blob_scalar: SU256,
 }
 
 impl L1GasFee {
@@ -72,11 +89,28 @@ impl L1GasFee {
         SU256::from(l1_gas) + self.overhead
     }
 
-    pub fn data_fee(&self, cfg: &evm::Config, data: &[u8]) -> SU256 {
+    pub fn data_fee(&self, fork: ScrollFork, cfg: &evm::Config, data: &[u8]) -> SU256 {
+        match fork {
+            ScrollFork::Bernoulli => self.data_fee_bernoulli(cfg, data),
+            ScrollFork::Curie => self.data_fee_curie(data),
+        }
+    }
+
+    pub fn data_fee_bernoulli(&self, cfg: &evm::Config, data: &[u8]) -> SU256 {
         let l1_gas_used = self.gas_used(cfg, data);
         let l1_data_fee = l1_gas_used * self.l1_base_fee;
         l1_data_fee * self.scalar / *GAS_FEE_PRECISION
     }
+
+    pub fn data_fee_curie(&self, data: &[u8]) -> SU256 {
+        let calldata_gas = self.commit_scalar * self.l1_base_fee;
+
+        // blob component of commit fees
+        let blob_gas: SU256 = self.l1_blob_base_fee * self.blob_scalar * SU256::from(data.len() as u64);
+    
+        // combined
+        (calldata_gas + blob_gas) / *GAS_FEE_PRECISION
+    }
 }
 
 fn read_gpo_storage_slots<S>(addr: &SH160, state: &mut S) -> Result<L1GasFee, statedb::Error>
@@ -86,10 +120,18 @@ where
     let l1_base_fee = state.get_state(addr, &SLOT_L1_BASE_FEE)?;
     let overhead = state.get_state(addr, &SLOT_OVERHEAD)?;
     let scalar = state.get_state(addr, &SLOT_SCALAR)?;
+
+    let l1_blob_base_fee = state.get_state(addr, &SLOT_L1_BLOB_BASE_FEE)?;
+    let commit_scalar = state.get_state(addr, &SLOT_COMMIT_SCALAR)?;
+    let blob_scalar = state.get_state(addr, &SLOT_BLOB_SCALAR_SLOT)?;
+
     let fee = L1GasFee {
         l1_base_fee: (&l1_base_fee).into(),
         overhead: (&overhead).into(),
         scalar: (&scalar).into(),
+        l1_blob_base_fee: (&l1_blob_base_fee).into(),
+        commit_scalar: (&commit_scalar).into(),
+        blob_scalar: (&blob_scalar).into(),
     };
     Ok(fee)
 }