refactor(worker): remove alpen storage deps from workspace (#56)

Moves AsmState into strata-asm-worker. Removes BlockSubmitter trait
entirely — the handle's submit_block/submit_block_async methods are
the direct API, no indirection needed.

strata-state, strata-storage, and strata-db-store-sled are now direct
git deps of bin/asm-runner only (binary-level, no cycle). The workspace
root Cargo.toml no longer references any alpen storage crates.

Author: evgenyzdanovich

Cargo.lock

@@ -89,11 +89,8 @@ strata-test-utils-checkpoint = { path = "crates/test-utils/checkpoint" }
 strata-btc-types = { git = "https://github.com/alpenlabs/alpen.git", rev = "02fe60d1b74470da3db67352b2f74625eb2e0ed1" }
 strata-codec-utils = { git = "https://github.com/alpenlabs/alpen.git", rev = "02fe60d1b74470da3db67352b2f74625eb2e0ed1" }
 strata-crypto = { git = "https://github.com/alpenlabs/alpen.git", rev = "02fe60d1b74470da3db67352b2f74625eb2e0ed1" }
-strata-db-store-sled = { git = "https://github.com/alpenlabs/alpen.git", rev = "02fe60d1b74470da3db67352b2f74625eb2e0ed1" }
 strata-identifiers = { git = "https://github.com/alpenlabs/alpen.git", rev = "02fe60d1b74470da3db67352b2f74625eb2e0ed1" }
 strata-primitives = { 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" }
 strata-test-utils-ssz = { git = "https://github.com/alpenlabs/alpen.git", rev = "02fe60d1b74470da3db67352b2f74625eb2e0ed1" }
 
 # Dependencies from alpenlabs/strata-bridge pinned to commit fc966d5 (STR-2598-asm-stf-proof-statements @ 2026-03-17)

Cargo.toml

@@ -24,12 +24,16 @@ strata-asm-proto-bridge-v1.workspace = true
 strata-asm-txs-bridge-v1.workspace = true
 strata-asm-worker.workspace = true
 strata-btc-types.workspace = true
-strata-db-store-sled.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" }
+
 strata-identifiers.workspace = true
 strata-merkle.workspace = true
 strata-predicate.workspace = true
-strata-state.workspace = true
-strata-storage.workspace = true
 strata-tasks.workspace = true
 
 anyhow.workspace = true

bin/asm-runner/Cargo.toml

@@ -14,7 +14,6 @@ use strata_asm_proof_types::{L1Range, ProofId};
 use strata_asm_worker::AsmWorkerHandle;
 use strata_btc_types::BlockHashExt;
 use strata_identifiers::L1BlockCommitment;
-use strata_state::BlockSubmitter;
 use strata_tasks::ShutdownGuard;
 use tokio::sync::mpsc;
 use tracing::{debug, error, info, warn};

bin/asm-runner/src/block_driver.rs

@@ -1,21 +1,35 @@
-//! WorkerContext implementation for ASM worker
+//! WorkerContext implementation for ASM worker.
+//!
+//! This is the glue between the worker (which uses `strata_asm_worker::AsmState`)
+//! and the storage layer (which uses `strata_state::asm_state::AsmState`).
+//! The two types are structurally identical — we convert between them at the
+//! persistence boundary.
 
 use std::sync::Arc;
 
 use bitcoin::{Block, BlockHash, Network};
 use bitcoind_async_client::{Client, traits::Reader};
 use strata_asm_common::{AsmManifest, AuxData};
-use strata_asm_worker::{WorkerContext, WorkerError, WorkerResult};
+use strata_asm_worker::{AsmState, WorkerContext, WorkerError, WorkerResult};
 use strata_btc_types::{BitcoinTxid, L1BlockIdBitcoinExt, RawBitcoinTx};
 use strata_identifiers::{Hash, L1BlockCommitment, L1BlockId};
-use strata_state::asm_state::AsmState;
+use strata_state::asm_state::AsmState as StorageAsmState;
 use strata_storage::{AsmStateManager, MmrIndexHandle};
 use tokio::runtime::Handle;
 
-/// ASM [`WorkerContext`] implementation
+/// Convert storage-layer AsmState to worker AsmState.
+fn from_storage(s: StorageAsmState) -> AsmState {
+    AsmState::new(s.state().clone(), s.logs().clone())
+}
+
+/// Convert worker AsmState to storage-layer AsmState.
+fn to_storage(s: &AsmState) -> StorageAsmState {
+    StorageAsmState::new(s.state().clone(), s.logs().clone())
+}
+
+/// ASM [`WorkerContext`] implementation.
 ///
-/// This implementation fetches L1 blocks directly from a Bitcoin node
-/// and uses SledDB for state storage.
+/// Fetches L1 blocks from a Bitcoin node and persists state via SledDB.
 pub(crate) struct AsmWorkerContext {
     runtime_handle: Handle,
     bitcoin_client: Arc<Client>,
@@ -24,7 +38,6 @@ pub(crate) struct AsmWorkerContext {
 }
 
 impl AsmWorkerContext {
-    /// Create a new BridgeWorkerContext
     pub(crate) const fn new(
         runtime_handle: Handle,
         bitcoin_client: Arc<Client>,
@@ -42,7 +55,6 @@ impl AsmWorkerContext {
 
 impl WorkerContext for AsmWorkerContext {
     fn get_l1_block(&self, blockid: &L1BlockId) -> WorkerResult<Block> {
-        // Fetch block directly from Bitcoin node by hash
         let block_hash: BlockHash = blockid.to_block_hash();
         self.runtime_handle
             .block_on(self.bitcoin_client.get_block(&block_hash))
@@ -52,12 +64,14 @@ impl WorkerContext for AsmWorkerContext {
     fn get_latest_asm_state(&self) -> WorkerResult<Option<(L1BlockCommitment, AsmState)>> {
         self.asm_manager
             .fetch_most_recent_state()
+            .map(|opt| opt.map(|(id, s)| (id, from_storage(s))))
             .map_err(|_| WorkerError::DbError)
     }
 
     fn get_anchor_state(&self, blockid: &L1BlockCommitment) -> WorkerResult<AsmState> {
         self.asm_manager
             .get_state(*blockid)
+            .map(|opt| opt.map(from_storage))
             .map_err(|_| WorkerError::DbError)?
             .ok_or(WorkerError::MissingAsmState(*blockid.blkid()))
     }
@@ -68,13 +82,11 @@ impl WorkerContext for AsmWorkerContext {
         state: &AsmState,
     ) -> WorkerResult<()> {
         self.asm_manager
-            .put_state(*blockid, state.clone())
+            .put_state(*blockid, to_storage(state))
             .map_err(|_| WorkerError::DbError)
     }
 
     fn store_l1_manifest(&self, _manifest: AsmManifest) -> WorkerResult<()> {
-        // Manifests are already stored with AsmState in AsmStateManager
-        // No separate storage needed for now
         Ok(())
     }
 
@@ -130,7 +142,6 @@ impl WorkerContext for AsmWorkerContext {
     }
 
     fn has_l1_manifest(&self, _blockid: &L1BlockId) -> WorkerResult<bool> {
-        // Each block generates a valid manifest
         Ok(true)
     }
 }

bin/asm-runner/src/worker_context.rs

@@ -17,12 +17,11 @@ strata-btc-verification.workspace = true
 strata-identifiers.workspace = true
 strata-merkle = { workspace = true, features = ["ssz"] }
 strata-service.workspace = true
-strata-state.workspace = true
 strata-tasks.workspace = true
 
 anyhow.workspace = true
-async-trait.workspace = true
 bitcoin.workspace = true
+borsh.workspace = true
 serde.workspace = true
 thiserror.workspace = true
 tracing.workspace = true

crates/worker/Cargo.toml

@@ -0,0 +1,40 @@
+//! ASM bookkeeping state.
+//!
+//! Previously lived in `strata-state` (alpen). Moved here to eliminate the
+//! circular dependency between the ASM repo and alpen.
+
+use borsh::{BorshDeserialize, BorshSerialize};
+use serde::{Deserialize, Serialize};
+use strata_asm_common::{AnchorState, AsmLogEntry};
+use strata_asm_stf::AsmStfOutput;
+
+/// ASM bookkeeping "umbrella" state.
+///
+/// Wraps an [`AnchorState`] (the raw STF output) with log entries.
+/// This is the unit stored in the database per L1 block.
+#[derive(Debug, Clone, PartialEq, BorshSerialize, BorshDeserialize, Serialize, Deserialize)]
+pub struct AsmState {
+    state: AnchorState,
+    logs: Vec<AsmLogEntry>,
+}
+
+impl AsmState {
+    pub fn new(state: AnchorState, logs: Vec<AsmLogEntry>) -> Self {
+        Self { state, logs }
+    }
+
+    pub fn from_output(output: AsmStfOutput) -> Self {
+        Self {
+            state: output.state,
+            logs: output.manifest.logs.to_vec(),
+        }
+    }
+
+    pub fn logs(&self) -> &Vec<AsmLogEntry> {
+        &self.logs
+    }
+
+    pub fn state(&self) -> &AnchorState {
+        &self.state
+    }
+}

crates/worker/src/asm_state.rs

@@ -1,7 +1,7 @@
-use async_trait::async_trait;
+//! Handle for interacting with the ASM worker service.
+
 use strata_identifiers::L1BlockCommitment;
 use strata_service::{CommandHandle, ServiceError, ServiceMonitor};
-use strata_state::BlockSubmitter;
 
 use crate::{AsmWorkerStatus, WorkerError, message::AsmWorkerMessage};
 
@@ -24,37 +24,32 @@ impl AsmWorkerHandle {
         }
     }
 
-    /// Allows other services to listen to status updates.
-    ///
-    /// Can be useful for logic that want to listen to logs/updates of ASM state.
-    pub fn monitor(&self) -> &ServiceMonitor<AsmWorkerStatus> {
-        &self.monitor
-    }
-
-    /// Returns the number of pending inputs that have not been processed yet.
-    pub fn pending(&self) -> usize {
-        self.command_handle.pending()
-    }
-}
-
-#[async_trait]
-impl BlockSubmitter for AsmWorkerHandle {
     /// Sends an L1 block to the ASM service and waits for processing to complete.
-    fn submit_block(&self, block: L1BlockCommitment) -> anyhow::Result<()> {
+    pub fn submit_block(&self, block: L1BlockCommitment) -> anyhow::Result<()> {
         self.command_handle
             .send_and_wait_blocking(|completion| AsmWorkerMessage::SubmitBlock(block, completion))
             .map_err(convert_service_error)?
             .map_err(Into::into)
     }
 
-    /// Sends an L1 block to the ASM service and waits for processing to complete.
-    async fn submit_block_async(&self, block: L1BlockCommitment) -> anyhow::Result<()> {
+    /// Sends an L1 block to the ASM service and waits for processing to complete (async).
+    pub async fn submit_block_async(&self, block: L1BlockCommitment) -> anyhow::Result<()> {
         self.command_handle
             .send_and_wait(|completion| AsmWorkerMessage::SubmitBlock(block, completion))
             .await
             .map_err(convert_service_error)?
             .map_err(Into::into)
     }
+
+    /// Allows other services to listen to status updates.
+    pub fn monitor(&self) -> &ServiceMonitor<AsmWorkerStatus> {
+        &self.monitor
+    }
+
+    /// Returns the number of pending inputs that have not been processed yet.
+    pub fn pending(&self) -> usize {
+        self.command_handle.pending()
+    }
 }
 
 /// Convert service framework errors to worker errors.

crates/worker/src/handle.rs

@@ -3,6 +3,7 @@
 //! The `strata-asm-worker` crate provides a dedicated asynchronous worker
 //! for managing Strata's Anchor state (ASM).
 
+mod asm_state;
 mod aux_resolver;
 mod builder;
 mod constants;
@@ -13,6 +14,7 @@ mod service;
 mod state;
 mod traits;
 
+pub use asm_state::AsmState;
 pub use aux_resolver::AuxDataResolver;
 pub use builder::AsmWorkerBuilder;
 pub use errors::{WorkerError, WorkerResult};

crates/worker/src/lib.rs

@@ -2,9 +2,8 @@
 
 use strata_identifiers::L1BlockCommitment;
 use strata_service::CommandCompletionSender;
-use strata_state::asm_state::AsmState;
 
-use crate::WorkerResult;
+use crate::{AsmState, WorkerResult};
 
 /// Messages from the ASM Handle to the subprotocol to give it work to do.
 #[derive(Debug)]