feat(storage): replace alpen storage with local sled implementation (#59)

* feat(storage): replace alpen storage with local sled implementation

Introduces crates/storage (strata-asm-storage) with two sled-backed
backends that replace three alpen crates:

- AsmStateDb: anchor state + aux data persistence (replaces
  strata-state + strata-storage's AsmStateManager)
- MmrDb: manifest hash MMR with proof generation (replaces
  strata-db-store-sled's MmrIndexDb + strata-storage's MmrIndexManager)

The asm-runner binary now has zero alpen dependencies. All storage
is self-contained within the ASM repo.

Removed from bin/asm-runner:
- strata-state (alpen git dep)
- strata-storage (alpen git dep)
- strata-db-store-sled (alpen git dep)
- threadpool (no longer needed without AsmStateManager's pool)

* test(storage): add unit tests for AsmStateDb and MmrDb

Author: evgenyzdanovich

Cargo.lock

@@ -31,6 +31,7 @@ members = [
   "crates/test-utils/btcio",
   "crates/test-utils/checkpoint",
   "crates/worker",
+  "crates/storage",
 
   # tests
   "tests",
@@ -77,6 +78,7 @@ strata-asm-txs-bridge-v1 = { path = "crates/txs/bridge-v1" }
 strata-asm-txs-checkpoint = { path = "crates/txs/checkpoint" }
 strata-asm-txs-test-utils = { path = "crates/txs/test-utils" }
 strata-asm-worker = { path = "crates/worker" }
+asm-storage = { path = "crates/storage" }
 strata-bridge-types = { path = "crates/bridge-types" }
 strata-btc-verification = { path = "crates/btc-verification" }
 strata-checkpoint-types-ssz = { path = "crates/checkpoint-types" }
@@ -191,5 +193,6 @@ strata-asm-txs-bridge-v1 = { path = "crates/txs/bridge-v1" }
 strata-asm-txs-checkpoint = { path = "crates/txs/checkpoint" }
 strata-asm-txs-test-utils = { path = "crates/txs/test-utils" }
 strata-asm-worker = { path = "crates/worker" }
+asm-storage = { path = "crates/storage" }
 strata-btc-verification = { path = "crates/btc-verification" }
 strata-checkpoint-types-ssz = { path = "crates/checkpoint-types" }

Cargo.toml

@@ -25,11 +25,7 @@ strata-asm-txs-bridge-v1.workspace = true
 strata-asm-worker.workspace = true
 strata-btc-types.workspace = true
 
-# Storage deps — now only needed by the runner binary, not ASM library crates
-# TODO(STR-2544): eliminate it completely
-strata-db-store-sled = { git = "https://github.com/alpenlabs/alpen.git", rev = "02fe60d1b74470da3db67352b2f74625eb2e0ed1" }
-strata-state = { git = "https://github.com/alpenlabs/alpen.git", rev = "02fe60d1b74470da3db67352b2f74625eb2e0ed1" }
-strata-storage = { git = "https://github.com/alpenlabs/alpen.git", rev = "02fe60d1b74470da3db67352b2f74625eb2e0ed1" }
+asm-storage.workspace = true
 
 strata-identifiers.workspace = true
 strata-merkle.workspace = true
@@ -45,9 +41,9 @@ futures.workspace = true
 jsonrpsee = { workspace = true, features = ["server", "macros"] }
 serde.workspace = true
 serde_json.workspace = true
+sled.workspace = true
 ssz.workspace = true
 strata-asm-sp1-guest-builder = { path = "../../guest-builder/sp1", optional = true }
-threadpool = "1.8"
 tokio.workspace = true
 toml.workspace = true
 tracing.workspace = true

bin/asm-runner/Cargo.toml

@@ -17,16 +17,16 @@ use crate::{
     config::{AsmRpcConfig, BitcoinConfig},
     prover::{InputBuilder, ProofOrchestrator},
     rpc_server::run_rpc_server,
-    storage::create_storage_managers,
+    storage::create_storage,
     worker_context::AsmWorkerContext,
 };
 pub(crate) async fn bootstrap(
     config: AsmRpcConfig,
     params: AsmParams,
     executor: TaskExecutor,
 ) -> Result<()> {
-    // 1. Create storage managers (AsmStateManager + MmrHandle)
-    let (asm_manager, mmr_handle) = create_storage_managers(&config.database)?;
+    // 1. Create storage
+    let (state_db, mmr_db) = create_storage(&config.database)?;
 
     // 2. Connect to Bitcoin node
     let bitcoin_client = Arc::new(connect_bitcoin(&config.bitcoin).await?);
@@ -36,8 +36,8 @@ pub(crate) async fn bootstrap(
     let worker_context = AsmWorkerContext::new(
         runtime_handle.clone(),
         bitcoin_client.clone(),
-        asm_manager.clone(),
-        mmr_handle,
+        state_db.clone(),
+        mmr_db.clone(),
     );
 
     // 4. Launch ASM worker
@@ -80,7 +80,7 @@ pub(crate) async fn bootstrap(
             AsmStfProofProgram::native_host()
         };
 
-        let input_builder = InputBuilder::new(asm_manager.clone(), bitcoin_client.clone());
+        let input_builder = InputBuilder::new(state_db.clone(), bitcoin_client.clone());
         let mut orchestrator =
             ProofOrchestrator::new(proof_db, host, orch_config, input_builder, rx);
 
@@ -121,7 +121,7 @@ pub(crate) async fn bootstrap(
     let rpc_port = config.rpc.port;
     executor.spawn_critical_async_with_shutdown("rpc_server", move |shutdown| {
         run_rpc_server(
-            asm_manager,
+            state_db,
             asm_worker,
             bitcoin_client,
             proof_db_for_rpc,

bin/asm-runner/src/bootstrap.rs

@@ -5,6 +5,7 @@
 use std::sync::Arc;
 
 use anyhow::{Context, Result};
+use asm_storage::AsmStateDb;
 use bitcoind_async_client::{Client, traits::Reader};
 use moho_runtime_impl::RuntimeInput;
 use moho_runtime_interface::MohoProgram;
@@ -14,18 +15,17 @@ use strata_asm_proof_types::L1Range;
 use strata_btc_types::{BlockHashExt, L1BlockIdBitcoinExt};
 use strata_btc_verification::{self, TxidInclusionProof};
 use strata_identifiers::L1BlockCommitment;
-use strata_storage::AsmStateManager;
 
 /// Builds [`RuntimeInput`] for proof generation, dispatching by proof type.
 pub(crate) struct InputBuilder {
-    asm_manager: Arc<AsmStateManager>,
+    state_db: Arc<AsmStateDb>,
     bitcoin_client: Arc<Client>,
 }
 
 impl InputBuilder {
-    pub(crate) fn new(asm_manager: Arc<AsmStateManager>, bitcoin_client: Arc<Client>) -> Self {
+    pub(crate) fn new(state_db: Arc<AsmStateDb>, bitcoin_client: Arc<Client>) -> Self {
         Self {
-            asm_manager,
+            state_db,
             bitcoin_client,
         }
     }
@@ -47,8 +47,8 @@ impl InputBuilder {
 
         // 2. Fetch the auxiliary data stored during STF execution.
         let aux_data = self
-            .asm_manager
-            .get_aux_data(commitment)
+            .state_db
+            .get_aux_data(&commitment)
             .context("failed to fetch aux data")?
             .context("aux data not found for block")?;
 
@@ -69,8 +69,8 @@ impl InputBuilder {
         let parent_commitment = L1BlockCommitment::new(parent_height, parent_hash.to_l1_block_id());
 
         let asm_state = self
-            .asm_manager
-            .get_state(parent_commitment)
+            .state_db
+            .get(&parent_commitment)
             .context("failed to fetch parent anchor state")?
             .context("parent anchor state not found")?;
         let anchor_state = asm_state.state();

bin/asm-runner/src/prover/input.rs

@@ -3,6 +3,7 @@
 use std::{fmt::Display, sync::Arc};
 
 use anyhow::Result;
+use asm_storage::AsmStateDb;
 use async_trait::async_trait;
 use bitcoin::BlockHash;
 use bitcoind_async_client::{Client, traits::Reader};
@@ -20,7 +21,6 @@ use strata_asm_txs_bridge_v1::BRIDGE_V1_SUBPROTOCOL_ID;
 use strata_asm_worker::{AsmWorkerHandle, AsmWorkerStatus};
 use strata_btc_types::BlockHashExt;
 use strata_identifiers::L1BlockCommitment;
-use strata_storage::AsmStateManager;
 use strata_tasks::ShutdownGuard;
 use tracing::info;
 
@@ -31,7 +31,7 @@ fn to_rpc_error(e: impl Display) -> ErrorObjectOwned {
 
 /// ASM RPC server implementation
 pub(crate) struct AsmRpcServer {
-    asm_manager: Arc<AsmStateManager>,
+    state_db: Arc<AsmStateDb>,
     asm_worker: Arc<AsmWorkerHandle>,
     bitcoin_client: Arc<Client>,
     proof_db: Option<SledProofDb>,
@@ -40,13 +40,13 @@ pub(crate) struct AsmRpcServer {
 impl AsmRpcServer {
     /// Create a new ASM RPC server
     pub(crate) fn new(
-        asm_manager: Arc<AsmStateManager>,
+        state_db: Arc<AsmStateDb>,
         asm_worker: Arc<AsmWorkerHandle>,
         bitcoin_client: Arc<Client>,
         proof_db: Option<SledProofDb>,
     ) -> Self {
         Self {
-            asm_manager,
+            state_db,
             asm_worker,
             bitcoin_client,
             proof_db,
@@ -69,10 +69,7 @@ impl AsmRpcServer {
             .to_block_commitment(block_hash)
             .await
             .map_err(to_rpc_error)?;
-        let state = self
-            .asm_manager
-            .get_state(commitment)
-            .map_err(to_rpc_error)?;
+        let state = self.state_db.get(&commitment).map_err(to_rpc_error)?;
         match state {
             Some(state) => {
                 let bridge_state = state
@@ -140,15 +137,15 @@ impl AssignmentsApiServer for AsmRpcServer {
 
 /// Run the RPC server
 pub(crate) async fn run_rpc_server(
-    asm_manager: Arc<AsmStateManager>,
+    state_db: Arc<AsmStateDb>,
     asm_worker: Arc<AsmWorkerHandle>,
     bitcoin_client: Arc<Client>,
     proof_db: Option<SledProofDb>,
     rpc_host: String,
     rpc_port: u16,
     shutdown: ShutdownGuard,
 ) -> Result<()> {
-    let rpc_server = AsmRpcServer::new(asm_manager, asm_worker, bitcoin_client, proof_db);
+    let rpc_server = AsmRpcServer::new(state_db, asm_worker, bitcoin_client, proof_db);
 
     let server = ServerBuilder::default()
         .build(format!("{}:{}", rpc_host, rpc_port))

bin/asm-runner/src/rpc_server.rs

@@ -1,57 +1,16 @@
-//! Storage manager setup using SledDB from [Alpen](https://github.com/alpenlabs/alpen)
+//! Storage setup for the ASM runner.
 
-use std::{sync::Arc, time::Duration};
+use std::sync::Arc;
 
 use anyhow::Result;
-use strata_db_store_sled::{AsmDBSled, MmrIndexDb, SledDbConfig, open_sled_database};
-use strata_storage::{AsmStateManager, MmrId, MmrIndexHandle, MmrIndexManager};
-use threadpool::ThreadPool;
+use asm_storage::{AsmStateDb, MmrDb};
 
 use crate::config::DatabaseConfig;
 
-/// Default number of threads for database operations.
-const DEFAULT_NUM_THREADS: usize = 4;
-
-/// Default number of retries for failed database operations.
-const DEFAULT_RETRY_COUNT: u16 = 4;
-
-/// Default delay between retries for failed database operations.
-const DEFAULT_DELAY: Duration = Duration::from_millis(150);
-
-/// Sled database name for MMR data.
-const MMR_DB_NAME: &str = "mmr";
-
-/// Sled database name for ASM state data.
-const ASM_DB_NAME: &str = "asm";
-
-/// Create storage managers for ASM state and MMR
-///
-/// Returns a tuple of (AsmStateManager, MmrHandle) that can be used by the
-/// WorkerContext and RPC server.
-pub(crate) fn create_storage_managers(
-    config: &DatabaseConfig,
-) -> Result<(Arc<AsmStateManager>, MmrIndexHandle)> {
-    // Create thread pools for database operations
-    let pool = ThreadPool::new(config.num_threads.unwrap_or(DEFAULT_NUM_THREADS));
-
-    // Open sled databases
-    let asm_sled_db = open_sled_database(&config.path, ASM_DB_NAME)?;
-    let mmr_sled_db = open_sled_database(&config.path, MMR_DB_NAME)?;
-
-    // Create database instances with default config
-    let config = SledDbConfig::new_with_constant_backoff(
-        config.retry_count.unwrap_or(DEFAULT_RETRY_COUNT),
-        config.delay.unwrap_or(DEFAULT_DELAY).as_millis() as u64,
-    );
-    let asm_db = Arc::new(AsmDBSled::new(asm_sled_db, config.clone())?);
-    let mmr_db = Arc::new(MmrIndexDb::new(mmr_sled_db, config)?);
-
-    // Create managers
-    let asm_manager = Arc::new(AsmStateManager::new(pool.clone(), asm_db));
-    let mmr_manager = MmrIndexManager::new(pool, mmr_db);
-
-    // Get a handle for the ASM manifest MMR
-    let mmr_handle = mmr_manager.get_handle(MmrId::Asm);
-
-    Ok((asm_manager, mmr_handle))
+/// Create storage backends for the ASM runner.
+pub(crate) fn create_storage(config: &DatabaseConfig) -> Result<(Arc<AsmStateDb>, Arc<MmrDb>)> {
+    let db = sled::open(&config.path)?;
+    let state_db = Arc::new(AsmStateDb::open(&db)?);
+    let mmr_db = Arc::new(MmrDb::open(&db)?);
+    Ok((state_db, mmr_db))
 }