Str 304 migrate prover guest code

Cargo.toml

@@ -197,6 +197,8 @@ toml = "0.5"
 tower = "0.4"
 tracing = "0.1.40"
 tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }
+uuid = { version = "1.0", features = ["v4", "serde"] }
+
 
 # This is needed for custom build of SP1
 [profile.release.build-override]

bin/prover-client/Cargo.toml

@@ -9,31 +9,38 @@ path = "src/main.rs"
 required-features = ["prover"]
 
 [dependencies]
+alpen-express-btcio = { workspace = true }
 alpen-express-common = { workspace = true }
 alpen-express-db = { workspace = true }
+alpen-express-primitives = { workspace = true }
 alpen-express-rocksdb = { workspace = true }
+alpen-express-rpc-types = { workspace = true }
+alpen-express-state = { workspace = true }
+express-proofimpl-btc-blockspace = { workspace = true }
 express-proofimpl-evm-ee-stf = { workspace = true }
+express-proofimpl-l1-batch = { workspace = true }
 express-prover-client-rpc-api = { workspace = true }
 express-sp1-adapter = { workspace = true, features = ["prover"] }
 express-sp1-guest-builder = { path = "../../provers/sp1" }
 express-zkvm = { workspace = true }
 
-
 anyhow = { workspace = true }
 argh = { workspace = true }
 async-trait = { workspace = true }
 bincode = { workspace = true }
+bitcoin = { workspace = true }
+borsh = { workspace = true }
 jsonrpsee = { workspace = true, features = ["http-client"] }
 rayon = "1.8.0"
 reth-rpc-types = { workspace = true }
 rockbound = { workspace = true }
 serde = { workspace = true }
+strata-tx-parser = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true }
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true, features = ["env-filter"] }
-uuid = { version = "1.0", features = ["v4", "serde"] }
-
+uuid = { workspace = true }
 
 [features]
 prover = []

bin/prover-client/src/args.rs

@@ -32,6 +32,15 @@ pub struct Args {
  #[argh(option, description = "reth rpc host:port")]
  pub reth_rpc: String,
 
+ #[argh(option, description = "bitcoind RPC host")]
+ pub bitcoind_url: String,
+
+ #[argh(option, description = "bitcoind RPC user")]
+ pub bitcoind_user: String,
+
+ #[argh(option, description = "bitcoind RPC password")]
+ pub bitcoind_password: String,
+
  #[argh(option, description = "enable prover client dev rpc", default = "true")]
  pub enable_dev_rpcs: bool,
 }
@@ -53,4 +62,8 @@ impl Args {
  pub fn get_reth_rpc_url(&self) -> String {
  self.reth_rpc.to_string()
  }
+
+ pub fn get_btc_rpc_url(&self) -> String {
+ format!("http://{}", self.bitcoind_url)
+ }
 }

bin/prover-client/src/config.rs

@@ -1,11 +1,5 @@
 // Number of prover workers to spawn
-pub const NUM_PROVER_WORKER: usize = 10;
+pub const NUM_PROVER_WORKERS: usize = 5;
 
-// Wait time in seconds for the prover manager loop, in seconds
-pub const PROVER_MANAGER_WAIT_TIME: u64 = 5;
-
-// Interval between dispatching block proving tasks, in seconds
-pub const BLOCK_PROVING_TASK_DISPATCH_INTERVAL: u64 = 1;
-
-// Starting block height for EL block proving tasks
-pub const EL_START_BLOCK_HEIGHT: u64 = 1;
+// Wait time in seconds for the prover manager loop
+pub const PROVER_MANAGER_INTERVAL: u64 = 2;

bin/prover-client/src/dispatcher.rs

@@ -0,0 +1,55 @@
+use std::{fmt::Debug, sync::Arc};
+
+use tracing::info;
+use uuid::Uuid;
+
+use crate::{errors::ProvingTaskError, proving_ops::ops::ProvingOperations, task::TaskTracker};
+
+/// Generic dispatcher for block proving tasks.
+#[derive(Debug, Clone)]
+pub struct TaskDispatcher<O>
+where
+ O: ProvingOperations,
+{
+ operations: O,
+ task_tracker: Arc<TaskTracker>,
+}
+
+impl<O> TaskDispatcher<O>
+where
+ O: ProvingOperations + Clone + Send + Sync + 'static,
+ O::Params: Debug + Clone,
+{
+ /// Creates a new task dispatcher.
+ pub fn new(operations: O, task_tracker: Arc<TaskTracker>) -> Self {
+ Self {
+ operations,
+ task_tracker,
+ }
+ }
+
+ /// Creates a proving task for the given params.
+ pub async fn create_task(&self, param: O::Params) -> Result<Uuid, ProvingTaskError> {
+ info!(
+ "Creating proving task for block {:?} {:?}",
+ param,
+ self.operations.block_type()
+ );
+ let input = self
+ .operations
+ .fetch_input(param.clone())
+ .await
+ .map_err(|e| ProvingTaskError::FetchInput {
+ param: format!("{:?}", param),
+ task_type: self.operations.block_type(),
+ source: e,
+ })?;
+ self.operations
+ .append_task(self.task_tracker.clone(), input)
+ .await
+ }
+
+ pub fn task_tracker(&self) -> Arc<TaskTracker> {
+ self.task_tracker.clone()
+ }
+}

bin/prover-client/src/errors.rs

@@ -2,13 +2,43 @@ use thiserror::Error;
 
 // Define custom error type
 #[derive(Error, Debug)]
-pub enum ELProvingTaskError {
- #[error("Failed to fetch EL block prover input for block number {block_num}: {source}")]
- FetchElBlockProverInputError {
- block_num: u64,
+pub enum ProvingTaskError {
+ #[error("Failed to fetch {task_type} input for {param}: {source}")]
+ FetchInput {
+ param: String,
+ task_type: ProvingTaskType,
  source: anyhow::Error,
  },
 
  #[error("Failed to serialize the EL block prover input")]
- SerializationError(#[from] bincode::Error),
+ Serialization(#[from] bincode::Error),
+
+ #[error("Failed to borsh deserialize the input")]
+ BorshSerialization(#[from] borsh::io::Error),
+
+ #[error("Failed to create dependency task: {0}")]
+ DependencyTaskCreation(String),
+}
+
+// Define ProvingTaskType enum to represent EL and CL
+#[derive(Debug, Clone, Copy)]
+pub enum ProvingTaskType {
+ Btc,
+ EL,
+ CL,
+ ClBatch,
+ BtcBatch,
+}
+
+impl std::fmt::Display for ProvingTaskType {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ let block_type_str = match self {
+ ProvingTaskType::Btc => "BTC",
+ ProvingTaskType::EL => "EL",
+ ProvingTaskType::CL => "CL",
+ ProvingTaskType::ClBatch => "CL Batch",
+ ProvingTaskType::BtcBatch => "BTC Batch",
+ };
+ write!(f, "{}", block_type_str)
+ }
 }

bin/prover-client/src/main.rs

@@ -2,59 +2,103 @@
 
 use std::sync::Arc;
 
+use alpen_express_btcio::rpc::BitcoinClient;
 use alpen_express_common::logging;
 use args::Args;
-use config::EL_START_BLOCK_HEIGHT;
+use dispatcher::TaskDispatcher;
 use express_sp1_adapter::SP1Host;
+use express_zkvm::ProverOptions;
 use jsonrpsee::http_client::HttpClientBuilder;
 use manager::ProverManager;
+use proving_ops::{
+ btc_ops::BtcOperations, checkpoint_ops::CheckpointOperations, cl_ops::ClOperations,
+ el_ops::ElOperations, l1_batch_ops::L1BatchOperations, l2_batch_ops::L2BatchOperations,
+};
 use rpc_server::{ProverClientRpc, RpcContext};
 use task::TaskTracker;
-use task_dispatcher::ELBlockProvingTaskScheduler;
 use tracing::info;
 
 mod args;
 mod config;
 mod db;
+mod dispatcher;
 mod errors;
 mod manager;
 mod primitives;
 mod prover;
+mod proving_ops;
 mod rpc_server;
 mod task;
-mod task_dispatcher;
 
 #[tokio::main]
 async fn main() {
  logging::init();
  info!("running alpen express prover client in dev mode");
 
  let args: Args = argh::from_env();
- let task_tracker = Arc::new(TaskTracker::new());
 
- let el_rpc_client = HttpClientBuilder::default()
+ let el_client = HttpClientBuilder::default()
  .build(args.get_reth_rpc_url())
  .expect("failed to connect to the el client");
 
- let el_proving_task_scheduler = ELBlockProvingTaskScheduler::new(
- el_rpc_client,
- task_tracker.clone(),
- EL_START_BLOCK_HEIGHT,
+ let cl_client = HttpClientBuilder::default()
+ .build(args.get_sequencer_rpc_url())
+ .expect("failed to connect to the el client");
+
+ let btc_client = Arc::new(
+ BitcoinClient::new(
+ args.get_btc_rpc_url(),
+ args.bitcoind_user.clone(),
+ args.bitcoind_password.clone(),
+ )
+ .unwrap(),
  );
- let rpc_context = RpcContext::new(el_proving_task_scheduler.clone());
- let prover_manager: ProverManager<SP1Host> = ProverManager::new(task_tracker);
+
+ let task_tracker = Arc::new(TaskTracker::new());
+
+ // Create L1 operations
+ let btc_ops = BtcOperations::new(btc_client.clone());
+ let btc_dispatcher = TaskDispatcher::new(btc_ops, task_tracker.clone());
+
+ // Create EL operations
+ let el_ops = ElOperations::new(el_client.clone());
+ let el_dispatcher = TaskDispatcher::new(el_ops, task_tracker.clone());
+
+ let cl_ops = ClOperations::new(cl_client.clone(), Arc::new(el_dispatcher.clone()));
+ let cl_dispatcher = TaskDispatcher::new(cl_ops, task_tracker.clone());
+
+ let l1_batch_ops = L1BatchOperations::new(Arc::new(btc_dispatcher.clone()), btc_client.clone());
+ let l1_batch_dispatcher = TaskDispatcher::new(l1_batch_ops, task_tracker.clone());
+
+ let l2_batch_ops = L2BatchOperations::new(Arc::new(cl_dispatcher.clone()).clone());
+ let l2_batch_dispatcher = TaskDispatcher::new(l2_batch_ops, task_tracker.clone());
+
+ let checkpoint_ops = CheckpointOperations::new(
+ Arc::new(l1_batch_dispatcher.clone()),
+ Arc::new(l2_batch_dispatcher.clone()),
+ );
+
+ let checkpoint_dispatcher = TaskDispatcher::new(checkpoint_ops, task_tracker.clone());
+
+ let rpc_context = RpcContext::new(
+ btc_dispatcher.clone(),
+ el_dispatcher.clone(),
+ cl_dispatcher.clone(),
+ l1_batch_dispatcher.clone(),
+ l2_batch_dispatcher.clone(),
+ checkpoint_dispatcher.clone(),
+ );
+
+ let prover_options = ProverOptions {
+ use_mock_prover: false,
+ enable_compression: true,
+ ..Default::default()
+ };
+ let prover_manager: ProverManager<SP1Host> = ProverManager::new(task_tracker, prover_options);
 
  // run prover manager in background
  tokio::spawn(async move { prover_manager.run().await });
 
- // run el proving task dispatcher
- tokio::spawn(async move {
- el_proving_task_scheduler
- .clone()
- .listen_for_new_blocks()
- .await
- });
-
  // run rpc server
  let rpc_url = args.get_dev_rpc_url();
  run_rpc_server(rpc_context, rpc_url, args.enable_dev_rpcs)