Prover Client Functional Tests (#441)

* feat: prover client functional test

* tests: deposit & withdrwal functional test

* credential check off on the cl guest code

* functional tests refactor

Author: MdTeach

bin/prover-client/src/args.rs

@@ -53,7 +53,7 @@ pub struct Args {
     #[argh(
         option,
         description = "enable prover client checkpoint runner",
-        default = "true"
+        default = "false"
     )]
     pub enable_checkpoint_runner: bool,
 }

bin/prover-client/src/config.rs

@@ -1,5 +1,6 @@
 // Number of prover workers to spawn
 pub const NUM_PROVER_WORKERS: usize = 64;
+pub const MAX_PARALLEL_PROVING_INSTANCES: usize = 25;
 
 // Wait time in seconds for the prover manager loop
 pub const PROVER_MANAGER_INTERVAL: u64 = 2;

bin/prover-client/src/manager.rs

@@ -51,6 +51,10 @@ where
             .await;
 
         for task in pending_tasks {
+            if !self.prover.is_available() {
+                info!("Prover manager occupied skipping this turn..");
+                break;
+            }
             self.prover.submit_witness(task.id, task.prover_input);
             if self.prover.start_proving(task.id).is_err() {
                 self.task_tracker

bin/prover-client/src/prover.rs

@@ -26,7 +26,7 @@ use crate::elf::{
     GUEST_EVM_EE_STF_ELF, GUEST_L1_BATCH_ELF,
 };
 use crate::{
-    config::NUM_PROVER_WORKERS,
+    config::{MAX_PARALLEL_PROVING_INSTANCES, NUM_PROVER_WORKERS},
     db::open_rocksdb_database,
     primitives::{
         prover_input::{ProofWithVkey, ZKVMInput},
@@ -309,6 +309,16 @@ where
         }
     }
 
+    pub(crate) fn is_available(&self) -> bool {
+        let prover_state = self
+            .prover_state
+            .read()
+            .expect("Failed to acquire write lock");
+        let num_jobs = prover_state.pending_tasks_count;
+
+        num_jobs < MAX_PARALLEL_PROVING_INSTANCES
+    }
+
     fn save_proof_to_db(&self, task_id: Uuid, proof: &Proof) -> Result<(), anyhow::Error> {
         self.db
             .prover_store()

bin/strata-reth/res/alpen-dev-chain.json

@@ -16,7 +16,7 @@
     "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
     "config": {
         "ethash": {},
-        "chainId": 12345,
+        "chainId": 8091,
         "homesteadBlock": 0,
         "eip150Block": 0,
         "eip155Block": 0,

crates/proof-impl/cl-stf/src/lib.rs

@@ -10,7 +10,7 @@ use strata_primitives::{
 use strata_proofimpl_evm_ee_stf::ELProofPublicParams;
 use strata_state::{
     block::ExecSegment,
-    block_validation::{check_block_credential, validate_block_segments},
+    block_validation::validate_block_segments,
     bridge_ops,
     exec_update::{ELDepositData, ExecUpdate, Op, UpdateInput, UpdateOutput},
 };
@@ -23,24 +23,14 @@ pub fn verify_and_transition(
     el_proof_pp: ELProofPublicParams,
     rollup_params: &RollupParams,
 ) -> (ChainState, Vec<ELDepositData>) {
-    let deposit_datas = verify_l2_block(&new_l2_block, &el_proof_pp, rollup_params);
+    let deposit_datas = verify_l2_block(&new_l2_block, &el_proof_pp);
     let new_state = apply_state_transition(prev_chstate, &new_l2_block, rollup_params);
 
     (new_state, deposit_datas)
 }
 
 /// Verifies the L2 block.
-fn verify_l2_block(
-    block: &L2Block,
-    el_proof_pp: &ELProofPublicParams,
-    chain_params: &RollupParams,
-) -> Vec<ELDepositData> {
-    // Assert that the block has been signed by the designated signer
-    assert!(
-        check_block_credential(block.header(), &chain_params.cred_rule),
-        "Block credential verification failed"
-    );
-
+fn verify_l2_block(block: &L2Block, el_proof_pp: &ELProofPublicParams) -> Vec<ELDepositData> {
     // Assert that the block body and header are consistent
     assert!(
         validate_block_segments(block),

functional-tests/constants.py

@@ -74,17 +74,5 @@
     },
 }
 
-PROVER_ROLLUP_PARAMS = {
-    **DEFAULT_ROLLUP_PARAMS,
-    "proof_publish_mode": "strict",
-    "genesis_l1_height": 500,
-    "cred_rule": "unchecked",
-    "operator_config": {
-        "static": [
-            {
-                "signing_pk": "1ea7f6c7a924a1e722c09301a826cfd95b21b23a294cec5da3c0b5908e62e0c7",
-                "wallet_pk": "1ea7f6c7a924a1e722c09301a826cfd95b21b23a294cec5da3c0b5908e62e0c7",
-            }
-        ]
-    },
-}
+
+PROVER_ROLLUP_PARAMS = {**ROLLUP_PARAMS_FOR_DEPOSIT_TX}

functional-tests/fn_prover_checkpoint_with_deposit.py

@@ -0,0 +1,138 @@
+import time
+
+import flexitest
+from bitcoinlib.services.bitcoind import BitcoindClient
+
+from constants import (
+    ROLLUP_PARAMS_FOR_DEPOSIT_TX,
+    SEQ_PUBLISH_BATCH_INTERVAL_SECS,
+)
+from utils import wait_for_proof_with_time_out, wait_until
+
+EVM_WAIT_TIME = 2
+SATS_TO_WEI = 10**10
+
+withdrawal_intent_event_abi = {
+    "anonymous": False,
+    "inputs": [
+        {"indexed": False, "internalType": "uint64", "name": "amount", "type": "uint64"},
+        {"indexed": False, "internalType": "bytes", "name": "dest_pk", "type": "bytes32"},
+    ],
+    "name": "WithdrawalIntentEvent",
+    "type": "event",
+}
+event_signature_text = "WithdrawalIntentEvent(uint64,bytes32)"
+
+
+@flexitest.register
+class BridgeDepositTest(flexitest.Test):
+    def __init__(self, ctx: flexitest.InitContext):
+        ctx.set_env("prover")
+
+    def main(self, ctx: flexitest.RunContext):
+        evm_addr = "deedf001900dca3ebeefdeadf001900dca3ebeef"
+
+        btc = ctx.get_service("bitcoin")
+        btcrpc: BitcoindClient = btc.create_rpc()
+
+        # Do deposit and collect the L1 and L2 where the deposit transaction was included
+        l2_block_num, l1_deposit_txn_id = self.do_deposit(ctx, evm_addr)
+        l1_deposit_txn_block_info = btcrpc.proxy.gettransaction(l1_deposit_txn_id)
+        deposit_txn_block_num = l1_deposit_txn_block_info["blockheight"]
+
+        # Init the prover client
+        prover_client = ctx.get_service("prover_client")
+        prover_client_rpc = prover_client.create_rpc()
+        time.sleep(60)
+
+        # Dispatch the prover task
+        # Proving task with with few L1 and L2 blocks including the deposit transaction
+        l1_range = (deposit_txn_block_num - 1, deposit_txn_block_num + 1)
+        l2_range = (l2_block_num - 1, l2_block_num + 1)
+        task_id = prover_client_rpc.dev_strata_proveCheckpointRaw(0, l1_range, l2_range)
+        print("got proving task_id ", task_id)
+        assert task_id is not None
+
+        time_out = 30 * 60
+        wait_for_proof_with_time_out(prover_client_rpc, task_id, time_out=time_out)
+
+    def do_deposit(self, ctx: flexitest.RunContext, evm_addr: str):
+        btc = ctx.get_service("bitcoin")
+        seq = ctx.get_service("sequencer")
+
+        seqrpc = seq.create_rpc()
+        btcrpc: BitcoindClient = btc.create_rpc()
+
+        amount_to_send = ROLLUP_PARAMS_FOR_DEPOSIT_TX["deposit_amount"] / 10**8
+        name = ROLLUP_PARAMS_FOR_DEPOSIT_TX["rollup_name"].encode("utf-8").hex()
+
+        addr = "bcrt1pzupt5e8eqvt995r57jmmylxlswqfddsscrrq7njygrkhej3e7q2qur0c76"
+        outputs = [{addr: amount_to_send}, {"data": f"{name}{evm_addr}"}]
+
+        options = {"changePosition": 2}
+
+        psbt_result = btcrpc.proxy.walletcreatefundedpsbt([], outputs, 0, options)
+        psbt = psbt_result["psbt"]
+
+        signed_psbt = btcrpc.proxy.walletprocesspsbt(psbt)
+
+        finalized_psbt = btcrpc.proxy.finalizepsbt(signed_psbt["psbt"])
+        deposit_tx = finalized_psbt["hex"]
+
+        original_num_deposits = len(seqrpc.strata_getCurrentDeposits())
+        print(f"Original deposit count: {original_num_deposits}")
+
+        reth = ctx.get_service("reth")
+        rethrpc = reth.create_rpc()
+
+        original_balance = int(rethrpc.eth_getBalance(f"0x{evm_addr}"), 16)
+        print(f"Balance before deposit: {original_balance}")
+
+        btc_txn_id = btcrpc.sendrawtransaction(deposit_tx)["txid"]
+
+        # check if we are getting deposits
+        wait_until(
+            lambda: len(seqrpc.strata_getCurrentDeposits()) > original_num_deposits,
+            error_with="seem not be getting deposits",
+            timeout=SEQ_PUBLISH_BATCH_INTERVAL_SECS,
+        )
+
+        current_block_num = int(rethrpc.eth_blockNumber(), base=16)
+        print(f"Current reth block num: {current_block_num}")
+
+        wait_until(
+            lambda: int(rethrpc.eth_getBalance(f"0x{evm_addr}"), 16) > original_balance,
+            error_with="eth balance did not update",
+            timeout=EVM_WAIT_TIME,
+        )
+
+        deposit_amount = ROLLUP_PARAMS_FOR_DEPOSIT_TX["deposit_amount"] * SATS_TO_WEI
+
+        balance = int(rethrpc.eth_getBalance(f"0x{evm_addr}"), 16)
+        print(f"Balance after deposit: {balance}")
+
+        net_balance = balance - original_balance
+        assert net_balance == deposit_amount, f"invalid deposit amount: {net_balance}"
+
+        wait_until(
+            lambda: int(rethrpc.eth_blockNumber(), base=16) > current_block_num,
+            error_with="not building blocks",
+            timeout=EVM_WAIT_TIME * 2,
+        )
+
+        balance = int(rethrpc.eth_getBalance(f"0x{evm_addr}"), 16)
+        net_balance = balance - original_balance
+        assert (
+            net_balance == deposit_amount
+        ), f"deposit processed multiple times, extra: {balance - original_balance - deposit_amount}"
+
+        # Scan the L2 blocks where the deposits were included
+        start_block = 1
+        end_block = int(rethrpc.eth_blockNumber(), base=16) + 1
+        for block_num in range(start_block, end_block):
+            block = rethrpc.eth_getBlockByNumber(hex(block_num), False)
+            withdrawals = block.get("withdrawals", None)
+            if withdrawals is not None and len(withdrawals) != 0:
+                return block_num, btc_txn_id
+
+        return None, btc_txn_id