Move ScheduledBundle into the scheduler crate alongside batch and tx

Relocate ScheduledBundle and BundleBlocks from the aggregate-prover crate
to the scheduler crate, so the bundle handle sits next to ScheduledBatch
and ScheduledTransaction. The handle is now generic over its artifact type
A (opaque, like ScheduledBatch's P::BatchArtifact) rather than the receipt,
which keeps the scheduler free of settlement/proof-system structs and
avoids a scheduler -> aggregate-prover dependency cycle.

SettlementArtifact stays in aggregate-prover; call sites move from
ScheduledBundle<Receipt> to ScheduledBundle<SettlementArtifact<Receipt>>.
The scheduler gains kaspa-hashes and vprogs-l1-types for the bundle's
metadata fields, and the settler crate gains a scheduler dependency.

Neutralize the moved bundle docs so the scheduler crate no longer names
downstream crates (aggregate prover, settler, proof-receipt store),
matching ScheduledBatch's generic voice.

Author: biryukovmaxim

Cargo.lock

@@ -21,10 +21,10 @@ use kaspa_wrpc_client::prelude::KaspaRpcClient;
 use vprogs_core_atomics::AsyncQueue;
 use vprogs_l1_bridge::L1BridgeConfig;
 use vprogs_node_framework::{Node, NodeConfig};
-use vprogs_scheduling_scheduler::ExecutionConfig;
+use vprogs_scheduling_scheduler::{ExecutionConfig, ScheduledBundle};
 use vprogs_storage_manager::StorageConfig;
 use vprogs_storage_rocksdb_store::RocksDbStore;
-use vprogs_zk_aggregate_prover::{AggregateProverConfig, ScheduledBundle};
+use vprogs_zk_aggregate_prover::{AggregateProverConfig, SettlementArtifact};
 use vprogs_zk_backend_risc0_api::{Backend, ProofType, Receipt};
 use vprogs_zk_batch_prover::{BatchProverConfig, LaneProofRequest, LaneProofSource};
 use vprogs_zk_vm::{ProvingPipeline, Vm};
@@ -37,7 +37,7 @@ pub type V = Vm<Backend, Store>;
 pub type FlowNode = Node<Store, V>;
 /// Queue of bundle handles the aggregate prover publishes to the settlement worker (one per formed
 /// bundle).
-pub type FlowSettlementQueue = AsyncQueue<ScheduledBundle<Receipt>>;
+pub type FlowSettlementQueue = AsyncQueue<ScheduledBundle<SettlementArtifact<Receipt>>>;
 
 /// Everything the bridge needs to follow our lane on the remote node.
 pub struct BridgeParams {

examples/tn10-flow/src/daemon.rs

@@ -8,6 +8,7 @@ arc-swap.workspace                            = true
 borsh.workspace                               = true
 crossbeam-deque.workspace                     = true
 crossbeam-queue.workspace                     = true
+kaspa-hashes.workspace                        = true
 num_cpus.workspace                            = true
 tap.workspace                                 = true
 thiserror.workspace                           = true
@@ -17,6 +18,7 @@ vprogs-core-hashing.workspace                 = true
 vprogs-core-macros.workspace                  = true
 vprogs-core-smt.workspace                     = true
 vprogs-core-types.workspace                   = true
+vprogs-l1-types.workspace                     = true
 vprogs-scheduling-execution-workers.workspace = true
 vprogs-state-batch-metadata.workspace         = true
 vprogs-state-metadata.workspace               = true

scheduling/scheduler/Cargo.toml

@@ -10,6 +10,7 @@ mod resource;
 mod resource_access;
 mod rollback;
 mod scheduled_batch;
+mod scheduled_bundle;
 mod scheduled_transaction;
 mod scheduler;
 mod state;
@@ -27,6 +28,7 @@ pub use pruning_worker::PruningWorker;
 pub(crate) use resource::Resource;
 pub(crate) use resource_access::ResourceAccess;
 pub use scheduled_batch::{ScheduledBatch, ScheduledBatchRef};
+pub use scheduled_bundle::{BundleBlocks, ScheduledBundle};
 pub use scheduled_transaction::ScheduledTransaction;
 pub(crate) use scheduled_transaction::ScheduledTransactionRef;
 pub use scheduler::Scheduler;

scheduling/scheduler/src/lib.rs

@@ -6,8 +6,6 @@ use vprogs_core_atomics::AtomicAsyncLatch;
 use vprogs_core_macros::smart_pointer;
 use vprogs_l1_types::SettlementInfo;
 
-use crate::SettlementArtifact;
-
 /// The L1 block span a bundle proves over.
 #[derive(Clone, Copy)]
 pub struct BundleBlocks {
@@ -17,26 +15,25 @@ pub struct BundleBlocks {
     pub block_prove_to: Hash,
 }
 
-/// A bundle the aggregate prover has formed and published to the settlement queue.
+/// A formed bundle of proved batches, published to a settlement consumer before its artifact
+/// exists.
 ///
-/// Mirrors [`ScheduledBatch`](vprogs_scheduling_scheduler::ScheduledBatch)'s artifact mechanism:
-/// the handle is pushed onto the settlement queue *before* its proof exists, so a consumer can pop
-/// it, read the immediate metadata (e.g. reconcile pacing against `batches`), and then await the
-/// proved [`SettlementArtifact`]. The aggregate worker fills the artifact via
+/// Mirrors [`ScheduledBatch`](crate::ScheduledBatch)'s artifact mechanism: the handle is published
+/// *before* its artifact exists, so a consumer can pop it, read the immediate metadata (e.g.
+/// reconcile pacing against `batches`), and then await the proved artifact `A`, filled via
 /// [`publish_artifact`](Self::publish_artifact) once proving completes.
 ///
 /// A no-op bundle (all-empty prefix, or one that advanced no state) carries no artifact: it is
 /// constructed already resolved (latch open, artifact `None`) and the consumer skips it. Every
 /// formed bundle still produces exactly one handle, so a consumer that paces itself against proving
 /// can account for all submitted batches by summing each handle's `batches`.
 #[smart_pointer]
-pub struct ScheduledBundle<R> {
+pub struct ScheduledBundle<A> {
     /// Number of scheduled batches this bundle consumed (including empty batches in the ready
     /// prefix). Readable immediately, before the artifact is published.
     batches: usize,
-    /// The bundle's first checkpoint index (bundle-start). With `from_block` it is the
-    /// bundle-start coordinate that keys the aggregator receipt's prefix in the proof-receipt
-    /// store. Immediate.
+    /// The bundle's first checkpoint index (bundle-start). With `from_block`, the coordinate that
+    /// keys the bundle's aggregate receipt. Immediate.
     checkpoint_index: u64,
     /// L1 block at the bundle's first checkpoint (the block it proves *from*), pairing with
     /// `block_prove_to`. Together with `checkpoint_index` it keys the aggregator receipt and keeps
@@ -45,19 +42,18 @@ pub struct ScheduledBundle<R> {
     /// L1 block the bundle proves through (its final block). Immediate, for logging / pacing.
     block_prove_to: Hash,
     /// Most-recent covenant settlement visible on chain as of the bundle's final block, or `None`
-    /// until one lands. Lets the settler skip a bundle an external settlement already covered: the
-    /// same redundancy the aggregate prover applies when forming bundles. Immediate.
+    /// until one lands. Immediate.
     latest_settlement: Option<SettlementInfo>,
-    /// The proved settlement, filled via [`publish_artifact`](Self::publish_artifact). `None` for
-    /// a no-op bundle that advanced no state.
-    settlement: ArcSwapOption<SettlementArtifact<R>>,
+    /// The proved artifact, filled via [`publish_artifact`](Self::publish_artifact). `None` for a
+    /// no-op bundle that advanced no state.
+    artifact: ArcSwapOption<A>,
     /// Opens when the artifact has been published (or resolved as a no-op).
     artifact_published: AtomicAsyncLatch,
 }
 
-impl<R> ScheduledBundle<R> {
-    /// Creates an unresolved bundle handle: its metadata is readable immediately, the settlement
-    /// artifact is filled later via [`publish_artifact`](Self::publish_artifact).
+impl<A> ScheduledBundle<A> {
+    /// Creates an unresolved bundle handle: its metadata is readable immediately, the artifact is
+    /// filled later via [`publish_artifact`](Self::publish_artifact).
     pub fn new(
         batches: usize,
         checkpoint_index: u64,
@@ -71,13 +67,13 @@ impl<R> ScheduledBundle<R> {
             from_block,
             block_prove_to,
             latest_settlement,
-            settlement: ArcSwapOption::empty(),
+            artifact: ArcSwapOption::empty(),
             artifact_published: AtomicAsyncLatch::new(),
         }))
     }
 
     /// Creates an immediately-resolved no-op bundle: it advanced no state, so it carries no
-    /// settlement and its artifact latch is already open.
+    /// artifact and its artifact latch is already open.
     pub fn resolved_noop(
         batches: usize,
         checkpoint_index: u64,
@@ -93,7 +89,7 @@ impl<R> ScheduledBundle<R> {
             from_block,
             block_prove_to,
             latest_settlement,
-            settlement: ArcSwapOption::empty(),
+            artifact: ArcSwapOption::empty(),
             artifact_published,
         }))
     }
@@ -124,22 +120,22 @@ impl<R> ScheduledBundle<R> {
         self.latest_settlement
     }
 
-    /// Publishes the bundle's settlement artifact and opens the `artifact_published` latch. A
-    /// `None` artifact resolves the handle as a no-op (the consumer skips it).
-    pub fn publish_artifact(&self, artifact: Option<SettlementArtifact<R>>) {
+    /// Publishes the bundle's artifact and opens the `artifact_published` latch. A `None` artifact
+    /// resolves the handle as a no-op (the consumer skips it).
+    pub fn publish_artifact(&self, artifact: Option<A>) {
         if let Some(artifact) = artifact {
-            self.settlement.store(Some(Arc::new(artifact)));
+            self.artifact.store(Some(Arc::new(artifact)));
         }
         self.artifact_published.open();
     }
 
-    /// Returns the published settlement artifact, or `None` if the bundle resolved as a no-op.
+    /// Returns the published artifact, or `None` if the bundle resolved as a no-op.
     ///
     /// Must be called after [`wait_artifact_published`](Self::wait_artifact_published): the handle
     /// is visible to consumers before its artifact exists, so an early call returns `None` for an
     /// unresolved bundle rather than panicking.
-    pub fn artifact(&self) -> Option<Arc<SettlementArtifact<R>>> {
-        self.settlement.load_full()
+    pub fn artifact(&self) -> Option<Arc<A>> {
+        self.artifact.load_full()
     }
 
     /// Waits until the bundle's artifact has been published (or resolved as a no-op).

…aggregate-prover/src/scheduled_bundle.rs …duling/scheduler/src/scheduled_bundle.rszk/aggregate-prover/src/scheduled_bundle.rs renamed to scheduling/scheduler/src/scheduled_bundle.rs zk/aggregate-prover/src/scheduled_bundle.rs renamed to scheduling/scheduler/src/scheduled_bundle.rs

@@ -20,9 +20,9 @@ use vprogs_core_test_utils::ResourceIdExt;
 use vprogs_core_types::{AccessMetadata, ResourceId, SchedulerTransaction};
 use vprogs_l1_types::ChainBlockMetadata;
 use vprogs_l1_wallet::{build, encode_activity_payload};
-use vprogs_scheduling_scheduler::{Processor, Scheduler};
+use vprogs_scheduling_scheduler::{Processor, ScheduledBundle, Scheduler};
 use vprogs_storage_rocksdb_store::RocksDbStore;
-use vprogs_zk_aggregate_prover::{AggregateProverConfig, ScheduledBundle, SettlementArtifact};
+use vprogs_zk_aggregate_prover::{AggregateProverConfig, SettlementArtifact};
 use vprogs_zk_backend_risc0_api::{Backend, ProofType, Receipt};
 use vprogs_zk_backend_risc0_covenant::{
     Settlement, SettlementDevInput, build_dev_redeem_script, dev_redeem_script_len,
@@ -163,7 +163,7 @@ pub struct L2Driver {
     /// Queue the in-process aggregate prover publishes each bundle handle onto (real_e2e only).
     /// The driver pops from it to settle proved bundles. `None` in the other modes and before
     /// the proving stack is built.
-    settlement_queue: Option<AsyncQueue<ScheduledBundle<Receipt>>>,
+    settlement_queue: Option<AsyncQueue<ScheduledBundle<SettlementArtifact<Receipt>>>>,
     /// Batches submitted to the aggregate prover but not yet accounted by a bundle outcome
     /// (real_e2e only). Gates the settlement back-pressure and is reconciled by each outcome's
     /// `batches`.
@@ -198,7 +198,7 @@ fn build_exec(
     proving: bool,
     covenant_id: Option<Hash>,
     consensus: Weak<Consensus>,
-) -> (Exec, Option<AsyncQueue<ScheduledBundle<Receipt>>>) {
+) -> (Exec, Option<AsyncQueue<ScheduledBundle<SettlementArtifact<Receipt>>>>) {
     let db = tempfile::tempdir().expect("temp db dir");
     let store = RocksDbStore::open(db.path().join("l2"));
     let (pipeline, settlement_queue) = if proving {

sim/src/driver/l2_driver.rs

@@ -1,8 +1,9 @@
 use kaspa_hashes::Hash;
 use vprogs_core_atomics::AsyncQueue;
+use vprogs_scheduling_scheduler::ScheduledBundle;
 use vprogs_zk_batch_prover::LaneProofSource;
 
-use crate::ScheduledBundle;
+use crate::SettlementArtifact;
 
 /// Static configuration for the aggregate prover.
 ///
@@ -22,5 +23,5 @@ pub struct AggregateProverConfig<L: LaneProofSource, R: Send + Sync + 'static> {
     /// before its proof exists; the consumer awaits the artifact), for a settlement worker to act
     /// on. `None` runs the prover without settling (e.g. exec/test paths); proved bundles are
     /// then only logged.
-    pub settlement_queue: Option<AsyncQueue<ScheduledBundle<R>>>,
+    pub settlement_queue: Option<AsyncQueue<ScheduledBundle<SettlementArtifact<R>>>>,
 }

zk/aggregate-prover/src/config.rs

@@ -2,12 +2,10 @@ mod backend;
 mod command;
 mod config;
 mod prover;
-mod scheduled_bundle;
 mod settlement_artifact;
 mod worker;
 
 pub use backend::Backend;
 pub use config::AggregateProverConfig;
 pub use prover::AggregateProver;
-pub use scheduled_bundle::{BundleBlocks, ScheduledBundle};
 pub use settlement_artifact::SettlementArtifact;

zk/aggregate-prover/src/lib.rs

@@ -9,14 +9,13 @@ use vprogs_core_atomics::AsyncQueue;
 use vprogs_core_codec::Reader;
 use vprogs_core_smt::EMPTY_HASH;
 use vprogs_l1_types::{ChainBlockMetadata, SettlementInfo};
-use vprogs_scheduling_scheduler::{Processor, ScheduledBatch};
+use vprogs_scheduling_scheduler::{BundleBlocks, Processor, ScheduledBatch, ScheduledBundle};
 use vprogs_storage_types::Store;
 use vprogs_zk_abi::batch_aggregator::{Inputs as AggregatorInputs, StateTransition};
 use vprogs_zk_batch_prover::{LaneProofRequest, LaneProofSource};
 
 use crate::{
-    AggregateProver, AggregateProverConfig, Backend, BundleBlocks, ScheduledBundle,
-    SettlementArtifact, command::Command,
+    AggregateProver, AggregateProverConfig, Backend, SettlementArtifact, command::Command,
 };
 
 /// Background worker that accumulates scheduled batches, forms bundles from the consecutively-ready
@@ -34,7 +33,7 @@ pub(crate) struct Worker<S: Store, P: Processor<S>, B: Backend, L: LaneProofSour
     lane_source: L,
     /// Queue each formed bundle's [`ScheduledBundle`] handle is published onto for on-chain
     /// settlement, or `None` to run without settling.
-    settlement_queue: Option<AsyncQueue<ScheduledBundle<B::Receipt>>>,
+    settlement_queue: Option<AsyncQueue<ScheduledBundle<SettlementArtifact<B::Receipt>>>>,
     /// Batches accumulated but not yet bundled, in scheduling order.
     queued: VecDeque<ScheduledBatch<S, P>>,
     /// Last settled L1 block (the lower bound a new bundle chains from). `None` at genesis.
@@ -277,7 +276,7 @@ where
 
     /// Publishes a formed bundle's handle onto the settlement queue, if one is wired. With no queue
     /// the prover runs without settling and the handle is dropped.
-    fn emit(&self, bundle: ScheduledBundle<B::Receipt>) {
+    fn emit(&self, bundle: ScheduledBundle<SettlementArtifact<B::Receipt>>) {
         if let Some(queue) = &self.settlement_queue {
             queue.push(bundle);
         }

zk/aggregate-prover/src/worker.rs

@@ -16,6 +16,7 @@ tokio                                      = { workspace = true, features = ["ma
 vprogs-core-atomics.workspace              = true
 vprogs-core-smt.workspace                  = true
 vprogs-l1-wallet.workspace                 = true
+vprogs-scheduling-scheduler.workspace      = true
 vprogs-zk-aggregate-prover.workspace       = true
 vprogs-zk-backend-risc0-api                = { workspace = true, features = ["host"] }
 vprogs-zk-backend-risc0-covenant.workspace = true