Dependency sweep: drop unused deps, consolidate rand on 0.10, refresh lockfile

Cargo.toml

@@ -29,7 +29,7 @@ qp-poseidon-core = { version = "=3.1.0", default-features = false }
 serde = { version = "=1.0.228", default-features = false, features = ["derive"] }
 tiny-keccak = { version = "=2.0.2", default-features = false, features = ["keccak"] }
 tracing = { version = "=0.1.44", default-features = false, features = ["std"] }
-zeroize = { version = "=1.8.2", default-features = false, features = ["alloc"] }
+zeroize = { version = "=1.9.1", default-features = false, features = ["alloc"] }
 
 [workspace.package]
 authors = ["Quantus Network"]

common/Cargo.toml

@@ -12,21 +12,17 @@ anyhow = { workspace = true, default-features = false }
 qp-plonky2 = { workspace = true, default-features = false }
 qp-poseidon-core = { workspace = true, default-features = false }
 qp-wormhole-inputs = { version = "=4.4.0", path = "../wormhole/inputs", default-features = false }
-rand = { version = "=0.8.6", default-features = false, features = ["alloc"], optional = true }
 serde = { workspace = true }
-serde_json = { version = "=1.0.150", default-features = false, features = ["alloc"] }
+serde_json = { version = "=1.0.154", default-features = false, features = ["alloc"] }
 
 [features]
 default = ["std"]
 formal-export = ["qp-plonky2/formal-export", "std"]
 std = [
 	"anyhow/std",
-	"dep:rand",
 	"qp-plonky2/std",
 	"qp-poseidon-core/std",
 	"qp-wormhole-inputs/std",
-	"rand/std",
-	"rand/std_rng",
 	"serde/std",
 	"serde_json/std",
 ]

ownership/circuit-builder/Cargo.toml

@@ -11,7 +11,7 @@ version.workspace = true
 
 [dependencies]
 anyhow = { workspace = true, features = ["std"] }
-clap = { version = "=4.6.1", features = ["derive"] }
+clap = { version = "=4.6.7", features = ["derive"] }
 ownership-circuit = { package = "qp-ownership-circuit", version = "=4.4.0", path = "../circuit" }
 qp-plonky2 = { workspace = true, features = ["default"] }
 zk-circuits-common = { package = "qp-zk-circuits-common", version = "=4.4.0", path = "../../common" }

ownership/tests/Cargo.toml

@@ -8,12 +8,9 @@ publish = false
 version.workspace = true
 
 [dependencies]
-anyhow = { workspace = true }
-hex = { workspace = true }
 ownership-circuit = { package = "qp-ownership-circuit", version = "=4.4.0", path = "../circuit" }
 ownership-prover = { package = "qp-ownership-prover", version = "=4.4.0", path = "../prover" }
 ownership-verifier = { package = "qp-ownership-verifier", version = "=4.4.0", path = "../verifier" }
-qp-ownership-inputs = { version = "=4.4.0", path = "../inputs" }
 qp-plonky2 = { workspace = true, default-features = true }
 tiny-keccak = { workspace = true }
 wormhole-circuit = { package = "qp-wormhole-circuit", version = "=4.4.0", path = "../../wormhole/circuit" }

wormhole/aggregator/Cargo.toml

@@ -13,10 +13,9 @@ hex = "=0.4.3"
 qp-plonky2 = { workspace = true }
 qp-wormhole-gpu = { version = "=4.4.0", path = "../gpu", optional = true, features = ["constraint-export"] }
 qp-wormhole-inputs = { version = "=4.4.0", path = "../inputs" }
-rand = "=0.8.6"
-rayon = { version = "=1.12.0", optional = true }
+rand = { version = "=0.10.1", default-features = false, features = ["thread_rng"] }
 serde = { version = "=1.0.228", features = ["derive"] }
-serde_json = "=1.0.150"
+serde_json = "=1.0.154"
 tracing = { workspace = true, optional = true }
 wormhole-circuit = { package = "qp-wormhole-circuit", version = "=4.4.0", path = "../circuit", default-features = false }
 wormhole-prover = { package = "qp-wormhole-prover", version = "=4.4.0", path = "../prover", default-features = false }
@@ -25,7 +24,8 @@ zk-circuits-common = { package = "qp-zk-circuits-common", version = "=4.4.0", pa
 [dev-dependencies]
 criterion = { workspace = true }
 env_logger = "=0.11.9"
-futures = { version = "=0.3.32", default-features = false, features = ["executor"] }
+pollster = "=1.0.1"
+rayon = "=1.12.0"
 test-helpers = { path = "../tests/test-helpers", default-features = false }
 tracing-subscriber = { version = "=0.3.23", default-features = false, features = ["registry", "std"] }
 # Enables `TracingBuilder` for the checked-in formal wrapper trace test.
@@ -35,9 +35,8 @@ zk-circuits-common = { package = "qp-zk-circuits-common", version = "=4.4.0", pa
 wormhole-circuit-builder = { package = "qp-wormhole-circuit-builder", path = "../circuit-builder" }
 
 [features]
-default = ["multithread", "std"]
+default = ["std"]
 gpu = ["dep:qp-wormhole-gpu", "dep:tracing", "std"]
-multithread = ["rayon"]
 no_zk = []
 profile = ["qp-plonky2/rand", "qp-plonky2/timing", "std"]
 std = [
@@ -66,4 +65,4 @@ required-features = ["gpu"]
 
 [[example]]
 name = "public_batch_compare"
-required-features = ["gpu", "multithread"]
+required-features = ["gpu"]

wormhole/aggregator/benches/gpu.rs

@@ -34,7 +34,7 @@ const WORKER_COUNTS: &[usize] = &[2, 4];
 fn device() -> Arc<DeviceContext> {
     static DEVICE: OnceLock<Arc<DeviceContext>> = OnceLock::new();
     Arc::clone(DEVICE.get_or_init(|| {
-        let context = futures::executor::block_on(DeviceContext::new())
+        let context = pollster::block_on(DeviceContext::new())
             .expect("GPU benches require a hardware GPU with native u64 shader support");
         eprintln!("adapter: {:?}", context.adapter_info());
         Arc::new(context)

wormhole/aggregator/examples/prepare_public_batch.rs

@@ -41,7 +41,7 @@ fn run(profile: &profile::Profile) -> Result<()> {
         start.elapsed().as_secs_f64()
     );
     let start = Instant::now();
-    let context = futures::executor::block_on(DeviceContext::new())?;
+    let context = pollster::block_on(DeviceContext::new())?;
     println!(
         "GPU device initialization: {:.3}s",
         start.elapsed().as_secs_f64()

wormhole/aggregator/examples/public_batch_compare.rs

@@ -123,7 +123,7 @@ fn run(arguments: Vec<String>, timestamps: bool, profile: Option<&profile::Profi
     let mut gpu_init = 0.0;
     if backend == "gpu" {
         let device_started = Instant::now();
-        let context = Arc::new(futures::executor::block_on(DeviceContext::with_options(
+        let context = Arc::new(pollster::block_on(DeviceContext::with_options(
             DeviceOptions {
                 timestamps,
                 ..Default::default()

wormhole/aggregator/src/aggregator/gpu_tests.rs

@@ -34,7 +34,7 @@ fn gpu_proving_context(
             })
         })
         .collect::<Result<Vec<_>>>()?;
-    let context = Arc::new(futures::executor::block_on(DeviceContext::new())?);
+    let context = Arc::new(pollster::block_on(DeviceContext::new())?);
     prover.with_gpu(context, PreparationOptions::default())?;
     let proving = ProvingContext {
         aggregator_address: address,
@@ -110,7 +110,7 @@ fn gpu_backend_proves_through_aggregator_and_cloned_workers() -> Result<()> {
     assert_send_sync::<ProvingContext>();
     let (prover, inner, private_batch_verifier) =
         crate::public_batch::prover::lib::tests::gpu_fixture();
-    let context = Arc::new(futures::executor::block_on(DeviceContext::new())?);
+    let context = Arc::new(pollster::block_on(DeviceContext::new())?);
     let options = PreparationOptions::default();
     let address = BytesDigest::try_from([7u8; 32])?;
     let proving = ProvingContext {

wormhole/aggregator/src/dummy_proof.rs

@@ -24,7 +24,7 @@ use anyhow::Result;
 use plonky2::plonk::circuit_data::CommonCircuitData;
 use plonky2::plonk::proof::ProofWithPublicInputs;
 use qp_wormhole_inputs::PublicCircuitInputs;
-use rand::Rng;
+use rand::RngExt;
 use wormhole_circuit::inputs::{CircuitInputs, PrivateCircuitInputs};
 use wormhole_circuit::unspendable_account::UnspendableAccount;
 use zk_circuits_common::circuit::{C, D, F};
@@ -157,7 +157,7 @@ pub fn build_dummy_circuit_inputs() -> Result<CircuitInputs> {
 /// Generate a random 32-byte nullifier preimage for dummy proofs.
 /// The circuit will hash this to produce the actual nullifier.
 pub(crate) fn generate_random_nullifier_preimage() -> BytesDigest {
-    let mut rng = rand::thread_rng();
+    let mut rng = rand::rng();
     loop {
         let mut nullifier = [0u8; 32];
         rng.fill(&mut nullifier);

wormhole/aggregator/src/private_batch/circuit/tests/circuit_logic.rs

@@ -15,7 +15,7 @@ use plonky2::{
 };
 use qp_wormhole_inputs::{BytesDigest, PrivateBatchShape, WithdrawalOutput};
 use rand::rngs::StdRng;
-use rand::{Rng, SeedableRng};
+use rand::{RngExt, SeedableRng};
 
 use zk_circuits_common::circuit::{
     wormhole_leaf_circuit_config, wormhole_private_batch_circuit_config, C, D, F,
@@ -106,7 +106,7 @@ fn build_private_batch(
 fn deterministic_dummy_nullifier_pre_images(n: usize) -> Vec<[F; 4]> {
     let mut rng = StdRng::from_seed([77u8; 32]);
     (0..n)
-        .map(|_| core::array::from_fn(|_| F::from_canonical_u64(rng.gen::<u32>() as u64)))
+        .map(|_| core::array::from_fn(|_| F::from_canonical_u64(rng.random::<u32>() as u64)))
         .collect()
 }
 
@@ -482,7 +482,7 @@ fn recursive_aggregation_tree() {
     let block = block_hash(0);
 
     let inputs: Vec<u32> = (0..SHAPE.num_leaf_proofs)
-        .map(|_| rng.gen::<u32>() >> 4)
+        .map(|_| rng.random::<u32>() >> 4)
         .collect();
     let proofs: Vec<_> = inputs
         .iter()

wormhole/aggregator/src/private_batch/prover/lib.rs

@@ -388,7 +388,7 @@ impl PrivateBatchProver {
         }
         outputs.resize(self.shape.num_exit_slots, WithdrawalOutput::default());
 
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
 
         // Uniformly shuffle proofs to hide dummy positions. The circuit selects its block
         // reference from the first non-dummy slot in-circuit, so no position is special.

wormhole/aggregator/src/public_batch/prover/backend.rs

@@ -168,7 +168,7 @@ mod tests {
     #[ignore = "requires a hardware GPU with native u64 shader support"]
     fn gpu_backend_keeps_proving_after_a_worker_panics_mid_proof() -> Result<()> {
         let circuit = build_circuit();
-        let context = Arc::new(futures::executor::block_on(DeviceContext::new())?);
+        let context = Arc::new(pollster::block_on(DeviceContext::new())?);
         let backend =
             GpuBackend::prepare(Arc::clone(&circuit), context, PreparationOptions::default())?;
         circuit.verify(backend.prove(PartialWitness::new())?)?;
@@ -191,14 +191,14 @@ mod tests {
     fn gpu_rebuild_releases_old_backend_and_can_retry_after_failure() -> Result<()> {
         let circuit = build_circuit();
         let options = PreparationOptions::default();
-        let old_context = Arc::new(futures::executor::block_on(DeviceContext::new())?);
+        let old_context = Arc::new(pollster::block_on(DeviceContext::new())?);
         let old_weak = Arc::downgrade(&old_context);
         let mut backend = ProvingBackend::Gpu(Box::new(GpuBackend::prepare(
             Arc::clone(&circuit),
             old_context,
             options,
         )?));
-        let context = Arc::new(futures::executor::block_on(DeviceContext::new())?);
+        let context = Arc::new(pollster::block_on(DeviceContext::new())?);
         let error = backend
             .replace_gpu(&context, || {
                 // This checks ownership release, not physical driver VRAM reclamation.

wormhole/circuit-builder/Cargo.toml

@@ -16,9 +16,9 @@ zk-circuits-common = { package = "qp-zk-circuits-common", version = "=4.4.0", pa
 
 [dependencies]
 anyhow = { workspace = true, features = ["std"] }
-clap = { version = "=4.6.1", features = ["derive"] }
+clap = { version = "=4.6.7", features = ["derive"] }
 qp-plonky2 = { workspace = true, features = ["default"] }
-rand = "=0.8.6"
+rand = { version = "=0.10.1", default-features = false, features = ["thread_rng"] }
 wormhole-aggregator = { package = "qp-wormhole-aggregator", version = "=4.4.0", path = "../aggregator", default-features = false, features = [
 	"std",
 ] }

wormhole/circuit/Cargo.toml

@@ -9,7 +9,6 @@ version.workspace = true
 
 [dependencies]
 anyhow = { workspace = true }
-hex = { workspace = true, features = ["alloc"] }
 qp-plonky2 = { workspace = true }
 qp-wormhole-inputs = { version = "=4.4.0", path = "../inputs", default-features = false }
 zeroize = { workspace = true }

wormhole/gpu/Cargo.toml

@@ -30,7 +30,7 @@ wgpu = { version = "=27.0.1", optional = true, default-features = false, feature
 
 [dev-dependencies]
 criterion = { workspace = true }
-futures = { version = "=0.3.32", default-features = false, features = ["executor"] }
+pollster = "=1.0.1"
 qp-plonky2 = { workspace = true, features = ["rand"] }
 tracing-subscriber = { version = "=0.3.23", default-features = false, features = ["registry", "std"] }
 

wormhole/gpu/benches/kernels.rs

@@ -30,7 +30,7 @@ const CHUNK_ROWS: usize = 1 << 16;
 fn context() -> &'static DeviceContext {
     static CONTEXT: OnceLock<DeviceContext> = OnceLock::new();
     CONTEXT.get_or_init(|| {
-        let context = futures::executor::block_on(DeviceContext::new())
+        let context = pollster::block_on(DeviceContext::new())
             .expect("kernel benches require a hardware GPU with native u64 shader support");
         eprintln!("adapter: {:?}", context.adapter_info());
         context

wormhole/gpu/src/circuit/openings/tests.rs

@@ -69,7 +69,7 @@ fn next_row_openings_and_composition_span_coefficient_batches() -> Result<()> {
     use plonky2::field::polynomial::PolynomialCoeffs;
     use plonky2::util::reducing::ReducingFactor;
 
-    let context = futures::executor::block_on(DeviceContext::new())?;
+    let context = pollster::block_on(DeviceContext::new())?;
     let mut config = CircuitConfig::standard_recursion_config();
     config.num_challenges = 3;
     let circuit = CircuitBuilder::<F, 2>::new(config).build::<C>();

wormhole/gpu/src/circuit/prover/tests.rs

@@ -97,7 +97,7 @@ fn prove_two_inputs_on_one_workspace(context: &DeviceContext) -> Result<()> {
 #[test]
 #[ignore = "requires a hardware GPU with native u64 shader support"]
 fn coordinator_generates_verifiable_proofs_with_fri_and_reuses_workspace() -> Result<()> {
-    let context = futures::executor::block_on(DeviceContext::new())?;
+    let context = pollster::block_on(DeviceContext::new())?;
     prove_two_inputs_on_one_workspace(&context)
 }
 
@@ -107,7 +107,7 @@ fn profiled_coordinator_records_every_host_span() -> Result<()> {
     let captured = HostSpans::default();
     let dispatcher = tracing::Dispatch::new(tracing_subscriber::registry().with(captured.clone()));
     tracing::dispatcher::with_default(&dispatcher, || -> Result<()> {
-        let context = futures::executor::block_on(DeviceContext::with_options(DeviceOptions {
+        let context = pollster::block_on(DeviceContext::with_options(DeviceOptions {
             timestamps: true,
             ..Default::default()
         }))?;
@@ -156,7 +156,7 @@ fn profiled_coordinator_records_every_host_span() -> Result<()> {
 #[test]
 #[ignore = "requires a hardware GPU with native u64 shader support"]
 fn pow_grind_spanning_many_chunks_matches_single_chunk_and_cpu_proofs() -> Result<()> {
-    let context = futures::executor::block_on(DeviceContext::new())?;
+    let context = pollster::block_on(DeviceContext::new())?;
     let mut config = CircuitConfig::standard_recursion_config();
     config.fri_config.reduction_strategy = FriReductionStrategy::Fixed(vec![]);
     config.fri_config.proof_of_work_bits = 6;
@@ -217,7 +217,7 @@ fn pow_grind_spanning_many_chunks_matches_single_chunk_and_cpu_proofs() -> Resul
 #[test]
 #[ignore = "requires a hardware GPU with native u64 shader support"]
 fn boundary_witness_values_prove_identically_to_cpu() -> Result<()> {
-    let context = futures::executor::block_on(DeviceContext::new())?;
+    let context = pollster::block_on(DeviceContext::new())?;
     let mut config = CircuitConfig::standard_recursion_config();
     config.fri_config.reduction_strategy = FriReductionStrategy::Fixed(vec![1]);
     config.fri_config.proof_of_work_bits = 4;
@@ -292,7 +292,7 @@ fn workspace_ranges_and_pow_retries_are_checked() {
 #[test]
 #[ignore = "requires a hardware GPU with native u64 shader support"]
 fn coordinator_handles_zero_fri_rounds_and_reuses_workspace_after_input_errors() -> Result<()> {
-    let context = futures::executor::block_on(DeviceContext::new())?;
+    let context = pollster::block_on(DeviceContext::new())?;
     let mut config = CircuitConfig::standard_recursion_config();
     config.fri_config.reduction_strategy = FriReductionStrategy::Fixed(vec![]);
     config.fri_config.proof_of_work_bits = 8;

wormhole/gpu/src/circuit/quotient/tests.rs

@@ -214,7 +214,7 @@ fn cpu_quotient_values(
 #[test]
 #[ignore = "requires a hardware GPU with native u64 shader support"]
 fn resident_proving_stages_match_cpu_and_generate_verifiable_proofs() -> Result<()> {
-    let context = futures::executor::block_on(DeviceContext::new())?;
+    let context = pollster::block_on(DeviceContext::new())?;
     for (challenges, factor, rate) in [(2, 8, 3), (3, 7, 4)] {
         let mut config = CircuitConfig::standard_recursion_config();
         config.num_challenges = challenges;

wormhole/gpu/src/circuit/tests.rs

@@ -210,7 +210,7 @@ fn column_batches_respect_binding_limits() {
 #[test]
 #[ignore = "requires a hardware GPU with native u64 shader support"]
 fn resident_wire_commitment_matches_cpu_and_reuses_preparation() -> Result<()> {
-    let context = futures::executor::block_on(DeviceContext::new())?;
+    let context = pollster::block_on(DeviceContext::new())?;
     let (circuit, input) = tiny_circuit();
     let prepared = PreparedCircuit::prepare(
         &context,

wormhole/gpu/src/operations/extension/tests.rs

@@ -14,7 +14,7 @@ fn planes(values: &[E<F>]) -> Vec<F> {
 #[test]
 #[ignore = "requires a hardware GPU with native u64 shader support"]
 fn extension_polynomial_operations_match_cpu_across_block_boundaries() -> Result<()> {
-    let context = futures::executor::block_on(DeviceContext::new())?;
+    let context = pollster::block_on(DeviceContext::new())?;
     let kernels = Arc::new(ExtensionKernels::prepare(&context)?);
     let point = E([F::from_canonical_u64(11), F::from_canonical_u64(9)]);
     let weights = [

wormhole/gpu/src/operations/fri/tests.rs

@@ -28,7 +28,7 @@ fn planes(values: &[E<F>]) -> Vec<F> {
 #[test]
 #[ignore = "requires a hardware GPU with native u64 shader support"]
 fn fri_folds_and_chunked_commitments_match_cpu() -> Result<()> {
-    let context = futures::executor::block_on(DeviceContext::new())?;
+    let context = pollster::block_on(DeviceContext::new())?;
     let kernels = Arc::new(FriKernels::prepare(&context)?);
     let poseidon = Arc::new(PoseidonKernels::prepare(&context)?);
     for (rows, arity, cap_height) in [

wormhole/gpu/src/operations/pow/tests.rs

@@ -18,7 +18,7 @@ fn pow_ranges_and_snapshots_are_checked() -> Result<()> {
 #[ignore = "requires a hardware GPU with native u64 shader support"]
 fn pow_matches_cpu_transcript_and_retries_without_advancing_on_exhaustion() -> Result<()> {
     use crate::ProofWorkspace;
-    let context = futures::executor::block_on(DeviceContext::new())?;
+    let context = pollster::block_on(DeviceContext::new())?;
     let kernels = Arc::new(PowKernels::prepare(
         &context,
         Arc::new(PoseidonKernels::prepare(&context)?),

wormhole/gpu/src/operations/queries/tests.rs

@@ -33,7 +33,7 @@ fn query_layout_decodes_cpu_records_and_rejects_invalid_shapes() -> Result<()> {
 #[test]
 #[ignore = "requires a hardware GPU with native u64 shader support"]
 fn sparse_initial_and_fri_queries_match_cpu_leaves_and_paths() -> Result<()> {
-    let context = futures::executor::block_on(DeviceContext::new())?;
+    let context = pollster::block_on(DeviceContext::new())?;
     let kernels = Arc::new(MerkleQueryKernels::prepare(&context)?);
     let challenges = [
         F::ZERO,

wormhole/gpu/src/operations/quotient/tests.rs

@@ -157,7 +157,7 @@ fn zero_padding_is_not_emitted_as_horner_work() {
 #[test]
 #[ignore = "requires a hardware GPU with native u64 shader support"]
 fn quotient_matches_cpu_gates_and_permutation_equations_on_arbitrary_rows() -> Result<()> {
-    let context = futures::executor::block_on(DeviceContext::new())?;
+    let context = pollster::block_on(DeviceContext::new())?;
     for challenges in [2, 3] {
         let mut config = CircuitConfig::standard_recursion_config();
         config.num_challenges = challenges;

wormhole/gpu/src/operations/scan/tests.rs

@@ -6,7 +6,7 @@ use plonky2::field::types::Field;
 #[test]
 #[ignore = "requires a hardware GPU with native u64 shader support"]
 fn hierarchical_prefix_products_match_cpu_including_zeros() -> Result<()> {
-    let context = futures::executor::block_on(DeviceContext::new())?;
+    let context = pollster::block_on(DeviceContext::new())?;
     // The last shape requires three scan levels, not just one carry pass.
     for rows in [1, 255, 256, 257, 65537] {
         let columns = 2;