diff --git a/Cargo.lock b/Cargo.lock index 41e77fc7..5bb47116 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -6605,6 +6605,31 @@ dependencies = [ "sp-runtime", ] +[[package]] +name = "pallet-miner-aggregation" +version = "0.1.0" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "hex", + "pallet-assets", + "pallet-balances", + "pallet-wormhole", + "pallet-zk-tree", + "parity-scale-codec", + "qp-dilithium-crypto", + "qp-header", + "qp-poseidon", + "qp-wormhole", + "qp-wormhole-verifier", + "scale-info", + "sp-core", + "sp-io", + "sp-runtime", + "sp-state-machine", +] + [[package]] name = "pallet-mining-rewards" version = "0.1.0" @@ -8357,8 +8382,7 @@ dependencies = [ [[package]] name = "qp-wormhole-aggregator" version = "2.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ba5a23eea8e17c97632f5056d1fecdb83d2e997f79d823fb97c514823fce8580" +source = "git+https://github.com/Quantus-Network/qp-zk-circuits?rev=982fd4de36019c108169fedcff348003a06ad465#982fd4de36019c108169fedcff348003a06ad465" dependencies = [ "anyhow", "hex", @@ -8375,8 +8399,7 @@ dependencies = [ [[package]] name = "qp-wormhole-circuit" version = "2.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b72abd3357e1c486621431109d83a259076ed941fcc7f035353a629940c443d9" +source = "git+https://github.com/Quantus-Network/qp-zk-circuits?rev=982fd4de36019c108169fedcff348003a06ad465#982fd4de36019c108169fedcff348003a06ad465" dependencies = [ "anyhow", "hex", @@ -8388,8 +8411,7 @@ dependencies = [ [[package]] name = "qp-wormhole-circuit-builder" version = "2.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9d27c981d34a35cb10ee96e16c1fb44fbb4c52f3e58a787ce089c21bf5469514" +source = "git+https://github.com/Quantus-Network/qp-zk-circuits?rev=982fd4de36019c108169fedcff348003a06ad465#982fd4de36019c108169fedcff348003a06ad465" dependencies = [ "anyhow", "clap", @@ -8402,8 +8424,7 @@ dependencies = [ [[package]] name = "qp-wormhole-inputs" version = "2.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f69e54a0f450d349cb1169bbb743a7a846475a1210760308e38f55841e5aa5c0" +source = "git+https://github.com/Quantus-Network/qp-zk-circuits?rev=982fd4de36019c108169fedcff348003a06ad465#982fd4de36019c108169fedcff348003a06ad465" dependencies = [ "anyhow", ] @@ -8411,8 +8432,7 @@ dependencies = [ [[package]] name = "qp-wormhole-prover" version = "2.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "68cee4d6a0317f89d1ec7a6c40a9592e5525c75b9cb21bd7d5d3b408301068bd" +source = "git+https://github.com/Quantus-Network/qp-zk-circuits?rev=982fd4de36019c108169fedcff348003a06ad465#982fd4de36019c108169fedcff348003a06ad465" dependencies = [ "anyhow", "qp-plonky2", @@ -8424,8 +8444,7 @@ dependencies = [ [[package]] name = "qp-wormhole-verifier" version = "2.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "83f7c0134a766c6624183d129abf12523247e38fc27860e3a9778f73321008ae" +source = "git+https://github.com/Quantus-Network/qp-zk-circuits?rev=982fd4de36019c108169fedcff348003a06ad465#982fd4de36019c108169fedcff348003a06ad465" dependencies = [ "anyhow", "qp-plonky2-verifier", @@ -8435,8 +8454,7 @@ dependencies = [ [[package]] name = "qp-zk-circuits-common" version = "2.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f6d5e1d764560fd797f71defbf75a1618596945c53e33033ac42cc7c2e4689f6" +source = "git+https://github.com/Quantus-Network/qp-zk-circuits?rev=982fd4de36019c108169fedcff348003a06ad465#982fd4de36019c108169fedcff348003a06ad465" dependencies = [ "anyhow", "hex", @@ -8566,6 +8584,7 @@ dependencies = [ "pallet-assets-holder", "pallet-balances", "pallet-conviction-voting", + "pallet-miner-aggregation", "pallet-mining-rewards", "pallet-multisig", "pallet-preimage", diff --git a/Cargo.toml b/Cargo.toml index 90eb9690..0c1af5e1 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -14,6 +14,7 @@ members = [ "miner-api", "node", "pallets/frame-system", + "pallets/miner-aggregation", "pallets/mining-rewards", "pallets/multisig", "pallets/qpow", @@ -132,6 +133,7 @@ zeroize = { version = "1.7.0", default-features = false } # Own dependencies pallet-balances = { version = "46.0.0", default-features = false } +pallet-miner-aggregation = { path = "./pallets/miner-aggregation", default-features = false } pallet-mining-rewards = { path = "./pallets/mining-rewards", default-features = false } pallet-multisig = { path = "./pallets/multisig", default-features = false } pallet-qpow = { path = "./pallets/qpow", default-features = false } @@ -155,11 +157,11 @@ qp-poseidon = { version = "1.4.0", default-features = false } qp-poseidon-core = { version = "1.4.0", default-features = false } qp-rusty-crystals-dilithium = { version = "2.4.0", default-features = false } qp-rusty-crystals-hdwallet = { version = "2.3.1" } -qp-wormhole-circuit = { version = "2.0.1", default-features = false } -qp-wormhole-circuit-builder = { version = "2.0.1", default-features = false } -qp-wormhole-prover = { version = "2.0.1", default-features = false } -qp-wormhole-verifier = { version = "2.0.1", default-features = false } -qp-zk-circuits-common = { version = "2.0.1", default-features = false } +qp-wormhole-circuit = { version = "2.0.1", git = "https://github.com/Quantus-Network/qp-zk-circuits", rev = "982fd4de36019c108169fedcff348003a06ad465", default-features = false } +qp-wormhole-circuit-builder = { version = "2.0.1", git = "https://github.com/Quantus-Network/qp-zk-circuits", rev = "982fd4de36019c108169fedcff348003a06ad465", default-features = false } +qp-wormhole-prover = { version = "2.0.1", git = "https://github.com/Quantus-Network/qp-zk-circuits", rev = "982fd4de36019c108169fedcff348003a06ad465", default-features = false } +qp-wormhole-verifier = { version = "2.0.1", git = "https://github.com/Quantus-Network/qp-zk-circuits", rev = "982fd4de36019c108169fedcff348003a06ad465", default-features = false } +qp-zk-circuits-common = { version = "2.0.1", git = "https://github.com/Quantus-Network/qp-zk-circuits", rev = "982fd4de36019c108169fedcff348003a06ad465", default-features = false } # polkadot-sdk dependencies diff --git a/docs/delegated-l1-aggregation.md b/docs/delegated-l1-aggregation.md new file mode 100644 index 00000000..15f1952c --- /dev/null +++ b/docs/delegated-l1-aggregation.md @@ -0,0 +1,111 @@ +# Delegated L1 Aggregation + +Wormhole proving is split into two layers: + +- Layer 0 remains client-side because L0 proof generation touches private witness data. +- Layer 1 is delegated to bonded aggregation miners and only aggregates already-public L0 aggregate proofs. + +The protocol invariant is: + +```text +Candidate submission does not lock nullifiers. +Bundle claim locks nullifiers. +L1 settlement consumes locked nullifiers and marks them used. +Direct L0 verification rejects used or locked nullifiers. +``` + +The MVP candidate path stores bounded L0 aggregate proof bytes on-chain in +`pallet-miner-aggregation`. Submission parses public metadata and queues candidates by +`BundleGroupKey`, but it does not run full ZK verification, settle exits, lock nullifiers, or mark +nullifiers used. + +Nullifier state is owned by `pallet-wormhole`: + +- `UsedNullifiers` tracks nullifiers consumed by settlement. +- `LockedNullifiers` tracks nullifiers exclusively leased to an aggregation bundle. + +This prevents the direct-L0 race after a miner claims a bundle, while avoiding the opposite attack +where unverified candidate spam locks nullifiers. + +Current reward and bond model: + +- candidate submitters reserve a storage bond, validity bond, and aggregation tip +- aggregation miners register a reward address, active-job limit, and bond +- bundle claim reserves a miner bond and locks all bundle nullifiers +- timeout releases bundle locks, returns unexpired candidates to the queue, and releases the miner bond +- successful L1 settlement consumes locked nullifiers, marks candidates settled, releases candidate bonds, and pays candidate tips to the configured aggregation reward account +- pending expired candidates can be dropped and refunded +- pending invalid candidates can be challenged; if full L0 verification fails, the candidate is marked invalid and its validity bond is burned + +MVP limitations: + +- L1 public inputs do not yet expose a constrained `bundle_root`; settlement compares the reconstructed public effects instead. +- `Bundle.bundle_root` is metadata until the L1 circuit exposes a constrained public root. +- The live external-miner RPC adapter is intentionally separated behind the miner service + `AggregationChainClient` trait; the worker core can be exercised with mocked clients and real + local prover artifacts. + +Dependency strategy: + +1. Merge the `qp-zk-circuits` delegated L1 aggregation changes first, or keep downstream repos + pinned to an exact `qp-zk-circuits` commit. +2. The chain workspace currently pins `qp-zk-circuits` crates to + `982fd4de36019c108169fedcff348003a06ad465`. +3. The `quantus-miner` delegated aggregation worker must use the same `qp-zk-circuits` commit until + these crates are published or upgraded together. +4. Preferred merge order is `qp-zk-circuits`, then `chain`, then `quantus-miner`. + +Runtime weights: + +- `pallet-miner-aggregation/src/weights.rs` currently uses conservative placeholder weights. +- `pallet-miner-aggregation/src/benchmarking.rs` contains benchmark scaffolding and + `runtime/src/benchmarks.rs` registers `pallet_miner_aggregation`. +- Placeholders are explicit for all extrinsics: + `submit_l0_candidate`, `register_aggregator`, `update_aggregator`, `unregister_aggregator`, + `claim_bundle`, `submit_l1_aggregate_cheap_reject`, `submit_l1_aggregate_valid_proof`, + `timeout_bundle`, `challenge_invalid_l0_candidate`, `challenge_invalid_l0_in_bundle`, and + `drop_expired_candidate`. +- The dispatchable weight for `submit_l1_aggregate` is the valid-proof placeholder because it is the + conservative upper bound. Cheap rejects are separately documented for future benchmark mapping. +- These values are not benchmark-generated. Replace them with autogenerated benchmark output before + release. + +Benchmark regeneration: + +```bash +cargo test --locked -p pallet-miner-aggregation --features runtime-benchmarks +cargo build --release --locked --features runtime-benchmarks +./target/release/quantus-node benchmark pallet \ + --chain dev \ + --pallet pallet_miner_aggregation \ + --extrinsic '*' \ + --steps 50 \ + --repeat 20 \ + --output pallets/miner-aggregation/src/weights.rs +``` + +Known benchmark blocker: the checked-in L1 settlement fixture is configured for one layer-0 proof, +while the runtime currently configures `MinerAggregationNumLayer0Proofs = 2`. Either regenerate the +fixture for the runtime setting or run the valid L1 benchmark with `QP_GENERATE_LAYER1=true` and +`QP_NUM_LAYER0_PROOFS=1` before committing generated weights. + +ZK proving tests must use release mode: + +```bash +cargo test --release -p -- --nocapture +cargo run --release -p -- +``` + +Parser-only, storage-only, mock-runtime, and precomputed-proof fixture tests may run without +`--release`. + +Local E2E fixture command: + +```bash +./chain/scripts/e2e-delegated-l1-aggregation.sh +``` + +This command regenerates fixtures with release-mode proving, runs the release-mode chain settlement +fixture, runs the miner worker state-machine test, and runs the miner real-prover fixture. The live +external-miner RPC adapter remains behind `AggregationChainClient` and is not exercised by this +fixture command. diff --git a/pallets/miner-aggregation/Cargo.toml b/pallets/miner-aggregation/Cargo.toml new file mode 100644 index 00000000..513e4bab --- /dev/null +++ b/pallets/miner-aggregation/Cargo.toml @@ -0,0 +1,55 @@ +[package] +authors.workspace = true +edition.workspace = true +homepage.workspace = true +license.workspace = true +name = "pallet-miner-aggregation" +repository.workspace = true +version = "0.1.0" + +[dependencies] +codec = { workspace = true, default-features = false, features = ["derive"] } +frame-benchmarking = { workspace = true, optional = true } +frame-support.workspace = true +frame-system.workspace = true +hex = { workspace = true, optional = true, features = ["alloc"] } +pallet-wormhole.workspace = true +qp-wormhole-verifier = { workspace = true, default-features = false } +scale-info = { workspace = true, default-features = false, features = ["derive"] } +sp-io.workspace = true +sp-runtime.workspace = true + +[dev-dependencies] +hex = { workspace = true, features = ["alloc"] } +pallet-assets = { workspace = true, features = ["std"] } +pallet-balances = { workspace = true, features = ["std"] } +pallet-zk-tree = { workspace = true, features = ["std"] } +qp-dilithium-crypto = { workspace = true, features = ["std"] } +qp-header = { workspace = true, features = ["serde"] } +qp-poseidon = { workspace = true, features = ["std"] } +qp-wormhole = { workspace = true, features = ["std"] } +sp-core.workspace = true +sp-state-machine.workspace = true + +[features] +default = ["std"] +runtime-benchmarks = [ + "dep:frame-benchmarking", + "dep:hex", + "frame-benchmarking/runtime-benchmarks", + "frame-support/runtime-benchmarks", + "frame-system/runtime-benchmarks", + "pallet-wormhole/runtime-benchmarks", +] +std = [ + "codec/std", + "frame-benchmarking?/std", + "frame-support/std", + "frame-system/std", + "hex?/std", + "pallet-wormhole/std", + "qp-wormhole-verifier/std", + "scale-info/std", + "sp-io/std", + "sp-runtime/std", +] diff --git a/pallets/miner-aggregation/README.md b/pallets/miner-aggregation/README.md new file mode 100644 index 00000000..46d1ed8c --- /dev/null +++ b/pallets/miner-aggregation/README.md @@ -0,0 +1,63 @@ +# Miner Aggregation Pallet + +MVP pallet for delegated Wormhole L1 aggregation. + +Current scope: + +- signed users submit bounded on-chain L0 aggregate proof candidates +- candidate submission parses public L0 metadata but does not verify the proof +- candidate submission does not lock or mark nullifiers +- compatible candidates are queued by `BundleGroupKey` +- submitter storage bond, validity bond, and aggregation tip are reserved +- aggregation miners register a reward address, job limit, and bond +- registered miners can claim a full compatible bundle +- bundle claim locks nullifiers through `pallet-wormhole` +- bundle timeout unlocks nullifiers and returns unexpired candidates to the queue +- L1 submission performs cheap public-input/effects checks before full L1 verification +- pending expired candidates can be cleaned up and refunded +- pending invalid candidates can be challenged and have their validity bond burned +- claimed invalid candidates can be challenged before L1 settlement + +Nullifier locking remains owned by `pallet-wormhole`. Bundle claim must call the wormhole lock +helpers; candidate submission must never lock nullifiers. + +Any test or command that generates ZK proofs must run with `--release`. The default pallet test +suite uses precomputed fixture proof bytes and does not generate proofs. + +MVP limitations: + +- L1 fixture regeneration must use `chain/scripts/generate-delegated-l1-fixture.sh`, which runs + proving in release mode. +- The local delegated aggregation E2E fixture can be run with + `./chain/scripts/e2e-delegated-l1-aggregation.sh` from the workspace root. +- The positive L1 settlement fixture test requires `QP_GENERATE_LAYER1=true` and + `QP_NUM_LAYER0_PROOFS=1` so `pallet-wormhole` embeds matching L1 verifier artifacts. +- `Bundle.bundle_root` remains metadata until the L1 circuit exposes a constrained public root. + +Weights: + +- `src/weights.rs` contains explicit conservative placeholder weights for every pallet extrinsic. +- `submit_l1_aggregate_cheap_reject` and `submit_l1_aggregate_valid_proof` are both recorded; the + dispatchable declares the valid-proof placeholder because it is the safe upper bound. +- Benchmark scaffolding lives in `src/benchmarking.rs` and is registered in + `runtime/src/benchmarks.rs`. +- These weights are not benchmark-generated and must be replaced with runtime benchmark output before release. + +Benchmark regeneration: + +```bash +cargo test --locked -p pallet-miner-aggregation --features runtime-benchmarks +cargo build --release --locked --features runtime-benchmarks +./target/release/quantus-node benchmark pallet \ + --chain dev \ + --pallet pallet_miner_aggregation \ + --extrinsic '*' \ + --steps 50 \ + --repeat 20 \ + --output pallets/miner-aggregation/src/weights.rs +``` + +The `submit_l1_aggregate_valid_proof` benchmark requires matching L1 verifier artifacts and the +current one-candidate L1 fixture. Run it with `QP_GENERATE_LAYER1=true` and +`QP_NUM_LAYER0_PROOFS=1`, or regenerate the fixture for the runtime's configured +`NumLayer0Proofs` before replacing `weights.rs`. diff --git a/pallets/miner-aggregation/src/benchmarking.rs b/pallets/miner-aggregation/src/benchmarking.rs new file mode 100644 index 00000000..085e6d0e --- /dev/null +++ b/pallets/miner-aggregation/src/benchmarking.rs @@ -0,0 +1,373 @@ +//! Benchmarking setup for pallet-miner-aggregation. + +extern crate alloc; + +use super::*; +use alloc::vec::Vec; +use codec::Decode; +use frame_benchmarking::v2::*; +use frame_support::{ + assert_noop, assert_ok, + traits::{Currency, Get}, +}; +use frame_system::{pallet_prelude::BlockNumberFor, RawOrigin}; +use qp_wormhole_verifier::parse_aggregated_public_inputs; +use sp_runtime::traits::{One, SaturatedConversion, Saturating}; + +const AGGREGATED_PROOF_HEX: &str = include_str!("../../wormhole/test-data/aggregated.hex"); +const L1_FIXTURE_L0_CANDIDATE_0_HEX: &str = include_str!("../test-data/l0_candidate_0.hex"); +const L1_FIXTURE_AGGREGATE_HEX: &str = include_str!("../test-data/l1_aggregate.hex"); + +fn balance(value: u128) -> BalanceOf { + value.saturated_into() +} + +fn proof_bytes() -> Vec { + hex::decode(AGGREGATED_PROOF_HEX.trim()).expect("valid aggregated proof hex") +} + +fn l1_fixture_l0_candidate_0_bytes() -> Vec { + hex::decode(L1_FIXTURE_L0_CANDIDATE_0_HEX.trim()).expect("valid L1 fixture L0 proof hex") +} + +fn l1_fixture_aggregate_bytes() -> Vec { + hex::decode(L1_FIXTURE_AGGREGATE_HEX.trim()).expect("valid L1 aggregate proof hex") +} + +fn fund(account: &T::AccountId) { + let amount = balance::(1_000_000_000_000_000_000); + let _ = ::Currency::deposit_creating(account, amount); +} + +fn setup_matching_block_hash(proof_bytes: &[u8]) { + let proof = pallet_wormhole::Pallet::::deserialize_aggregated_proof(proof_bytes) + .expect("proof deserializes"); + let inputs = parse_aggregated_public_inputs(&proof).expect("public inputs parse"); + let block_number = BlockNumberFor::::from(inputs.block_data.block_number); + let block_hash_bytes: [u8; 32] = + inputs.block_data.block_hash.as_ref().try_into().expect("digest is 32 bytes"); + let block_hash = ::Hash::decode(&mut &block_hash_bytes[..]) + .expect("runtime hash decodes from 32 bytes"); + frame_system::BlockHash::::insert(block_number, block_hash); +} + +fn invalid_l0_proof_bytes() -> Vec { + let valid_bytes = proof_bytes(); + setup_matching_block_hash::(&valid_bytes); + + for idx in (0..valid_bytes.len()).rev() { + let mut mutated = valid_bytes.clone(); + mutated[idx] ^= 1; + let Ok(proof) = pallet_wormhole::Pallet::::deserialize_aggregated_proof(&mutated) else { + continue; + }; + if pallet_wormhole::Pallet::::parse_aggregated_inputs_from_proof(&proof).is_err() { + continue; + } + if matches!( + pallet_wormhole::Pallet::::verify_aggregated_proof_for_candidate(&mutated), + Err(pallet_wormhole::Error::::AggregatedVerificationFailed) + ) { + return mutated; + } + } + + panic!("could not derive invalid proof bytes that still parse"); +} + +fn candidate_id_for(proof_bytes: &[u8]) -> CandidateId { + sp_io::hashing::blake2_256(proof_bytes) +} + +fn seed_candidate_queue( + submitter: &T::AccountId, + invalid_first: bool, +) -> (CandidateId, BundleGroupKey) { + fund::(submitter); + let proof_bytes = if invalid_first { invalid_l0_proof_bytes::() } else { proof_bytes() }; + setup_matching_block_hash::(&proof_bytes); + assert_ok!(Pallet::::submit_l0_candidate( + RawOrigin::Signed(submitter.clone()).into(), + proof_bytes.clone(), + balance::(1_000) + )); + + let first_id = candidate_id_for(&proof_bytes); + let first = L0Candidates::::get(first_id).expect("candidate stored"); + let group_key = first.group_key.clone(); + let required = T::NumLayer0Proofs::get().max(1) as usize; + + for index in 1usize..required { + let synthetic_id = sp_io::hashing::blake2_256(&index.to_le_bytes()); + let mut nullifiers = first.nullifiers.to_vec(); + for (nullifier_index, nullifier) in nullifiers.iter_mut().enumerate() { + *nullifier = [index as u8; 32]; + nullifier[31] = nullifier_index as u8; + } + let candidate = L0Candidate { + proof_hash: synthetic_id, + public_inputs_hash: [index as u8; 32], + group_key: first.group_key.clone(), + submitter: first.submitter.clone(), + submitted_at: first.submitted_at, + expires_at: first.expires_at, + proof_bytes: first.proof_bytes.to_vec().try_into().expect("proof bytes fit"), + nullifiers: nullifiers.try_into().expect("nullifiers fit"), + exit_summary: first.exit_summary.to_vec().try_into().expect("exit summary fits"), + aggregation_tip: first.aggregation_tip, + storage_bond: first.storage_bond, + validity_bond: first.validity_bond, + status: L0CandidateStatus::Pending, + }; + L0Candidates::::insert(synthetic_id, candidate); + PendingQueues::::try_mutate(&group_key, |queue| { + queue.try_push(synthetic_id).map_err(|_| Error::::QueueFull) + }) + .expect("synthetic candidate fits queue"); + } + + (first_id, group_key) +} + +fn register_benchmark_aggregator( + miner: &T::AccountId, + reward_address: [u8; 32], + max_active_jobs: u32, +) { + fund::(miner); + assert_ok!(Pallet::::register_aggregator( + RawOrigin::Signed(miner.clone()).into(), + reward_address, + max_active_jobs, + balance::(100_000) + )); +} + +fn setup_claimable_bundle( + invalid_first: bool, +) -> (T::AccountId, CandidateId, BundleGroupKey, [u8; 32]) { + let submitter: T::AccountId = account("submitter", 0, 0); + let miner: T::AccountId = account("miner", 0, 0); + let reward_address = [7u8; 32]; + let (candidate_id, group_key) = seed_candidate_queue::(&submitter, invalid_first); + register_benchmark_aggregator::( + &miner, + reward_address, + T::MaxActiveBundlesPerMiner::get().max(1), + ); + (miner, candidate_id, group_key, reward_address) +} + +fn claim_seeded_bundle(invalid_first: bool) -> (T::AccountId, CandidateId, BundleId) { + let (miner, candidate_id, group_key, reward_address) = + setup_claimable_bundle::(invalid_first); + assert_ok!(Pallet::::claim_bundle( + RawOrigin::Signed(miner.clone()).into(), + group_key, + reward_address, + T::MinMinerBond::get() + )); + let bundle_id = MinerActiveBundles::::get(&miner) + .first() + .copied() + .expect("active bundle recorded"); + (miner, candidate_id, bundle_id) +} + +#[benchmarks] +mod benchmarks { + use super::*; + + #[benchmark] + fn submit_l0_candidate() { + let submitter: T::AccountId = whitelisted_caller(); + fund::(&submitter); + let proof_bytes = proof_bytes(); + setup_matching_block_hash::(&proof_bytes); + let candidate_id = candidate_id_for(&proof_bytes); + + #[extrinsic_call] + _(RawOrigin::Signed(submitter.clone()), proof_bytes, balance::(1_000)); + + assert!(L0Candidates::::contains_key(candidate_id)); + } + + #[benchmark] + fn register_aggregator() { + let miner: T::AccountId = whitelisted_caller(); + fund::(&miner); + let reward_address = [7u8; 32]; + + #[extrinsic_call] + _(RawOrigin::Signed(miner.clone()), reward_address, 4, balance::(100_000)); + + assert!(RegisteredAggregators::::contains_key(miner)); + } + + #[benchmark] + fn update_aggregator() { + let miner: T::AccountId = whitelisted_caller(); + register_benchmark_aggregator::(&miner, [7u8; 32], 4); + let new_reward_address = [8u8; 32]; + + #[extrinsic_call] + _(RawOrigin::Signed(miner.clone()), new_reward_address, 2, balance::(50_000)); + + assert_eq!( + RegisteredAggregators::::get(miner) + .expect("aggregator stored") + .reward_address, + new_reward_address + ); + } + + #[benchmark] + fn unregister_aggregator() { + let miner: T::AccountId = whitelisted_caller(); + register_benchmark_aggregator::(&miner, [7u8; 32], 4); + + #[extrinsic_call] + _(RawOrigin::Signed(miner.clone())); + + assert!(!RegisteredAggregators::::contains_key(miner)); + } + + #[benchmark] + fn claim_bundle() { + let (miner, candidate_id, group_key, reward_address) = setup_claimable_bundle::(false); + + #[extrinsic_call] + _(RawOrigin::Signed(miner.clone()), group_key, reward_address, T::MinMinerBond::get()); + + assert!(matches!( + L0Candidates::::get(candidate_id).expect("candidate stored").status, + L0CandidateStatus::Claimed { .. } + )); + } + + #[benchmark] + fn timeout_bundle() { + let (miner, _candidate_id, bundle_id) = claim_seeded_bundle::(false); + let bundle = Bundles::::get(bundle_id).expect("bundle stored"); + frame_system::Pallet::::set_block_number(bundle.deadline.saturating_add(One::one())); + + #[extrinsic_call] + _(RawOrigin::Signed(miner.clone()), bundle_id); + + assert!(MinerActiveBundles::::get(miner).is_empty()); + } + + #[benchmark] + fn submit_l1_aggregate_cheap_reject() { + let (miner, _candidate_id, bundle_id) = claim_seeded_bundle::(false); + + #[block] + { + assert_noop!( + Pallet::::submit_l1_aggregate( + RawOrigin::Signed(miner.clone()).into(), + bundle_id, + Vec::new() + ), + Error::::MalformedL1Proof + ); + } + } + + #[benchmark] + fn submit_l1_aggregate_valid_proof() { + assert_eq!(T::NumLayer0Proofs::get(), 1, "L1 fixture benchmark requires NumLayer0Proofs=1"); + assert!( + pallet_wormhole::get_layer1_verifier().is_ok(), + "L1 fixture benchmark requires QP_GENERATE_LAYER1=true" + ); + let submitter: T::AccountId = account("submitter", 0, 0); + let miner: T::AccountId = account("miner", 0, 0); + let reward_address = [7u8; 32]; + fund::(&submitter); + fund::(&miner); + let l0_proof_bytes = l1_fixture_l0_candidate_0_bytes(); + setup_matching_block_hash::(&l0_proof_bytes); + assert_ok!(Pallet::::submit_l0_candidate( + RawOrigin::Signed(submitter).into(), + l0_proof_bytes.clone(), + balance::(1_000) + )); + let candidate_id = candidate_id_for(&l0_proof_bytes); + let group_key = L0Candidates::::get(candidate_id).expect("candidate stored").group_key; + register_benchmark_aggregator::(&miner, reward_address, 1); + assert_ok!(Pallet::::claim_bundle( + RawOrigin::Signed(miner.clone()).into(), + group_key, + reward_address, + T::MinMinerBond::get() + )); + let bundle_id = MinerActiveBundles::::get(&miner) + .first() + .copied() + .expect("active bundle recorded"); + + #[block] + { + assert_ok!(Pallet::::submit_l1_aggregate( + RawOrigin::Signed(miner.clone()).into(), + bundle_id, + l1_fixture_aggregate_bytes() + )); + } + } + + #[benchmark] + fn challenge_invalid_l0_candidate() { + let submitter: T::AccountId = account("submitter", 0, 0); + let challenger: T::AccountId = whitelisted_caller(); + let (candidate_id, _group_key) = seed_candidate_queue::(&submitter, true); + fund::(&challenger); + + #[extrinsic_call] + _(RawOrigin::Signed(challenger), candidate_id); + + assert_eq!( + L0Candidates::::get(candidate_id).expect("candidate stored").status, + L0CandidateStatus::ChallengedInvalid + ); + } + + #[benchmark] + fn challenge_invalid_l0_in_bundle() { + let (miner, candidate_id, bundle_id) = claim_seeded_bundle::(true); + let challenger: T::AccountId = whitelisted_caller(); + fund::(&challenger); + + #[extrinsic_call] + _(RawOrigin::Signed(challenger), bundle_id, candidate_id); + + assert!(MinerActiveBundles::::get(miner).is_empty()); + assert_eq!( + L0Candidates::::get(candidate_id).expect("candidate stored").status, + L0CandidateStatus::ChallengedInvalid + ); + } + + #[benchmark] + fn drop_expired_candidate() { + let submitter: T::AccountId = account("submitter", 0, 0); + let caller: T::AccountId = whitelisted_caller(); + let (candidate_id, _group_key) = seed_candidate_queue::(&submitter, false); + fund::(&caller); + let candidate = L0Candidates::::get(candidate_id).expect("candidate stored"); + frame_system::Pallet::::set_block_number( + candidate.expires_at.saturating_add(One::one()), + ); + + #[extrinsic_call] + _(RawOrigin::Signed(caller), candidate_id); + + assert_eq!( + L0Candidates::::get(candidate_id).expect("candidate stored").status, + L0CandidateStatus::Expired + ); + } + + impl_benchmark_test_suite!(Pallet, crate::mock::new_test_ext(), crate::mock::Test); +} diff --git a/pallets/miner-aggregation/src/lib.rs b/pallets/miner-aggregation/src/lib.rs new file mode 100644 index 00000000..d65b9f49 --- /dev/null +++ b/pallets/miner-aggregation/src/lib.rs @@ -0,0 +1,1502 @@ +#![cfg_attr(not(feature = "std"), no_std)] + +extern crate alloc; +pub use pallet::*; +pub mod weights; +pub use weights::*; + +#[cfg(feature = "runtime-benchmarks")] +mod benchmarking; +#[cfg(test)] +mod mock; +#[cfg(test)] +mod tests; + +#[frame_support::pallet] +pub mod pallet { + use crate::WeightInfo; + use alloc::vec::Vec; + use codec::{Decode, Encode}; + use frame_support::{ + pallet_prelude::*, + traits::{tokens::BalanceStatus, Currency, ReservableCurrency}, + transactional, BoundedVec, + }; + use frame_system::pallet_prelude::*; + use qp_wormhole_verifier::{ + AggregatedPublicCircuitInputs, BytesDigest, Layer1AggregatedPublicCircuitInputs, + PublicInputsByAccount, L0_AGGREGATED_PUBLIC_INPUT_LAYOUT_VERSION, + }; + use sp_runtime::{ + traits::{Saturating, Zero}, + Permill, + }; + + pub type CandidateId = [u8; 32]; + pub type BundleId = [u8; 32]; + pub type CircuitId = [u8; 32]; + pub type PublicInputsHash = [u8; 32]; + pub type Nullifier = [u8; 32]; + pub type BalanceOf = + <::Currency as Currency<::AccountId>>::Balance; + + #[derive( + Encode, + Decode, + DecodeWithMemTracking, + Clone, + PartialEq, + Eq, + RuntimeDebug, + TypeInfo, + MaxEncodedLen, + )] + pub enum L0CandidateStatus { + Pending, + Claimed { bundle_id: BundleId }, + Settled { bundle_id: BundleId }, + Dropped, + Expired, + ChallengedInvalid, + } + + #[derive( + Encode, + Decode, + DecodeWithMemTracking, + Clone, + PartialEq, + Eq, + RuntimeDebug, + TypeInfo, + MaxEncodedLen, + )] + pub enum BundleStatus { + Claimed, + Proving, + Submitted, + Settled, + Expired, + Challenged, + Reassigned, + } + + #[derive( + Encode, + Decode, + DecodeWithMemTracking, + Clone, + PartialEq, + Eq, + RuntimeDebug, + TypeInfo, + MaxEncodedLen, + )] + pub struct BundleGroupKey { + pub circuit_id: CircuitId, + pub public_input_layout_version: u32, + pub num_leaf_proofs: u32, + pub num_layer0_proofs: u32, + pub asset_id: u32, + pub volume_fee_bps: u32, + pub block_hash: [u8; 32], + pub block_number: u32, + } + + #[derive( + Encode, + Decode, + DecodeWithMemTracking, + Clone, + PartialEq, + Eq, + RuntimeDebug, + TypeInfo, + MaxEncodedLen, + )] + pub struct ExitSlotSummary { + pub summed_output_amount: u32, + pub exit_account: [u8; 32], + } + + #[derive( + Encode, + Decode, + DecodeWithMemTracking, + Clone, + PartialEq, + Eq, + RuntimeDebug, + TypeInfo, + MaxEncodedLen, + )] + #[scale_info(skip_type_params(MaxProofBytes, MaxNullifiers, MaxExitSlots))] + pub struct L0Candidate< + AccountId, + BlockNumber, + Balance, + MaxProofBytes, + MaxNullifiers, + MaxExitSlots, + > + where + MaxProofBytes: Get, + MaxNullifiers: Get, + MaxExitSlots: Get, + { + pub proof_hash: CandidateId, + pub public_inputs_hash: PublicInputsHash, + pub group_key: BundleGroupKey, + pub submitter: AccountId, + pub submitted_at: BlockNumber, + pub expires_at: BlockNumber, + pub proof_bytes: BoundedVec, + pub nullifiers: BoundedVec, + pub exit_summary: BoundedVec, + pub aggregation_tip: Balance, + pub storage_bond: Balance, + pub validity_bond: Balance, + pub status: L0CandidateStatus, + } + + pub type CandidateOf = L0Candidate< + ::AccountId, + BlockNumberFor, + BalanceOf, + ::MaxL0ProofBytes, + ::MaxNullifiersPerL0, + ::MaxExitSlotsPerL0, + >; + + #[derive( + Encode, + Decode, + DecodeWithMemTracking, + Clone, + PartialEq, + Eq, + RuntimeDebug, + TypeInfo, + MaxEncodedLen, + )] + pub struct AggregatorInfo { + pub registered_at: BlockNumber, + pub reward_address: [u8; 32], + pub bond: Balance, + pub max_active_jobs: u32, + pub active_jobs: u32, + } + + #[derive( + Encode, + Decode, + DecodeWithMemTracking, + Clone, + PartialEq, + Eq, + RuntimeDebug, + TypeInfo, + MaxEncodedLen, + )] + #[scale_info(skip_type_params(MaxCandidates))] + pub struct Bundle + where + MaxCandidates: Get, + { + pub bundle_id: BundleId, + pub group_key: BundleGroupKey, + pub ordered_candidates: BoundedVec, + // Metadata only until the L1 circuit exposes a constrained bundle-root public input. + pub bundle_root: [u8; 32], + pub public_inputs_root: [u8; 32], + pub assigned_miner: AccountId, + pub aggregator_address: [u8; 32], + pub claimed_at: BlockNumber, + pub deadline: BlockNumber, + pub miner_bond: Balance, + pub reward_pot: Balance, + pub retry_count: u32, + pub status: BundleStatus, + } + + pub type BundleOf = Bundle< + ::AccountId, + BlockNumberFor, + BalanceOf, + ::MaxCandidatesPerQueue, + >; + + #[pallet::config] + pub trait Config: frame_system::Config + pallet_wormhole::Config { + type RuntimeEvent: From> + IsType<::RuntimeEvent>; + type Currency: ReservableCurrency< + Self::AccountId, + Balance = ::NativeBalance, + >; + + #[pallet::constant] + type MaxL0ProofBytes: Get; + + #[pallet::constant] + type MaxNullifiersPerL0: Get; + + #[pallet::constant] + type MaxExitSlotsPerL0: Get; + + #[pallet::constant] + type MaxCandidatesPerQueue: Get; + + #[pallet::constant] + type CandidateLifetime: Get>; + + #[pallet::constant] + type StorageBond: Get>; + + #[pallet::constant] + type ValidityBond: Get>; + + #[pallet::constant] + type NumLayer0Proofs: Get; + + #[pallet::constant] + type CircuitId: Get; + + #[pallet::constant] + type MaxActiveBundlesPerMiner: Get; + + #[pallet::constant] + type BundleProvingPeriod: Get>; + + #[pallet::constant] + type MinMinerBond: Get>; + + #[pallet::constant] + type MaxL1ProofBytes: Get; + + #[pallet::constant] + type MinerTimeoutSlash: Get; + + #[pallet::constant] + type InvalidL1ProofSlash: Get; + + #[pallet::constant] + type InvalidClaimSlash: Get; + + #[pallet::constant] + type InvalidCandidateChallengeReward: Get; + + type WeightInfo: WeightInfo; + } + + #[pallet::pallet] + pub struct Pallet(_); + + #[pallet::storage] + pub type L0Candidates = + StorageMap<_, Blake2_128Concat, CandidateId, CandidateOf, OptionQuery>; + + #[pallet::storage] + pub type PendingQueues = StorageMap< + _, + Blake2_128Concat, + BundleGroupKey, + BoundedVec, + ValueQuery, + >; + + #[pallet::storage] + pub type RegisteredAggregators = StorageMap< + _, + Blake2_128Concat, + T::AccountId, + AggregatorInfo, BalanceOf>, + OptionQuery, + >; + + #[pallet::storage] + pub type Bundles = + StorageMap<_, Blake2_128Concat, BundleId, BundleOf, OptionQuery>; + + #[pallet::storage] + pub type MinerActiveBundles = StorageMap< + _, + Blake2_128Concat, + T::AccountId, + BoundedVec, + ValueQuery, + >; + + #[pallet::event] + #[pallet::generate_deposit(pub(super) fn deposit_event)] + pub enum Event { + L0CandidateSubmitted { + candidate_id: CandidateId, + submitter: T::AccountId, + group_key: BundleGroupKey, + }, + AggregatorRegistered { + account: T::AccountId, + }, + AggregatorUpdated { + account: T::AccountId, + }, + AggregatorUnregistered { + account: T::AccountId, + }, + BundleClaimed { + bundle_id: BundleId, + miner: T::AccountId, + group_key: BundleGroupKey, + }, + BundleTimedOut { + bundle_id: BundleId, + }, + BundleSettled { + bundle_id: BundleId, + miner: T::AccountId, + }, + AggregationRewardPaid { + bundle_id: BundleId, + reward_account: T::AccountId, + tips_paid: BalanceOf, + fee_share_paid: BalanceOf, + }, + L0CandidateChallengedInvalid { + candidate_id: CandidateId, + challenger: T::AccountId, + }, + CandidateChallengeRewardPaid { + candidate_id: CandidateId, + challenger: T::AccountId, + reward: BalanceOf, + }, + BundleChallenged { + bundle_id: BundleId, + candidate_id: CandidateId, + challenger: T::AccountId, + }, + MinerBondSlashed { + bundle_id: BundleId, + miner: T::AccountId, + amount: BalanceOf, + }, + L1ProofRejected { + bundle_id: BundleId, + miner: T::AccountId, + slashed: BalanceOf, + }, + L0CandidateExpired { + candidate_id: CandidateId, + }, + } + + #[pallet::error] + pub enum Error { + ProofTooLarge, + MalformedPublicInputs, + UnsupportedCircuit, + UnsupportedLayoutVersion, + QueueFull, + DuplicateCandidate, + CandidateNotFound, + CandidateNotPending, + StaleBlockReference, + InvalidVolumeFeeRate, + NonNativeAssetNotSupported, + BondReservationFailed, + TooManyNullifiers, + TooManyExitSlots, + AggregatorNotRegistered, + TooManyActiveJobs, + InsufficientMinerBond, + InsufficientCandidates, + BundleNotFound, + BundleNotActive, + BundleExpired, + NotAssignedMiner, + BundleNotExpired, + DuplicateNullifier, + NullifierUnavailable, + ActiveBundleLimit, + ProofMismatch, + L1ProofTooLarge, + MalformedL1Proof, + MalformedL1PublicInputs, + L1ProofRejected, + RewardTransferFailed, + CandidateValid, + CandidateNotExpired, + ChallengeVerificationUnavailable, + InvalidRewardAddress, + AggregatorAddressMismatch, + AggregatorHasActiveJobs, + ActiveJobAccountingInconsistent, + CandidateNotInBundle, + } + + #[pallet::call] + impl Pallet { + #[pallet::call_index(0)] + #[pallet::weight(::WeightInfo::submit_l0_candidate())] + pub fn submit_l0_candidate( + origin: OriginFor, + proof_bytes: Vec, + aggregation_tip: BalanceOf, + ) -> DispatchResult { + let submitter = ensure_signed(origin)?; + ensure!( + proof_bytes.len() <= T::MaxL0ProofBytes::get() as usize, + Error::::ProofTooLarge + ); + + let candidate_id = sp_io::hashing::blake2_256(&proof_bytes); + ensure!(!L0Candidates::::contains_key(candidate_id), Error::::DuplicateCandidate); + + let proof = pallet_wormhole::Pallet::::deserialize_aggregated_proof(&proof_bytes) + .map_err(|_| Error::::MalformedPublicInputs)?; + let inputs = pallet_wormhole::Pallet::::parse_aggregated_inputs_from_proof(&proof) + .map_err(|_| Error::::MalformedPublicInputs)?; + + ensure!(inputs.asset_id == 0, Error::::NonNativeAssetNotSupported); + ensure!( + inputs.volume_fee_bps == ::VolumeFeeRateBps::get(), + Error::::InvalidVolumeFeeRate + ); + + let block_number = BlockNumberFor::::from(inputs.block_data.block_number); + let block_hash = frame_system::Pallet::::block_hash(block_number); + ensure!(block_hash != T::Hash::default(), Error::::StaleBlockReference); + ensure!( + block_hash.as_ref() == inputs.block_data.block_hash.as_ref(), + Error::::StaleBlockReference + ); + + let nullifiers = Self::bounded_nullifiers(&inputs)?; + let exit_summary = Self::bounded_exit_summary(&inputs)?; + let group_key = Self::group_key(&inputs)?; + let queue = PendingQueues::::get(&group_key); + ensure!(queue.len() < T::MaxCandidatesPerQueue::get() as usize, Error::::QueueFull); + + let proof_bytes: BoundedVec = + proof_bytes.try_into().map_err(|_| Error::::ProofTooLarge)?; + let public_inputs_hash = Self::public_inputs_hash(&inputs)?; + let submitted_at = frame_system::Pallet::::block_number(); + let expires_at = submitted_at.saturating_add(T::CandidateLifetime::get()); + let storage_bond = T::StorageBond::get(); + let validity_bond = T::ValidityBond::get(); + + Self::reserve_candidate_funds( + &submitter, + storage_bond, + validity_bond, + aggregation_tip, + )?; + + let candidate = L0Candidate { + proof_hash: candidate_id, + public_inputs_hash, + group_key: group_key.clone(), + submitter: submitter.clone(), + submitted_at, + expires_at, + proof_bytes, + nullifiers, + exit_summary, + aggregation_tip, + storage_bond, + validity_bond, + status: L0CandidateStatus::Pending, + }; + + L0Candidates::::insert(candidate_id, candidate); + PendingQueues::::try_mutate(&group_key, |queue| { + queue.try_push(candidate_id).map_err(|_| Error::::QueueFull) + })?; + + Self::deposit_event(Event::L0CandidateSubmitted { candidate_id, submitter, group_key }); + + Ok(()) + } + + #[pallet::call_index(1)] + #[pallet::weight(::WeightInfo::register_aggregator())] + #[transactional] + pub fn register_aggregator( + origin: OriginFor, + reward_address: [u8; 32], + max_active_jobs: u32, + bond: BalanceOf, + ) -> DispatchResult { + let account = ensure_signed(origin)?; + Self::set_aggregator_registration( + &account, + reward_address, + max_active_jobs, + bond, + true, + )?; + Ok(()) + } + + #[pallet::call_index(2)] + #[pallet::weight(::WeightInfo::claim_bundle())] + #[transactional] + pub fn claim_bundle( + origin: OriginFor, + group_key: BundleGroupKey, + aggregator_address: [u8; 32], + miner_bond: BalanceOf, + ) -> DispatchResult { + let miner = ensure_signed(origin)?; + ensure!(miner_bond >= T::MinMinerBond::get(), Error::::InsufficientMinerBond); + + let mut info = RegisteredAggregators::::get(&miner) + .ok_or(Error::::AggregatorNotRegistered)?; + ensure!( + aggregator_address == info.reward_address, + Error::::AggregatorAddressMismatch + ); + ensure!(info.active_jobs < info.max_active_jobs, Error::::TooManyActiveJobs); + ensure!( + MinerActiveBundles::::get(&miner).len() < + T::MaxActiveBundlesPerMiner::get() as usize, + Error::::ActiveBundleLimit + ); + ensure!(group_key.circuit_id == T::CircuitId::get(), Error::::UnsupportedCircuit); + ensure!( + group_key.public_input_layout_version == L0_AGGREGATED_PUBLIC_INPUT_LAYOUT_VERSION, + Error::::UnsupportedLayoutVersion + ); + ensure!( + group_key.num_layer0_proofs == T::NumLayer0Proofs::get(), + Error::::UnsupportedCircuit + ); + + let selected = Self::select_bundle_candidates(&group_key)?; + let nullifiers = Self::candidate_nullifiers(&selected)?; + pallet_wormhole::Pallet::::ensure_no_duplicate_nullifiers(&nullifiers) + .map_err(|_| Error::::DuplicateNullifier)?; + + let public_inputs_root = Self::public_inputs_root(&selected)?; + let bundle_root = Self::bundle_root(&group_key, &selected, public_inputs_root); + let claimed_at = frame_system::Pallet::::block_number(); + let deadline = claimed_at.saturating_add(T::BundleProvingPeriod::get()); + let bundle_id = Self::bundle_id(&miner, &group_key, &selected, claimed_at); + + ::Currency::reserve(&miner, miner_bond) + .map_err(|_| Error::::BondReservationFailed)?; + if let Err(_err) = pallet_wormhole::Pallet::::lock_nullifiers_for_bundle( + bundle_id, + deadline, + &nullifiers, + ) { + ::Currency::unreserve(&miner, miner_bond); + return Err(Error::::NullifierUnavailable.into()); + } + + Self::remove_selected_from_queue(&group_key, &selected)?; + for candidate_id in &selected { + L0Candidates::::try_mutate(candidate_id, |candidate| -> DispatchResult { + let candidate = candidate.as_mut().ok_or(Error::::CandidateNotFound)?; + ensure!( + candidate.status == L0CandidateStatus::Pending, + Error::::CandidateNotPending + ); + candidate.status = L0CandidateStatus::Claimed { bundle_id }; + Ok(()) + })?; + } + + let ordered_candidates: BoundedVec = + selected.clone().try_into().map_err(|_| Error::::InsufficientCandidates)?; + let bundle = Bundle { + bundle_id, + group_key: group_key.clone(), + ordered_candidates, + bundle_root, + public_inputs_root, + assigned_miner: miner.clone(), + aggregator_address: info.reward_address, + claimed_at, + deadline, + miner_bond, + reward_pot: BalanceOf::::zero(), + retry_count: 0, + status: BundleStatus::Claimed, + }; + + Bundles::::insert(bundle_id, bundle); + MinerActiveBundles::::try_mutate(&miner, |active| { + active.try_push(bundle_id).map_err(|_| Error::::ActiveBundleLimit) + })?; + info.active_jobs = info.active_jobs.saturating_add(1); + RegisteredAggregators::::insert(&miner, info); + Self::ensure_aggregator_active_jobs_consistent(&miner)?; + + Self::deposit_event(Event::BundleClaimed { bundle_id, miner, group_key }); + Ok(()) + } + + #[pallet::call_index(3)] + #[pallet::weight(::WeightInfo::timeout_bundle())] + #[transactional] + pub fn timeout_bundle(origin: OriginFor, bundle_id: BundleId) -> DispatchResult { + let _who = ensure_signed(origin)?; + let mut bundle = Bundles::::get(bundle_id).ok_or(Error::::BundleNotFound)?; + ensure!( + matches!(bundle.status, BundleStatus::Claimed | BundleStatus::Proving), + Error::::BundleNotActive + ); + let now = frame_system::Pallet::::block_number(); + ensure!(now > bundle.deadline, Error::::BundleNotExpired); + + let candidate_ids = bundle.ordered_candidates.to_vec(); + let nullifiers = Self::candidate_nullifiers(&candidate_ids)?; + pallet_wormhole::Pallet::::unlock_nullifiers_for_bundle(bundle_id, &nullifiers) + .map_err(|_| Error::::NullifierUnavailable)?; + + for candidate_id in &candidate_ids { + L0Candidates::::try_mutate(candidate_id, |candidate| -> DispatchResult { + let candidate = candidate.as_mut().ok_or(Error::::CandidateNotFound)?; + candidate.status = if now > candidate.expires_at { + Self::refund_candidate_reserves(candidate); + L0CandidateStatus::Expired + } else { + L0CandidateStatus::Pending + }; + Ok(()) + })?; + } + Self::return_unexpired_candidates_to_queue(&bundle.group_key, &candidate_ids, now)?; + let assigned_miner = bundle.assigned_miner.clone(); + let timeout_slash = Self::release_miner_bond_with_slash( + bundle_id, + &assigned_miner, + bundle.miner_bond, + T::MinerTimeoutSlash::get(), + )?; + Self::remove_active_bundle(&assigned_miner, bundle_id); + Self::decrement_active_jobs(&assigned_miner); + Self::ensure_aggregator_active_jobs_consistent(&assigned_miner)?; + bundle.miner_bond = BalanceOf::::zero(); + bundle.status = BundleStatus::Expired; + Bundles::::insert(bundle_id, bundle); + + if !timeout_slash.is_zero() { + Self::deposit_event(Event::MinerBondSlashed { + bundle_id, + miner: assigned_miner, + amount: timeout_slash, + }); + } + Self::deposit_event(Event::BundleTimedOut { bundle_id }); + Ok(()) + } + + #[pallet::call_index(4)] + #[pallet::weight(::WeightInfo::submit_l1_aggregate())] + #[transactional] + pub fn submit_l1_aggregate( + origin: OriginFor, + bundle_id: BundleId, + proof_bytes: Vec, + ) -> DispatchResult { + let submitter = ensure_signed(origin)?; + ensure!( + proof_bytes.len() <= T::MaxL1ProofBytes::get() as usize, + Error::::L1ProofTooLarge + ); + let mut bundle = Bundles::::get(bundle_id).ok_or(Error::::BundleNotFound)?; + ensure!(submitter == bundle.assigned_miner, Error::::NotAssignedMiner); + ensure!( + matches!(bundle.status, BundleStatus::Claimed | BundleStatus::Proving), + Error::::BundleNotActive + ); + let now = frame_system::Pallet::::block_number(); + ensure!(now <= bundle.deadline, Error::::BundleExpired); + + let proof = pallet_wormhole::Pallet::::deserialize_layer1_proof(&proof_bytes) + .map_err(|_| Error::::MalformedL1Proof)?; + let inputs = pallet_wormhole::Pallet::::parse_layer1_inputs_from_proof(&proof) + .map_err(|_| Error::::MalformedL1PublicInputs)?; + Self::ensure_l1_matches_bundle(&bundle, &inputs)?; + if pallet_wormhole::Pallet::::verify_layer1_proof(&proof).is_err() { + let slashed = Self::record_invalid_l1_verification_failure(bundle_id, &mut bundle)?; + Bundles::::insert(bundle_id, bundle); + Self::deposit_event(Event::L1ProofRejected { + bundle_id, + miner: submitter, + slashed, + }); + return Ok(()); + } + + let nullifiers = Self::layer1_nullifier_bytes(&inputs)?; + Self::settle_verified_l1_bundle( + bundle_id, + bundle, + nullifiers, + &inputs.account_data, + inputs.volume_fee_bps, + ) + } + + #[pallet::call_index(5)] + #[pallet::weight(::WeightInfo::challenge_invalid_l0_candidate())] + #[transactional] + pub fn challenge_invalid_l0_candidate( + origin: OriginFor, + candidate_id: CandidateId, + ) -> DispatchResult { + let challenger = ensure_signed(origin)?; + let candidate = + L0Candidates::::get(candidate_id).ok_or(Error::::CandidateNotFound)?; + ensure!( + candidate.status == L0CandidateStatus::Pending, + Error::::CandidateNotPending + ); + + Self::ensure_l0_candidate_invalid(&candidate)?; + + Self::remove_selected_from_queue(&candidate.group_key, &[candidate_id])?; + Self::refund_candidate_storage_and_tip(&candidate); + let reward = Self::slash_candidate_validity_bond(&candidate, &challenger)?; + L0Candidates::::mutate(candidate_id, |stored| { + if let Some(stored) = stored { + stored.status = L0CandidateStatus::ChallengedInvalid; + } + }); + + if !reward.is_zero() { + Self::deposit_event(Event::CandidateChallengeRewardPaid { + candidate_id, + challenger: challenger.clone(), + reward, + }); + } + Self::deposit_event(Event::L0CandidateChallengedInvalid { candidate_id, challenger }); + Ok(()) + } + + #[pallet::call_index(9)] + #[pallet::weight(::WeightInfo::challenge_invalid_l0_in_bundle())] + #[transactional] + pub fn challenge_invalid_l0_in_bundle( + origin: OriginFor, + bundle_id: BundleId, + candidate_id: CandidateId, + ) -> DispatchResult { + let challenger = ensure_signed(origin)?; + let mut bundle = Bundles::::get(bundle_id).ok_or(Error::::BundleNotFound)?; + ensure!( + matches!(bundle.status, BundleStatus::Claimed | BundleStatus::Proving), + Error::::BundleNotActive + ); + ensure!( + bundle.ordered_candidates.contains(&candidate_id), + Error::::CandidateNotInBundle + ); + let challenged_candidate = + L0Candidates::::get(candidate_id).ok_or(Error::::CandidateNotFound)?; + ensure!( + matches!( + challenged_candidate.status, + L0CandidateStatus::Claimed { bundle_id: claimed_bundle } + if claimed_bundle == bundle_id + ), + Error::::CandidateNotInBundle + ); + Self::ensure_l0_candidate_invalid(&challenged_candidate)?; + + let candidate_ids = bundle.ordered_candidates.to_vec(); + let nullifiers = Self::candidate_nullifiers(&candidate_ids)?; + pallet_wormhole::Pallet::::unlock_nullifiers_for_bundle(bundle_id, &nullifiers) + .map_err(|_| Error::::NullifierUnavailable)?; + + let now = frame_system::Pallet::::block_number(); + let reward = Self::slash_candidate_validity_bond(&challenged_candidate, &challenger)?; + Self::refund_candidate_storage_and_tip(&challenged_candidate); + + for candidate_id_in_bundle in &candidate_ids { + L0Candidates::::try_mutate( + candidate_id_in_bundle, + |candidate| -> DispatchResult { + let candidate = candidate.as_mut().ok_or(Error::::CandidateNotFound)?; + if *candidate_id_in_bundle == candidate_id { + candidate.status = L0CandidateStatus::ChallengedInvalid; + } else if now > candidate.expires_at { + Self::refund_candidate_reserves(candidate); + candidate.status = L0CandidateStatus::Expired; + } else { + candidate.status = L0CandidateStatus::Pending; + } + Ok(()) + }, + )?; + } + Self::return_unexpired_candidates_to_queue(&bundle.group_key, &candidate_ids, now)?; + + let assigned_miner = bundle.assigned_miner.clone(); + let miner_slash = Self::release_miner_bond_with_slash( + bundle_id, + &assigned_miner, + bundle.miner_bond, + T::InvalidClaimSlash::get(), + )?; + Self::remove_active_bundle(&assigned_miner, bundle_id); + Self::decrement_active_jobs(&assigned_miner); + Self::ensure_aggregator_active_jobs_consistent(&assigned_miner)?; + bundle.miner_bond = BalanceOf::::zero(); + bundle.status = BundleStatus::Challenged; + Bundles::::insert(bundle_id, bundle); + + if !reward.is_zero() { + Self::deposit_event(Event::CandidateChallengeRewardPaid { + candidate_id, + challenger: challenger.clone(), + reward, + }); + } + if !miner_slash.is_zero() { + Self::deposit_event(Event::MinerBondSlashed { + bundle_id, + miner: assigned_miner, + amount: miner_slash, + }); + } + Self::deposit_event(Event::BundleChallenged { + bundle_id, + candidate_id, + challenger: challenger.clone(), + }); + Self::deposit_event(Event::L0CandidateChallengedInvalid { candidate_id, challenger }); + Ok(()) + } + + #[pallet::call_index(6)] + #[pallet::weight(::WeightInfo::drop_expired_candidate())] + #[transactional] + pub fn drop_expired_candidate( + origin: OriginFor, + candidate_id: CandidateId, + ) -> DispatchResult { + let _who = ensure_signed(origin)?; + let mut candidate = + L0Candidates::::get(candidate_id).ok_or(Error::::CandidateNotFound)?; + ensure!( + candidate.status == L0CandidateStatus::Pending, + Error::::CandidateNotPending + ); + let now = frame_system::Pallet::::block_number(); + ensure!(now > candidate.expires_at, Error::::CandidateNotExpired); + + Self::remove_selected_from_queue(&candidate.group_key, &[candidate_id])?; + Self::refund_candidate_reserves(&candidate); + candidate.status = L0CandidateStatus::Expired; + L0Candidates::::insert(candidate_id, candidate); + + Self::deposit_event(Event::L0CandidateExpired { candidate_id }); + Ok(()) + } + + #[pallet::call_index(7)] + #[pallet::weight(::WeightInfo::update_aggregator())] + #[transactional] + pub fn update_aggregator( + origin: OriginFor, + reward_address: [u8; 32], + max_active_jobs: u32, + new_bond: BalanceOf, + ) -> DispatchResult { + let account = ensure_signed(origin)?; + Self::set_aggregator_registration( + &account, + reward_address, + max_active_jobs, + new_bond, + false, + )?; + Ok(()) + } + + #[pallet::call_index(8)] + #[pallet::weight(::WeightInfo::unregister_aggregator())] + #[transactional] + pub fn unregister_aggregator(origin: OriginFor) -> DispatchResult { + let account = ensure_signed(origin)?; + let info = RegisteredAggregators::::get(&account) + .ok_or(Error::::AggregatorNotRegistered)?; + Self::ensure_aggregator_has_no_active_jobs(&account)?; + if !info.bond.is_zero() { + ::Currency::unreserve(&account, info.bond); + } + RegisteredAggregators::::remove(&account); + Self::ensure_aggregator_active_jobs_consistent(&account)?; + Self::deposit_event(Event::AggregatorUnregistered { account }); + Ok(()) + } + } + + impl Pallet { + fn set_aggregator_registration( + account: &T::AccountId, + reward_address: [u8; 32], + max_active_jobs: u32, + bond: BalanceOf, + allow_create: bool, + ) -> DispatchResult { + Self::decode_registered_reward_address(&reward_address)?; + match RegisteredAggregators::::get(account) { + Some(info) => { + Self::ensure_aggregator_has_no_active_jobs(account)?; + Self::adjust_aggregator_bond(account, info.bond, bond)?; + RegisteredAggregators::::insert( + account, + AggregatorInfo { + registered_at: info.registered_at, + reward_address, + bond, + max_active_jobs, + active_jobs: 0, + }, + ); + Self::ensure_aggregator_active_jobs_consistent(account)?; + Self::deposit_event(Event::AggregatorUpdated { account: account.clone() }); + }, + None => { + ensure!(allow_create, Error::::AggregatorNotRegistered); + Self::ensure_aggregator_has_no_active_jobs(account)?; + Self::adjust_aggregator_bond(account, BalanceOf::::zero(), bond)?; + RegisteredAggregators::::insert( + account, + AggregatorInfo { + registered_at: frame_system::Pallet::::block_number(), + reward_address, + bond, + max_active_jobs, + active_jobs: 0, + }, + ); + Self::ensure_aggregator_active_jobs_consistent(account)?; + Self::deposit_event(Event::AggregatorRegistered { account: account.clone() }); + }, + } + Ok(()) + } + + fn adjust_aggregator_bond( + account: &T::AccountId, + old_bond: BalanceOf, + new_bond: BalanceOf, + ) -> Result<(), Error> { + if new_bond > old_bond { + let additional = new_bond.saturating_sub(old_bond); + if !additional.is_zero() { + ::Currency::reserve(account, additional) + .map_err(|_| Error::::BondReservationFailed)?; + } + } else if old_bond > new_bond { + let release = old_bond.saturating_sub(new_bond); + if !release.is_zero() { + ::Currency::unreserve(account, release); + } + } + Ok(()) + } + + fn ensure_aggregator_has_no_active_jobs(account: &T::AccountId) -> DispatchResult { + if let Some(info) = RegisteredAggregators::::get(account) { + ensure!(info.active_jobs == 0, Error::::AggregatorHasActiveJobs); + } + ensure!( + MinerActiveBundles::::get(account).is_empty(), + Error::::AggregatorHasActiveJobs + ); + Ok(()) + } + + pub(crate) fn ensure_aggregator_active_jobs_consistent( + account: &T::AccountId, + ) -> Result<(), Error> { + let active_bundle_count = MinerActiveBundles::::get(account).len() as u32; + if let Some(info) = RegisteredAggregators::::get(account) { + ensure!( + info.active_jobs == active_bundle_count, + Error::::ActiveJobAccountingInconsistent + ); + } else { + ensure!(active_bundle_count == 0, Error::::ActiveJobAccountingInconsistent); + } + Ok(()) + } + + fn ensure_l0_candidate_invalid(candidate: &CandidateOf) -> DispatchResult { + match pallet_wormhole::Pallet::::verify_aggregated_proof_for_candidate( + candidate.proof_bytes.as_slice(), + ) { + Ok(_) => Err(Error::::CandidateValid.into()), + Err(pallet_wormhole::Error::::AggregatedVerificationFailed) => Ok(()), + Err(_) => Err(Error::::ChallengeVerificationUnavailable.into()), + } + } + + fn slash_candidate_validity_bond( + candidate: &CandidateOf, + challenger: &T::AccountId, + ) -> Result, Error> { + let reward = T::InvalidCandidateChallengeReward::get() * candidate.validity_bond; + if !reward.is_zero() { + let not_moved = ::Currency::repatriate_reserved( + &candidate.submitter, + challenger, + reward, + BalanceStatus::Free, + ) + .map_err(|_| Error::::RewardTransferFailed)?; + ensure!(not_moved.is_zero(), Error::::RewardTransferFailed); + } + + let slash_amount = candidate.validity_bond.saturating_sub(reward); + Self::slash_reserved_balance(&candidate.submitter, slash_amount)?; + Ok(reward) + } + + fn slash_reserved_balance( + who: &T::AccountId, + amount: BalanceOf, + ) -> Result<(), Error> { + if amount.is_zero() { + return Ok(()); + } + let (_slashed, remaining) = ::Currency::slash_reserved(who, amount); + ensure!(remaining.is_zero(), Error::::BondReservationFailed); + Ok(()) + } + + fn release_miner_bond_with_slash( + _bundle_id: BundleId, + miner: &T::AccountId, + miner_bond: BalanceOf, + slash_rate: Permill, + ) -> Result, Error> { + let slash_amount = slash_rate * miner_bond; + Self::slash_reserved_balance(miner, slash_amount)?; + let release_amount = miner_bond.saturating_sub(slash_amount); + if !release_amount.is_zero() { + ::Currency::unreserve(miner, release_amount); + } + Ok(slash_amount) + } + + pub(crate) fn record_invalid_l1_verification_failure( + bundle_id: BundleId, + bundle: &mut BundleOf, + ) -> Result, Error> { + let slash_amount = T::InvalidL1ProofSlash::get() * bundle.miner_bond; + Self::slash_reserved_balance(&bundle.assigned_miner, slash_amount)?; + bundle.miner_bond = bundle.miner_bond.saturating_sub(slash_amount); + if !slash_amount.is_zero() { + Self::deposit_event(Event::MinerBondSlashed { + bundle_id, + miner: bundle.assigned_miner.clone(), + amount: slash_amount, + }); + } + Ok(slash_amount) + } + + pub(crate) fn settle_verified_l1_bundle( + bundle_id: BundleId, + mut bundle: BundleOf, + nullifiers: Vec, + account_data: &[PublicInputsByAccount], + volume_fee_bps: u32, + ) -> DispatchResult { + let reward_account = Self::reward_account(&bundle)?; + let prepared = pallet_wormhole::Pallet::::prepare_public_output_settlement( + account_data, + volume_fee_bps, + pallet_wormhole::SettlementKind::DelegatedL1 { + aggregation_reward_account: reward_account.clone(), + }, + ) + .map_err(|_| Error::::ProofMismatch)?; + let fee_share_paid = prepared.aggregation_prover_fee; + pallet_wormhole::Pallet::::ensure_nullifiers_locked_by_bundle( + bundle_id, + &nullifiers, + ) + .map_err(|_| Error::::NullifierUnavailable)?; + + pallet_wormhole::Pallet::::apply_public_output_settlement(prepared) + .map_err(|_| Error::::ProofMismatch)?; + pallet_wormhole::Pallet::::mark_locked_nullifiers_used(bundle_id, &nullifiers) + .map_err(|_| Error::::NullifierUnavailable)?; + + let mut tips_paid = BalanceOf::::zero(); + for candidate_id in bundle.ordered_candidates.iter() { + L0Candidates::::try_mutate(candidate_id, |candidate| -> DispatchResult { + let candidate = candidate.as_mut().ok_or(Error::::CandidateNotFound)?; + tips_paid = tips_paid.saturating_add(candidate.aggregation_tip); + Self::release_candidate_reserves(candidate, &reward_account)?; + candidate.status = L0CandidateStatus::Settled { bundle_id }; + Ok(()) + })?; + } + + ::Currency::unreserve(&bundle.assigned_miner, bundle.miner_bond); + Self::remove_active_bundle(&bundle.assigned_miner, bundle_id); + Self::decrement_active_jobs(&bundle.assigned_miner); + Self::ensure_aggregator_active_jobs_consistent(&bundle.assigned_miner)?; + let settled_miner = bundle.assigned_miner.clone(); + bundle.status = BundleStatus::Settled; + Bundles::::insert(bundle_id, bundle); + Self::deposit_event(Event::AggregationRewardPaid { + bundle_id, + reward_account, + tips_paid, + fee_share_paid, + }); + Self::deposit_event(Event::BundleSettled { bundle_id, miner: settled_miner }); + Ok(()) + } + + fn reserve_candidate_funds( + submitter: &T::AccountId, + storage_bond: BalanceOf, + validity_bond: BalanceOf, + aggregation_tip: BalanceOf, + ) -> Result<(), Error> { + ::Currency::reserve(submitter, storage_bond) + .map_err(|_| Error::::BondReservationFailed)?; + if let Err(_err) = ::Currency::reserve(submitter, validity_bond) { + ::Currency::unreserve(submitter, storage_bond); + return Err(Error::::BondReservationFailed); + } + if let Err(_err) = ::Currency::reserve(submitter, aggregation_tip) { + ::Currency::unreserve(submitter, storage_bond); + ::Currency::unreserve(submitter, validity_bond); + return Err(Error::::BondReservationFailed); + } + Ok(()) + } + + fn release_candidate_reserves( + candidate: &CandidateOf, + reward_account: &T::AccountId, + ) -> Result<(), Error> { + Self::refund_candidate_bonds(candidate); + if !candidate.aggregation_tip.is_zero() { + ::Currency::unreserve(&candidate.submitter, candidate.aggregation_tip); + ::Currency::transfer( + &candidate.submitter, + reward_account, + candidate.aggregation_tip, + frame_support::traits::ExistenceRequirement::AllowDeath, + ) + .map_err(|_| Error::::RewardTransferFailed)?; + } + Ok(()) + } + + fn refund_candidate_reserves(candidate: &CandidateOf) { + Self::refund_candidate_bonds(candidate); + Self::refund_candidate_tip(candidate); + } + + fn refund_candidate_storage_and_tip(candidate: &CandidateOf) { + ::Currency::unreserve(&candidate.submitter, candidate.storage_bond); + Self::refund_candidate_tip(candidate); + } + + fn refund_candidate_bonds(candidate: &CandidateOf) { + ::Currency::unreserve(&candidate.submitter, candidate.storage_bond); + ::Currency::unreserve(&candidate.submitter, candidate.validity_bond); + } + + fn refund_candidate_tip(candidate: &CandidateOf) { + if !candidate.aggregation_tip.is_zero() { + ::Currency::unreserve(&candidate.submitter, candidate.aggregation_tip); + } + } + + fn select_bundle_candidates( + group_key: &BundleGroupKey, + ) -> Result, Error> { + let now = frame_system::Pallet::::block_number(); + let mut selected = Vec::new(); + for candidate_id in PendingQueues::::get(group_key) { + let Some(candidate) = L0Candidates::::get(candidate_id) else { + continue; + }; + if candidate.status != L0CandidateStatus::Pending || + candidate.group_key != *group_key || + now > candidate.expires_at + { + continue; + } + selected.push(candidate_id); + if selected.len() == T::NumLayer0Proofs::get() as usize { + break; + } + } + ensure!( + selected.len() == T::NumLayer0Proofs::get() as usize, + Error::::InsufficientCandidates + ); + Ok(selected) + } + + fn remove_selected_from_queue( + group_key: &BundleGroupKey, + selected: &[CandidateId], + ) -> DispatchResult { + let mut retained = BoundedVec::::new(); + for candidate_id in PendingQueues::::get(group_key) { + if selected.contains(&candidate_id) { + continue; + } + retained.try_push(candidate_id).map_err(|_| Error::::QueueFull)?; + } + PendingQueues::::insert(group_key, retained); + Ok(()) + } + + fn return_unexpired_candidates_to_queue( + group_key: &BundleGroupKey, + candidate_ids: &[CandidateId], + now: BlockNumberFor, + ) -> DispatchResult { + PendingQueues::::try_mutate(group_key, |queue| -> DispatchResult { + for candidate_id in candidate_ids { + let Some(candidate) = L0Candidates::::get(candidate_id) else { + continue; + }; + if now <= candidate.expires_at && candidate.status == L0CandidateStatus::Pending + { + queue.try_push(*candidate_id).map_err(|_| Error::::QueueFull)?; + } + } + Ok(()) + }) + } + + fn candidate_nullifiers(candidate_ids: &[CandidateId]) -> Result, Error> { + let mut out = Vec::new(); + for candidate_id in candidate_ids { + let candidate = + L0Candidates::::get(candidate_id).ok_or(Error::::CandidateNotFound)?; + out.extend(candidate.nullifiers.iter().copied()); + } + Ok(out) + } + + fn expected_exit_summary( + candidate_ids: &[CandidateId], + ) -> Result, Error> { + let mut out = Vec::new(); + for candidate_id in candidate_ids { + let candidate = + L0Candidates::::get(candidate_id).ok_or(Error::::CandidateNotFound)?; + out.extend(candidate.exit_summary.iter().cloned()); + } + Ok(out) + } + + fn public_inputs_root(candidate_ids: &[CandidateId]) -> Result<[u8; 32], Error> { + let mut bytes = Vec::new(); + for candidate_id in candidate_ids { + let candidate = + L0Candidates::::get(candidate_id).ok_or(Error::::CandidateNotFound)?; + bytes.extend_from_slice(&candidate.public_inputs_hash); + } + Ok(sp_io::hashing::blake2_256(&bytes)) + } + + fn bundle_root( + group_key: &BundleGroupKey, + candidate_ids: &[CandidateId], + public_inputs_root: [u8; 32], + ) -> [u8; 32] { + let mut bytes = b"quantus:wormhole:l1-bundle:v1".to_vec(); + bytes.extend_from_slice(&group_key.encode()); + bytes.extend_from_slice(&public_inputs_root); + for candidate_id in candidate_ids { + bytes.extend_from_slice(candidate_id); + } + sp_io::hashing::blake2_256(&bytes) + } + + fn bundle_id( + miner: &T::AccountId, + group_key: &BundleGroupKey, + candidate_ids: &[CandidateId], + claimed_at: BlockNumberFor, + ) -> BundleId { + let mut bytes = b"quantus:wormhole:l1-bundle-id:v1".to_vec(); + bytes.extend_from_slice(&miner.encode()); + bytes.extend_from_slice(&group_key.encode()); + bytes.extend_from_slice(&claimed_at.encode()); + for candidate_id in candidate_ids { + bytes.extend_from_slice(candidate_id); + } + sp_io::hashing::blake2_256(&bytes) + } + + fn layer1_nullifier_bytes( + inputs: &Layer1AggregatedPublicCircuitInputs, + ) -> Result, Error> { + inputs + .nullifiers + .iter() + .map(Self::digest_to_bytes) + .collect::, _>>() + } + + pub(crate) fn ensure_l1_matches_bundle( + bundle: &BundleOf, + inputs: &Layer1AggregatedPublicCircuitInputs, + ) -> Result<(), Error> { + // Bundle roots are not security-critical for the MVP: settlement validates the full + // public effects below until the L1 circuit exposes a constrained bundle root. + ensure!( + Self::digest_to_bytes(&inputs.aggregator_address)? == bundle.aggregator_address, + Error::::ProofMismatch + ); + ensure!(inputs.asset_id == bundle.group_key.asset_id, Error::::ProofMismatch); + ensure!( + inputs.volume_fee_bps == bundle.group_key.volume_fee_bps, + Error::::ProofMismatch + ); + ensure!( + Self::digest_to_bytes(&inputs.block_data.block_hash)? == + bundle.group_key.block_hash, + Error::::ProofMismatch + ); + ensure!( + inputs.block_data.block_number == bundle.group_key.block_number, + Error::::ProofMismatch + ); + + let candidate_ids = bundle.ordered_candidates.to_vec(); + let mut expected_nullifiers = Self::candidate_nullifiers(&candidate_ids)?; + let mut actual_nullifiers = Self::layer1_nullifier_bytes(inputs)?; + pallet_wormhole::Pallet::::ensure_no_duplicate_nullifiers(&actual_nullifiers) + .map_err(|_| Error::::DuplicateNullifier)?; + expected_nullifiers.sort(); + actual_nullifiers.sort(); + ensure!(expected_nullifiers == actual_nullifiers, Error::::ProofMismatch); + + let expected_exits = Self::expected_exit_summary(&candidate_ids)?; + ensure!( + inputs.total_exit_slots as usize == inputs.account_data.len(), + Error::::ProofMismatch + ); + ensure!(expected_exits.len() == inputs.account_data.len(), Error::::ProofMismatch); + for (expected, actual) in expected_exits.iter().zip(inputs.account_data.iter()) { + ensure!( + expected.summed_output_amount == actual.summed_output_amount, + Error::::ProofMismatch + ); + ensure!( + expected.exit_account == Self::digest_to_bytes(&actual.exit_account)?, + Error::::ProofMismatch + ); + } + Ok(()) + } + + fn decode_registered_reward_address( + reward_address: &[u8; 32], + ) -> Result> { + let account = T::AccountId::decode(&mut &reward_address[..]) + .map_err(|_| Error::::InvalidRewardAddress)?; + let encoded = account.encode(); + let encoded: [u8; 32] = + encoded.as_slice().try_into().map_err(|_| Error::::InvalidRewardAddress)?; + ensure!(encoded == *reward_address, Error::::InvalidRewardAddress); + Ok(account) + } + + fn reward_account(bundle: &BundleOf) -> Result> { + Self::decode_registered_reward_address(&bundle.aggregator_address) + } + + fn remove_active_bundle(miner: &T::AccountId, bundle_id: BundleId) { + MinerActiveBundles::::mutate(miner, |active| { + if let Some(pos) = active.iter().position(|id| *id == bundle_id) { + active.remove(pos); + } + }); + } + + fn decrement_active_jobs(miner: &T::AccountId) { + RegisteredAggregators::::mutate(miner, |info| { + if let Some(info) = info { + info.active_jobs = info.active_jobs.saturating_sub(1); + } + }); + } + + fn group_key(inputs: &AggregatedPublicCircuitInputs) -> Result> { + let block_hash = Self::digest_to_bytes(&inputs.block_data.block_hash)?; + Ok(BundleGroupKey { + circuit_id: T::CircuitId::get(), + public_input_layout_version: L0_AGGREGATED_PUBLIC_INPUT_LAYOUT_VERSION, + num_leaf_proofs: inputs.nullifiers.len() as u32, + num_layer0_proofs: T::NumLayer0Proofs::get(), + asset_id: inputs.asset_id, + volume_fee_bps: inputs.volume_fee_bps, + block_hash, + block_number: inputs.block_data.block_number, + }) + } + + fn bounded_nullifiers( + inputs: &AggregatedPublicCircuitInputs, + ) -> Result, Error> { + let mut out = BoundedVec::::new(); + for nullifier in &inputs.nullifiers { + out.try_push(Self::digest_to_bytes(nullifier)?) + .map_err(|_| Error::::TooManyNullifiers)?; + } + Ok(out) + } + + fn bounded_exit_summary( + inputs: &AggregatedPublicCircuitInputs, + ) -> Result, Error> { + let mut out = BoundedVec::::new(); + for exit in &inputs.account_data { + out.try_push(ExitSlotSummary { + summed_output_amount: exit.summed_output_amount, + exit_account: Self::digest_to_bytes(&exit.exit_account)?, + }) + .map_err(|_| Error::::TooManyExitSlots)?; + } + Ok(out) + } + + fn public_inputs_hash( + inputs: &AggregatedPublicCircuitInputs, + ) -> Result> { + let mut bytes = Vec::new(); + bytes.extend_from_slice(&inputs.asset_id.to_le_bytes()); + bytes.extend_from_slice(&inputs.volume_fee_bps.to_le_bytes()); + bytes.extend_from_slice(Self::digest_to_bytes(&inputs.block_data.block_hash)?.as_ref()); + bytes.extend_from_slice(&inputs.block_data.block_number.to_le_bytes()); + for exit in &inputs.account_data { + bytes.extend_from_slice(&exit.summed_output_amount.to_le_bytes()); + bytes.extend_from_slice(Self::digest_to_bytes(&exit.exit_account)?.as_ref()); + } + for nullifier in &inputs.nullifiers { + bytes.extend_from_slice(Self::digest_to_bytes(nullifier)?.as_ref()); + } + Ok(sp_io::hashing::blake2_256(&bytes)) + } + + fn digest_to_bytes(digest: &BytesDigest) -> Result<[u8; 32], Error> { + digest.as_ref().try_into().map_err(|_| Error::::MalformedPublicInputs) + } + } +} diff --git a/pallets/miner-aggregation/src/mock.rs b/pallets/miner-aggregation/src/mock.rs new file mode 100644 index 00000000..29cbdbb1 --- /dev/null +++ b/pallets/miner-aggregation/src/mock.rs @@ -0,0 +1,197 @@ +use crate as pallet_miner_aggregation; +use frame_support::{ + construct_runtime, parameter_types, + traits::{ConstU128, ConstU32, Everything}, +}; +use frame_system::mocking::MockUncheckedExtrinsic; +use qp_poseidon::PoseidonHasher; +use sp_core::H256; +use sp_runtime::{ + traits::{BlakeTwo256, IdentityLookup}, + BuildStorage, Permill, +}; + +pub use qp_wormhole::{account_id, MINTING_ACCOUNT}; + +construct_runtime!( + pub enum Test { + System: frame_system, + Balances: pallet_balances, + Assets: pallet_assets, + Wormhole: pallet_wormhole, + MinerAggregation: pallet_miner_aggregation, + } +); + +pub type Balance = u128; +pub const UNIT: Balance = 1_000_000_000_000; +pub type AccountId = sp_core::crypto::AccountId32; +pub type Block = sp_runtime::generic::Block< + qp_header::Header, + MockUncheckedExtrinsic, +>; + +parameter_types! { + pub const BlockHashCount: u64 = 250; +} + +impl frame_system::Config for Test { + type RuntimeEvent = RuntimeEvent; + type BaseCallFilter = Everything; + type BlockWeights = (); + type BlockLength = (); + type RuntimeOrigin = RuntimeOrigin; + type RuntimeCall = RuntimeCall; + type RuntimeTask = (); + type Nonce = u64; + type Hash = H256; + type Hashing = BlakeTwo256; + type AccountId = AccountId; + type Lookup = IdentityLookup; + type Block = Block; + type BlockHashCount = BlockHashCount; + type DbWeight = (); + type Version = (); + type PalletInfo = PalletInfo; + type AccountData = pallet_balances::AccountData; + type OnNewAccount = (); + type OnKilledAccount = (); + type SystemWeightInfo = (); + type ExtensionsWeightInfo = (); + type SS58Prefix = (); + type OnSetCode = (); + type MaxConsumers = ConstU32<16>; + type SingleBlockMigrations = (); + type MultiBlockMigrator = (); + type PreInherents = (); + type PostInherents = (); + type PostTransactions = (); +} + +parameter_types! { + pub const ExistentialDeposit: Balance = 1; +} + +impl pallet_balances::Config for Test { + type RuntimeHoldReason = (); + type RuntimeFreezeReason = (); + type WeightInfo = (); + type Balance = Balance; + type DustRemoval = (); + type ExistentialDeposit = ExistentialDeposit; + type AccountStore = System; + type ReserveIdentifier = [u8; 8]; + type FreezeIdentifier = (); + type MaxLocks = ConstU32<50>; + type MaxReserves = (); + type MaxFreezes = (); + type DoneSlashHandler = (); + type RuntimeEvent = RuntimeEvent; +} + +impl pallet_assets::Config for Test { + type RuntimeEvent = RuntimeEvent; + type Balance = Balance; + type AssetId = u32; + type AssetIdParameter = u32; + type Currency = Balances; + type CreateOrigin = + frame_support::traits::AsEnsureOriginWithArg>; + type ForceOrigin = frame_system::EnsureRoot; + type AssetDeposit = ConstU128<1>; + type AssetAccountDeposit = ConstU128<1>; + type MetadataDepositBase = ConstU128<1>; + type MetadataDepositPerByte = ConstU128<1>; + type ApprovalDeposit = ConstU128<1>; + type StringLimit = ConstU32<50>; + type Freezer = (); + type Extra = (); + type WeightInfo = (); + type RemoveItemsLimit = ConstU32<1000>; + type CallbackHandle = (); + type Holder = (); + type ReserveData = (); +} + +parameter_types! { + pub const MintingAccount: AccountId = MINTING_ACCOUNT; + pub const MinimumTransferAmount: Balance = 10 * UNIT; + pub const VolumeFeeRateBps: u32 = 10; + pub const VolumeFeesBurnRate: Permill = Permill::from_percent(50); + pub const AggregationProverFeeShare: Permill = Permill::from_percent(25); +} + +impl pallet_wormhole::Config for Test { + type NativeBalance = Balance; + type Currency = Balances; + type Assets = Assets; + type AssetId = u32; + type AssetBalance = Balance; + type TransferCount = u64; + type MintingAccount = MintingAccount; + type MinimumTransferAmount = MinimumTransferAmount; + type VolumeFeeRateBps = VolumeFeeRateBps; + type VolumeFeesBurnRate = VolumeFeesBurnRate; + type AggregationProverFeeShare = AggregationProverFeeShare; + type WormholeAccountId = AccountId; + type WeightInfo = pallet_wormhole::weights::SubstrateWeight; + type ZkTree = (); +} + +parameter_types! { + pub const MaxL0ProofBytes: u32 = 256 * 1024; + pub const MaxNullifiersPerL0: u32 = 32; + pub const MaxExitSlotsPerL0: u32 = 64; + pub const MaxCandidatesPerQueue: u32 = 4; + pub const CandidateLifetime: u64 = 100; + pub const StorageBond: Balance = 10; + pub const ValidityBond: Balance = 20; + pub const NumLayer0Proofs: u32 = 1; + pub const CircuitId: [u8; 32] = [42u8; 32]; + pub const MaxActiveBundlesPerMiner: u32 = 4; + pub const BundleProvingPeriod: u64 = 10; + pub const MinMinerBond: Balance = 50; + pub const MaxL1ProofBytes: u32 = 512 * 1024; + pub const MinerTimeoutSlash: Permill = Permill::from_percent(20); + pub const InvalidL1ProofSlash: Permill = Permill::from_percent(10); + pub const InvalidClaimSlash: Permill = Permill::from_percent(40); + pub const InvalidCandidateChallengeReward: Permill = Permill::from_percent(50); +} + +impl pallet_miner_aggregation::Config for Test { + type RuntimeEvent = RuntimeEvent; + type Currency = Balances; + type MaxL0ProofBytes = MaxL0ProofBytes; + type MaxNullifiersPerL0 = MaxNullifiersPerL0; + type MaxExitSlotsPerL0 = MaxExitSlotsPerL0; + type MaxCandidatesPerQueue = MaxCandidatesPerQueue; + type CandidateLifetime = CandidateLifetime; + type StorageBond = StorageBond; + type ValidityBond = ValidityBond; + type NumLayer0Proofs = NumLayer0Proofs; + type CircuitId = CircuitId; + type MaxActiveBundlesPerMiner = MaxActiveBundlesPerMiner; + type BundleProvingPeriod = BundleProvingPeriod; + type MinMinerBond = MinMinerBond; + type MaxL1ProofBytes = MaxL1ProofBytes; + type MinerTimeoutSlash = MinerTimeoutSlash; + type InvalidL1ProofSlash = InvalidL1ProofSlash; + type InvalidClaimSlash = InvalidClaimSlash; + type InvalidCandidateChallengeReward = InvalidCandidateChallengeReward; + type WeightInfo = (); +} + +pub fn new_test_ext() -> sp_state_machine::TestExternalities { + let mut t = frame_system::GenesisConfig::::default().build_storage().unwrap(); + pallet_balances::GenesisConfig:: { + balances: vec![ + (account_id(1), 1_000 * UNIT), + (account_id(2), 1_000 * UNIT), + (account_id(3), 1_000 * UNIT), + ], + dev_accounts: None, + } + .assimilate_storage(&mut t) + .unwrap(); + t.into() +} diff --git a/pallets/miner-aggregation/src/tests.rs b/pallets/miner-aggregation/src/tests.rs new file mode 100644 index 00000000..2d6ccf14 --- /dev/null +++ b/pallets/miner-aggregation/src/tests.rs @@ -0,0 +1,1660 @@ +use crate::{ + mock::*, + pallet::{ + BundleStatus, Bundles, Error, L0CandidateStatus, L0Candidates, MinerActiveBundles, + PendingQueues, RegisteredAggregators, + }, +}; +use frame_support::{assert_noop, assert_ok, traits::fungible::Inspect}; +use qp_wormhole_verifier::{ + parse_aggregated_public_inputs, BlockData, BytesDigest, Layer1AggregatedPublicCircuitInputs, + PublicInputsByAccount, +}; +use sp_core::H256; + +const AGGREGATED_PROOF_HEX: &str = include_str!("../../wormhole/test-data/aggregated.hex"); +const L1_FIXTURE_L0_CANDIDATE_0_HEX: &str = include_str!("../test-data/l0_candidate_0.hex"); +const L1_FIXTURE_AGGREGATE_HEX: &str = include_str!("../test-data/l1_aggregate.hex"); + +fn decode_hex_fixture(contents: &str) -> Vec { + hex::decode(contents.trim()).expect("valid proof hex") +} + +fn proof_bytes() -> Vec { + decode_hex_fixture(AGGREGATED_PROOF_HEX) +} + +fn l1_fixture_l0_candidate_0_bytes() -> Vec { + decode_hex_fixture(L1_FIXTURE_L0_CANDIDATE_0_HEX) +} + +fn l1_fixture_aggregate_bytes() -> Vec { + decode_hex_fixture(L1_FIXTURE_AGGREGATE_HEX) +} + +fn setup_matching_block_hash(proof_bytes: &[u8]) { + let proof = Wormhole::deserialize_aggregated_proof(proof_bytes).expect("proof deserializes"); + let inputs = parse_aggregated_public_inputs(&proof).expect("public inputs parse"); + let block_number = inputs.block_data.block_number as u64; + let block_hash_bytes: [u8; 32] = inputs.block_data.block_hash.as_ref().try_into().unwrap(); + frame_system::BlockHash::::insert(block_number, H256::from(block_hash_bytes)); +} + +fn submit_candidate() -> ([u8; 32], crate::BundleGroupKey) { + let proof_bytes = proof_bytes(); + setup_matching_block_hash(&proof_bytes); + assert_ok!(MinerAggregation::submit_l0_candidate( + RuntimeOrigin::signed(account_id(1)), + proof_bytes.clone(), + 5 + )); + let candidate_id = sp_io::hashing::blake2_256(&proof_bytes); + let group_key = L0Candidates::::get(candidate_id).expect("candidate stored").group_key; + (candidate_id, group_key) +} + +fn invalid_l0_proof_bytes() -> Vec { + let valid_bytes = proof_bytes(); + setup_matching_block_hash(&valid_bytes); + + for idx in (0..valid_bytes.len()).rev() { + let mut mutated = valid_bytes.clone(); + mutated[idx] ^= 1; + let Ok(proof) = Wormhole::deserialize_aggregated_proof(&mutated) else { + continue; + }; + if Wormhole::parse_aggregated_inputs_from_proof(&proof).is_err() { + continue; + } + if matches!( + Wormhole::verify_aggregated_proof_for_candidate(&mutated), + Err(pallet_wormhole::Error::::AggregatedVerificationFailed) + ) { + return mutated; + } + } + + panic!("could not derive invalid proof bytes that still parse"); +} + +fn submit_invalid_candidate() -> ([u8; 32], crate::BundleGroupKey) { + let proof_bytes = invalid_l0_proof_bytes(); + setup_matching_block_hash(&proof_bytes); + assert_ok!(MinerAggregation::submit_l0_candidate( + RuntimeOrigin::signed(account_id(1)), + proof_bytes.clone(), + 5 + )); + let candidate_id = sp_io::hashing::blake2_256(&proof_bytes); + let group_key = L0Candidates::::get(candidate_id).expect("candidate stored").group_key; + (candidate_id, group_key) +} + +fn total_balance(account: &AccountId) -> Balance { + Balances::balance(account).saturating_add(Balances::reserved_balance(account)) +} + +fn register_miner() { + register_miner_with_reward(account_id(2)); +} + +fn register_miner_with_reward(reward_account: AccountId) { + let reward_address: [u8; 32] = *reward_account.as_ref(); + assert_ok!(MinerAggregation::register_aggregator( + RuntimeOrigin::signed(account_id(2)), + reward_address, + 2, + 100 + )); +} + +fn claim_candidate_bundle() -> ([u8; 32], [u8; 32], Vec<[u8; 32]>) { + claim_candidate_bundle_with_reward(account_id(2)) +} + +fn claim_invalid_candidate_bundle() -> ([u8; 32], [u8; 32], Vec<[u8; 32]>) { + let (candidate_id, group_key) = submit_invalid_candidate(); + register_miner(); + assert_ok!(MinerAggregation::claim_bundle( + RuntimeOrigin::signed(account_id(2)), + group_key, + *account_id(2).as_ref(), + MinMinerBond::get() + )); + let candidate = L0Candidates::::get(candidate_id).expect("candidate stored"); + let bundle_id = match candidate.status { + L0CandidateStatus::Claimed { bundle_id } => bundle_id, + _ => panic!("candidate should be claimed"), + }; + (candidate_id, bundle_id, candidate.nullifiers.to_vec()) +} + +fn claim_candidate_bundle_with_reward( + reward_account: AccountId, +) -> ([u8; 32], [u8; 32], Vec<[u8; 32]>) { + let (candidate_id, group_key) = submit_candidate(); + register_miner_with_reward(reward_account.clone()); + assert_ok!(MinerAggregation::claim_bundle( + RuntimeOrigin::signed(account_id(2)), + group_key, + *reward_account.as_ref(), + MinMinerBond::get() + )); + let candidate = L0Candidates::::get(candidate_id).expect("candidate stored"); + let bundle_id = match candidate.status { + L0CandidateStatus::Claimed { bundle_id } => bundle_id, + _ => panic!("candidate should be claimed"), + }; + (candidate_id, bundle_id, candidate.nullifiers.to_vec()) +} + +struct ClaimedL1FixtureBundle { + candidate_id: [u8; 32], + bundle_id: [u8; 32], + l1_proof_bytes: Vec, +} + +fn claim_l1_fixture_bundle() -> Option { + if pallet_wormhole::get_layer1_verifier().is_err() { + eprintln!( + "skipping L1 fixture test; rerun with QP_GENERATE_LAYER1=true \ + QP_NUM_LAYER0_PROOFS=1" + ); + return None; + } + + let l0_proof_bytes = l1_fixture_l0_candidate_0_bytes(); + setup_matching_block_hash(&l0_proof_bytes); + System::set_block_number(1); + assert_ok!(MinerAggregation::submit_l0_candidate( + RuntimeOrigin::signed(account_id(1)), + l0_proof_bytes.clone(), + 5 + )); + let candidate_id = sp_io::hashing::blake2_256(&l0_proof_bytes); + let submitted_candidate = L0Candidates::::get(candidate_id).expect("candidate stored"); + let group_key = submitted_candidate.group_key; + let submitted_nullifiers = submitted_candidate.nullifiers.to_vec(); + assert_eq!(submitted_candidate.status, L0CandidateStatus::Pending); + for nullifier in &submitted_nullifiers { + assert!(!Wormhole::is_nullifier_locked(nullifier)); + assert!(!Wormhole::is_nullifier_used(nullifier)); + } + assert_ok!(Wormhole::ensure_nullifiers_available_for_direct_settlement(&submitted_nullifiers)); + + register_miner(); + assert_ok!(MinerAggregation::claim_bundle( + RuntimeOrigin::signed(account_id(2)), + group_key, + *account_id(2).as_ref(), + MinMinerBond::get() + )); + let candidate = L0Candidates::::get(candidate_id).expect("candidate stored"); + let bundle_id = match candidate.status { + L0CandidateStatus::Claimed { bundle_id } => bundle_id, + _ => panic!("candidate should be claimed"), + }; + for nullifier in &submitted_nullifiers { + assert!(Wormhole::is_nullifier_locked(nullifier)); + assert!(!Wormhole::is_nullifier_used(nullifier)); + } + let err = Wormhole::ensure_nullifiers_available_for_direct_settlement(&submitted_nullifiers) + .expect_err("direct L0 settlement should reject claimed nullifiers"); + assert!(matches!(err, pallet_wormhole::Error::::NullifierLocked)); + + Some(ClaimedL1FixtureBundle { + candidate_id, + bundle_id, + l1_proof_bytes: l1_fixture_aggregate_bytes(), + }) +} + +fn add_synthetic_claimed_candidate_to_bundle(bundle_id: [u8; 32]) -> [u8; 32] { + let existing_id = Bundles::::get(bundle_id).expect("bundle stored").ordered_candidates[0]; + let mut candidate = L0Candidates::::get(existing_id).expect("candidate stored"); + let synthetic_id = [77u8; 32]; + let synthetic_nullifier = [88u8; 32]; + + candidate.proof_hash = synthetic_id; + candidate.public_inputs_hash = [99u8; 32]; + candidate.nullifiers = vec![synthetic_nullifier].try_into().expect("bounded nullifiers"); + candidate.status = L0CandidateStatus::Claimed { bundle_id }; + L0Candidates::::insert(synthetic_id, candidate); + + Bundles::::mutate(bundle_id, |bundle| { + bundle + .as_mut() + .expect("bundle stored") + .ordered_candidates + .try_push(synthetic_id) + .expect("bundle has capacity"); + }); + let bundle = Bundles::::get(bundle_id).expect("bundle stored"); + assert_ok!(Wormhole::lock_nullifiers_for_bundle( + bundle_id, + bundle.deadline, + &[synthetic_nullifier] + )); + + synthetic_id +} + +fn public_outputs_from_candidate(candidate_id: [u8; 32]) -> Vec { + let candidate = L0Candidates::::get(candidate_id).expect("candidate stored"); + candidate + .exit_summary + .iter() + .map(|exit| PublicInputsByAccount { + summed_output_amount: exit.summed_output_amount, + exit_account: BytesDigest::new_unchecked(exit.exit_account), + }) + .collect() +} + +fn account_from_digest(digest: &BytesDigest) -> AccountId { + let bytes: [u8; 32] = digest.as_ref().try_into().expect("digest is 32 bytes"); + AccountId::new(bytes) +} + +fn unique_exit_accounts(account_data: &[PublicInputsByAccount]) -> Vec { + let mut accounts = Vec::new(); + for exit in account_data { + let account = account_from_digest(&exit.exit_account); + if !accounts.contains(&account) { + accounts.push(account); + } + } + accounts +} + +fn layer1_inputs_for_candidate( + candidate_id: [u8; 32], + bundle_id: [u8; 32], + aggregator_address: [u8; 32], +) -> Layer1AggregatedPublicCircuitInputs { + let bundle = Bundles::::get(bundle_id).expect("bundle stored"); + let candidate = L0Candidates::::get(candidate_id).expect("candidate stored"); + let account_data = public_outputs_from_candidate(candidate_id); + let nullifiers = candidate + .nullifiers + .iter() + .map(|nullifier| BytesDigest::new_unchecked(*nullifier)) + .collect(); + + Layer1AggregatedPublicCircuitInputs { + aggregator_address: BytesDigest::new_unchecked(aggregator_address), + asset_id: bundle.group_key.asset_id, + volume_fee_bps: bundle.group_key.volume_fee_bps, + block_data: BlockData { + block_hash: BytesDigest::new_unchecked(bundle.group_key.block_hash), + block_number: bundle.group_key.block_number, + }, + total_exit_slots: account_data.len() as u32, + account_data, + nullifiers, + bundle_root: None, + circuit_id: None, + layout_version: None, + } +} + +fn claimed_bundle_inputs() -> ([u8; 32], [u8; 32], Layer1AggregatedPublicCircuitInputs) { + let (candidate_id, bundle_id, _nullifiers) = claim_candidate_bundle(); + let inputs = layer1_inputs_for_candidate(candidate_id, bundle_id, *account_id(2).as_ref()); + (candidate_id, bundle_id, inputs) +} + +fn assert_l1_proof_mismatch(bundle_id: [u8; 32], inputs: &Layer1AggregatedPublicCircuitInputs) { + let bundle = Bundles::::get(bundle_id).expect("bundle stored"); + let err = MinerAggregation::ensure_l1_matches_bundle(&bundle, inputs).unwrap_err(); + assert!(matches!(err, Error::::ProofMismatch)); +} + +fn assert_l1_duplicate_nullifier( + bundle_id: [u8; 32], + inputs: &Layer1AggregatedPublicCircuitInputs, +) { + let bundle = Bundles::::get(bundle_id).expect("bundle stored"); + let err = MinerAggregation::ensure_l1_matches_bundle(&bundle, inputs).unwrap_err(); + assert!(matches!(err, Error::::DuplicateNullifier)); +} + +fn expected_exit_amount_for( + account_data: &[PublicInputsByAccount], + account: &AccountId, +) -> Balance { + let account_bytes: &[u8] = account.as_ref(); + account_data + .iter() + .filter(|exit| exit.exit_account.as_ref() == account_bytes) + .map(|exit| { + (exit.summed_output_amount as Balance) + .saturating_mul(pallet_wormhole::SCALE_DOWN_FACTOR) + }) + .sum() +} + +fn below_minimum_public_outputs() -> Vec { + vec![PublicInputsByAccount { + summed_output_amount: 1, + exit_account: BytesDigest::new_unchecked(*account_id(3).as_ref()), + }] +} + +fn fail_verified_l1_settlement(candidate_id: [u8; 32], bundle_id: [u8; 32]) { + let bundle = Bundles::::get(bundle_id).expect("bundle stored"); + let nullifiers = L0Candidates::::get(candidate_id) + .expect("candidate stored") + .nullifiers + .to_vec(); + let err = MinerAggregation::settle_verified_l1_bundle( + bundle_id, + bundle, + nullifiers, + &below_minimum_public_outputs(), + VolumeFeeRateBps::get(), + ) + .unwrap_err(); + + assert_eq!(err, Error::::ProofMismatch.into()); +} + +#[test] +fn valid_candidate_is_queued_and_bonded() { + new_test_ext().execute_with(|| { + let submitter = account_id(1); + let proof_bytes = proof_bytes(); + setup_matching_block_hash(&proof_bytes); + + assert_ok!(MinerAggregation::submit_l0_candidate( + RuntimeOrigin::signed(submitter.clone()), + proof_bytes.clone(), + 5 + )); + + let candidate_id = sp_io::hashing::blake2_256(&proof_bytes); + let candidate = L0Candidates::::get(candidate_id).expect("candidate stored"); + assert_eq!(candidate.submitter, submitter); + assert_eq!(candidate.status, L0CandidateStatus::Pending); + assert_eq!(candidate.aggregation_tip, 5); + assert!(!candidate.nullifiers.is_empty()); + assert!(!candidate.exit_summary.is_empty()); + + let queue = PendingQueues::::get(&candidate.group_key); + assert_eq!(queue.as_slice(), &[candidate_id]); + assert_eq!(Balances::reserved_balance(&account_id(1)), 35); + }); +} + +#[test] +fn candidate_submission_does_not_lock_nullifiers() { + new_test_ext().execute_with(|| { + let proof_bytes = proof_bytes(); + setup_matching_block_hash(&proof_bytes); + + assert_ok!(MinerAggregation::submit_l0_candidate( + RuntimeOrigin::signed(account_id(1)), + proof_bytes.clone(), + 0 + )); + + let candidate_id = sp_io::hashing::blake2_256(&proof_bytes); + let candidate = L0Candidates::::get(candidate_id).expect("candidate stored"); + for nullifier in candidate.nullifiers { + assert!(!Wormhole::is_nullifier_locked(&nullifier)); + assert!(!Wormhole::is_nullifier_used(&nullifier)); + } + }); +} + +#[test] +fn duplicate_candidate_is_rejected() { + new_test_ext().execute_with(|| { + let proof_bytes = proof_bytes(); + setup_matching_block_hash(&proof_bytes); + + assert_ok!(MinerAggregation::submit_l0_candidate( + RuntimeOrigin::signed(account_id(1)), + proof_bytes.clone(), + 0 + )); + assert_noop!( + MinerAggregation::submit_l0_candidate( + RuntimeOrigin::signed(account_id(1)), + proof_bytes, + 0 + ), + Error::::DuplicateCandidate + ); + }); +} + +#[test] +fn oversized_candidate_is_rejected() { + new_test_ext().execute_with(|| { + let too_large = vec![0u8; MaxL0ProofBytes::get() as usize + 1]; + assert_noop!( + MinerAggregation::submit_l0_candidate( + RuntimeOrigin::signed(account_id(1)), + too_large, + 0 + ), + Error::::ProofTooLarge + ); + }); +} + +#[test] +fn stale_or_missing_block_reference_is_rejected() { + new_test_ext().execute_with(|| { + let proof_bytes = proof_bytes(); + assert_noop!( + MinerAggregation::submit_l0_candidate( + RuntimeOrigin::signed(account_id(1)), + proof_bytes, + 0 + ), + Error::::StaleBlockReference + ); + }); +} + +#[test] +fn aggregator_registration_is_stored() { + new_test_ext().execute_with(|| { + let account = account_id(1); + assert_ok!(MinerAggregation::register_aggregator( + RuntimeOrigin::signed(account.clone()), + *account.as_ref(), + 2, + 100 + )); + assert!(RegisteredAggregators::::contains_key(account)); + }); +} + +#[test] +fn aggregator_registration_re_register_does_not_strand_old_bond() { + new_test_ext().execute_with(|| { + let miner = account_id(2); + let first_reward = account_id(42); + let second_reward = account_id(43); + + assert_ok!(MinerAggregation::register_aggregator( + RuntimeOrigin::signed(miner.clone()), + *first_reward.as_ref(), + 2, + 100 + )); + assert_eq!(Balances::reserved_balance(&miner), 100); + + assert_ok!(MinerAggregation::register_aggregator( + RuntimeOrigin::signed(miner.clone()), + *second_reward.as_ref(), + 3, + 40 + )); + let info = RegisteredAggregators::::get(&miner).expect("registered"); + let second_reward_address: [u8; 32] = *second_reward.as_ref(); + assert_eq!(info.reward_address, second_reward_address); + assert_eq!(info.max_active_jobs, 3); + assert_eq!(info.bond, 40); + assert_eq!(info.active_jobs, 0); + assert_eq!(Balances::reserved_balance(&miner), 40); + + assert_ok!(MinerAggregation::register_aggregator( + RuntimeOrigin::signed(miner.clone()), + *first_reward.as_ref(), + 4, + 75 + )); + let info = RegisteredAggregators::::get(&miner).expect("registered"); + let first_reward_address: [u8; 32] = *first_reward.as_ref(); + assert_eq!(info.reward_address, first_reward_address); + assert_eq!(info.max_active_jobs, 4); + assert_eq!(info.bond, 75); + assert_eq!(Balances::reserved_balance(&miner), 75); + assert_ok!(MinerAggregation::ensure_aggregator_active_jobs_consistent(&miner)); + }); +} + +#[test] +fn aggregator_registration_update_extrinsic_adjusts_bond_and_reward_address() { + new_test_ext().execute_with(|| { + let miner = account_id(2); + let first_reward = account_id(42); + let second_reward = account_id(43); + + assert_ok!(MinerAggregation::register_aggregator( + RuntimeOrigin::signed(miner.clone()), + *first_reward.as_ref(), + 2, + 100 + )); + assert_ok!(MinerAggregation::update_aggregator( + RuntimeOrigin::signed(miner.clone()), + *second_reward.as_ref(), + 1, + 25 + )); + + let info = RegisteredAggregators::::get(&miner).expect("registered"); + let second_reward_address: [u8; 32] = *second_reward.as_ref(); + assert_eq!(info.reward_address, second_reward_address); + assert_eq!(info.max_active_jobs, 1); + assert_eq!(info.bond, 25); + assert_eq!(info.active_jobs, 0); + assert_eq!(Balances::reserved_balance(&miner), 25); + assert_ok!(MinerAggregation::ensure_aggregator_active_jobs_consistent(&miner)); + }); +} + +#[test] +fn aggregator_registration_re_register_rejects_active_jobs() { + new_test_ext().execute_with(|| { + let (candidate_id, group_key) = submit_candidate(); + register_miner(); + + assert_ok!(MinerAggregation::claim_bundle( + RuntimeOrigin::signed(account_id(2)), + group_key, + *account_id(2).as_ref(), + MinMinerBond::get() + )); + let candidate = L0Candidates::::get(candidate_id).expect("candidate stored"); + let L0CandidateStatus::Claimed { bundle_id } = candidate.status else { + panic!("candidate should be claimed"); + }; + + assert_noop!( + MinerAggregation::register_aggregator( + RuntimeOrigin::signed(account_id(2)), + *account_id(42).as_ref(), + 3, + 75 + ), + Error::::AggregatorHasActiveJobs + ); + assert_noop!( + MinerAggregation::update_aggregator( + RuntimeOrigin::signed(account_id(2)), + *account_id(42).as_ref(), + 3, + 75 + ), + Error::::AggregatorHasActiveJobs + ); + + let info = RegisteredAggregators::::get(account_id(2)).expect("registered"); + let original_reward_address: [u8; 32] = *account_id(2).as_ref(); + assert_eq!(info.reward_address, original_reward_address); + assert_eq!(info.bond, 100); + assert_eq!(info.active_jobs, 1); + assert_eq!(MinerActiveBundles::::get(account_id(2)).as_slice(), &[bundle_id]); + assert_eq!(Balances::reserved_balance(&account_id(2)), 100 + MinMinerBond::get()); + assert_ok!(MinerAggregation::ensure_aggregator_active_jobs_consistent(&account_id(2))); + }); +} + +#[test] +fn aggregator_registration_unregister_releases_bond_when_no_active_jobs() { + new_test_ext().execute_with(|| { + let miner = account_id(2); + assert_ok!(MinerAggregation::register_aggregator( + RuntimeOrigin::signed(miner.clone()), + *miner.as_ref(), + 2, + 100 + )); + assert_eq!(Balances::reserved_balance(&miner), 100); + + assert_ok!(MinerAggregation::unregister_aggregator(RuntimeOrigin::signed(miner.clone()))); + + assert!(!RegisteredAggregators::::contains_key(&miner)); + assert_eq!(Balances::reserved_balance(&miner), 0); + assert_ok!(MinerAggregation::ensure_aggregator_active_jobs_consistent(&miner)); + }); +} + +#[test] +fn aggregator_registration_unregister_rejects_when_active_bundle_exists() { + new_test_ext().execute_with(|| { + let (_candidate_id, group_key) = submit_candidate(); + register_miner(); + assert_ok!(MinerAggregation::claim_bundle( + RuntimeOrigin::signed(account_id(2)), + group_key, + *account_id(2).as_ref(), + MinMinerBond::get() + )); + + assert_noop!( + MinerAggregation::unregister_aggregator(RuntimeOrigin::signed(account_id(2))), + Error::::AggregatorHasActiveJobs + ); + assert!(RegisteredAggregators::::contains_key(account_id(2))); + assert_eq!(Balances::reserved_balance(&account_id(2)), 100 + MinMinerBond::get()); + assert_ok!(MinerAggregation::ensure_aggregator_active_jobs_consistent(&account_id(2))); + }); +} + +#[test] +fn claim_bundle_uses_registered_reward_address() { + new_test_ext().execute_with(|| { + let (_candidate_id, group_key) = submit_candidate(); + let reward_account = account_id(42); + register_miner_with_reward(reward_account.clone()); + + assert_ok!(MinerAggregation::claim_bundle( + RuntimeOrigin::signed(account_id(2)), + group_key, + *reward_account.as_ref(), + MinMinerBond::get() + )); + + let bundle_id = MinerActiveBundles::::get(account_id(2))[0]; + let bundle = Bundles::::get(bundle_id).expect("bundle stored"); + let reward_address: [u8; 32] = *reward_account.as_ref(); + assert_eq!(bundle.aggregator_address, reward_address); + }); +} + +#[test] +fn claim_bundle_rejects_mismatched_aggregator_address() { + new_test_ext().execute_with(|| { + let (candidate_id, group_key) = submit_candidate(); + let reward_account = account_id(42); + let wrong_reward_account = account_id(43); + register_miner_with_reward(reward_account); + + assert_noop!( + MinerAggregation::claim_bundle( + RuntimeOrigin::signed(account_id(2)), + group_key.clone(), + *wrong_reward_account.as_ref(), + MinMinerBond::get() + ), + Error::::AggregatorAddressMismatch + ); + + let candidate = L0Candidates::::get(candidate_id).expect("candidate stored"); + assert_eq!(candidate.status, L0CandidateStatus::Pending); + for nullifier in candidate.nullifiers { + assert!(!Wormhole::is_nullifier_locked(&nullifier)); + } + assert_eq!(PendingQueues::::get(&group_key).as_slice(), &[candidate_id]); + assert!(MinerActiveBundles::::get(account_id(2)).is_empty()); + }); +} + +#[test] +fn claim_bundle_requires_registration() { + new_test_ext().execute_with(|| { + let (_candidate_id, group_key) = submit_candidate(); + assert_noop!( + MinerAggregation::claim_bundle( + RuntimeOrigin::signed(account_id(2)), + group_key, + *account_id(2).as_ref(), + MinMinerBond::get() + ), + Error::::AggregatorNotRegistered + ); + }); +} + +#[test] +fn claim_bundle_locks_nullifiers_and_marks_candidate_claimed() { + new_test_ext().execute_with(|| { + let (candidate_id, group_key) = submit_candidate(); + register_miner(); + + assert_ok!(MinerAggregation::claim_bundle( + RuntimeOrigin::signed(account_id(2)), + group_key.clone(), + *account_id(2).as_ref(), + MinMinerBond::get() + )); + + let candidate = L0Candidates::::get(candidate_id).expect("candidate stored"); + let L0CandidateStatus::Claimed { bundle_id } = candidate.status else { + panic!("candidate should be claimed"); + }; + for nullifier in candidate.nullifiers { + assert!(Wormhole::is_nullifier_locked(&nullifier)); + } + assert!(PendingQueues::::get(&group_key).is_empty()); + assert_eq!(MinerActiveBundles::::get(account_id(2)).as_slice(), &[bundle_id]); + assert_eq!( + Bundles::::get(bundle_id).expect("bundle stored").status, + BundleStatus::Claimed + ); + }); +} + +#[test] +fn claim_bundle_rejects_locked_nullifier_without_side_effects() { + new_test_ext().execute_with(|| { + let (candidate_id, group_key) = submit_candidate(); + let candidate = L0Candidates::::get(candidate_id).expect("candidate stored"); + let nullifiers = candidate.nullifiers.to_vec(); + assert_ok!(Wormhole::lock_nullifiers_for_bundle( + [9u8; 32], + BundleProvingPeriod::get() + 10, + &nullifiers + )); + register_miner(); + let miner_reserved_before = Balances::reserved_balance(&account_id(2)); + + assert_noop!( + MinerAggregation::claim_bundle( + RuntimeOrigin::signed(account_id(2)), + group_key.clone(), + *account_id(2).as_ref(), + MinMinerBond::get() + ), + Error::::NullifierUnavailable + ); + + let candidate = L0Candidates::::get(candidate_id).expect("candidate stored"); + assert_eq!(candidate.status, L0CandidateStatus::Pending); + assert_eq!(PendingQueues::::get(&group_key).as_slice(), &[candidate_id]); + for nullifier in &nullifiers { + assert!(Wormhole::is_nullifier_locked(nullifier)); + assert!(!Wormhole::is_nullifier_used(nullifier)); + } + assert_eq!(Balances::reserved_balance(&account_id(2)), miner_reserved_before); + assert!(MinerActiveBundles::::get(account_id(2)).is_empty()); + assert_eq!( + RegisteredAggregators::::get(account_id(2)) + .expect("aggregator registered") + .active_jobs, + 0 + ); + assert_ok!(MinerAggregation::ensure_aggregator_active_jobs_consistent(&account_id(2))); + }); +} + +#[test] +fn claim_bundle_rejects_used_nullifier_without_side_effects() { + new_test_ext().execute_with(|| { + let (candidate_id, group_key) = submit_candidate(); + let candidate = L0Candidates::::get(candidate_id).expect("candidate stored"); + let nullifiers = candidate.nullifiers.to_vec(); + assert_ok!(Wormhole::mark_nullifiers_used(&nullifiers)); + register_miner(); + let miner_reserved_before = Balances::reserved_balance(&account_id(2)); + + assert_noop!( + MinerAggregation::claim_bundle( + RuntimeOrigin::signed(account_id(2)), + group_key.clone(), + *account_id(2).as_ref(), + MinMinerBond::get() + ), + Error::::NullifierUnavailable + ); + + let candidate = L0Candidates::::get(candidate_id).expect("candidate stored"); + assert_eq!(candidate.status, L0CandidateStatus::Pending); + assert_eq!(PendingQueues::::get(&group_key).as_slice(), &[candidate_id]); + for nullifier in &nullifiers { + assert!(!Wormhole::is_nullifier_locked(nullifier)); + assert!(Wormhole::is_nullifier_used(nullifier)); + } + assert_eq!(Balances::reserved_balance(&account_id(2)), miner_reserved_before); + assert!(MinerActiveBundles::::get(account_id(2)).is_empty()); + assert_eq!( + RegisteredAggregators::::get(account_id(2)) + .expect("aggregator registered") + .active_jobs, + 0 + ); + assert_ok!(MinerAggregation::ensure_aggregator_active_jobs_consistent(&account_id(2))); + }); +} + +#[test] +fn submit_l1_aggregate_rejects_proof_with_wrong_aggregator_address() { + new_test_ext().execute_with(|| { + let (candidate_id, bundle_id, _nullifiers) = claim_candidate_bundle(); + let bundle = Bundles::::get(bundle_id).expect("bundle stored"); + let wrong_inputs = + layer1_inputs_for_candidate(candidate_id, bundle_id, *account_id(42).as_ref()); + + let err = MinerAggregation::ensure_l1_matches_bundle(&bundle, &wrong_inputs).unwrap_err(); + assert!(matches!(err, Error::::ProofMismatch)); + }); +} + +#[test] +fn l1_full_effect_comparison_rejects_wrong_exit_amount() { + new_test_ext().execute_with(|| { + let (_candidate_id, bundle_id, mut inputs) = claimed_bundle_inputs(); + inputs.account_data[0].summed_output_amount = + inputs.account_data[0].summed_output_amount.wrapping_add(1); + + assert_l1_proof_mismatch(bundle_id, &inputs); + }); +} + +#[test] +fn l1_full_effect_comparison_rejects_wrong_exit_account() { + new_test_ext().execute_with(|| { + let (_candidate_id, bundle_id, mut inputs) = claimed_bundle_inputs(); + inputs.account_data[0].exit_account = BytesDigest::new_unchecked(*account_id(99).as_ref()); + + assert_l1_proof_mismatch(bundle_id, &inputs); + }); +} + +#[test] +fn l1_full_effect_comparison_rejects_extra_exit() { + new_test_ext().execute_with(|| { + let (_candidate_id, bundle_id, mut inputs) = claimed_bundle_inputs(); + let mut extra_exit = inputs.account_data[0].clone(); + extra_exit.summed_output_amount = extra_exit.summed_output_amount.wrapping_add(7); + inputs.account_data.push(extra_exit); + inputs.total_exit_slots = inputs.account_data.len() as u32; + + assert_l1_proof_mismatch(bundle_id, &inputs); + }); +} + +#[test] +fn l1_full_effect_comparison_rejects_missing_exit() { + new_test_ext().execute_with(|| { + let (_candidate_id, bundle_id, mut inputs) = claimed_bundle_inputs(); + inputs.account_data.pop(); + inputs.total_exit_slots = inputs.account_data.len() as u32; + + assert_l1_proof_mismatch(bundle_id, &inputs); + }); +} + +#[test] +fn l1_full_effect_comparison_rejects_wrong_nullifier() { + new_test_ext().execute_with(|| { + let (_candidate_id, bundle_id, mut inputs) = claimed_bundle_inputs(); + inputs.nullifiers[0] = BytesDigest::new_unchecked([0xAB; 32]); + + assert_l1_proof_mismatch(bundle_id, &inputs); + }); +} + +#[test] +fn l1_full_effect_comparison_rejects_duplicate_nullifier() { + new_test_ext().execute_with(|| { + let (_candidate_id, bundle_id, mut inputs) = claimed_bundle_inputs(); + let duplicate = inputs.nullifiers[0].clone(); + if inputs.nullifiers.len() == 1 { + inputs.nullifiers.push(duplicate); + } else { + inputs.nullifiers[1] = duplicate; + } + + assert_l1_duplicate_nullifier(bundle_id, &inputs); + }); +} + +#[test] +fn l1_full_effect_comparison_rejects_reordered_exits() { + new_test_ext().execute_with(|| { + let (_candidate_id, bundle_id, mut inputs) = claimed_bundle_inputs(); + let mut swap_pair = None; + 'outer: for first in 0..inputs.account_data.len() { + for second in (first + 1)..inputs.account_data.len() { + if inputs.account_data[first] != inputs.account_data[second] { + swap_pair = Some((first, second)); + break 'outer; + } + } + } + let (first, second) = swap_pair.expect("fixture has distinct exit entries"); + inputs.account_data.swap(first, second); + + assert_l1_proof_mismatch(bundle_id, &inputs); + }); +} + +#[test] +fn l1_full_effect_comparison_rejects_exit_slot_count_mismatch() { + new_test_ext().execute_with(|| { + let (_candidate_id, bundle_id, mut inputs) = claimed_bundle_inputs(); + inputs.total_exit_slots = inputs.total_exit_slots.saturating_add(1); + + assert_l1_proof_mismatch(bundle_id, &inputs); + }); +} + +#[test] +fn bundle_root_is_metadata_until_constrained_by_l1_circuit() { + new_test_ext().execute_with(|| { + let (_candidate_id, bundle_id, mut inputs) = claimed_bundle_inputs(); + inputs.bundle_root = Some(BytesDigest::new_unchecked([0x42; 32])); + let bundle = Bundles::::get(bundle_id).expect("bundle stored"); + + assert_ok!(MinerAggregation::ensure_l1_matches_bundle(&bundle, &inputs)); + }); +} + +#[test] +fn submit_l1_aggregate_accepts_valid_fixture_and_settles_bundle() { + new_test_ext().execute_with(|| { + let Some(fixture) = claim_l1_fixture_bundle() else { + return; + }; + let miner = account_id(2); + let reward_account = account_id(2); + let proof = Wormhole::deserialize_layer1_proof(&fixture.l1_proof_bytes) + .expect("L1 fixture proof deserializes"); + let inputs = Wormhole::parse_layer1_inputs_from_proof(&proof) + .expect("L1 fixture public inputs parse"); + let candidate_before = + L0Candidates::::get(fixture.candidate_id).expect("candidate stored"); + let bundle_before = Bundles::::get(fixture.bundle_id).expect("bundle stored"); + let nullifiers = candidate_before.nullifiers.to_vec(); + let prepared = Wormhole::prepare_public_output_settlement( + &inputs.account_data, + inputs.volume_fee_bps, + pallet_wormhole::SettlementKind::DelegatedL1 { + aggregation_reward_account: reward_account.clone(), + }, + ) + .expect("settlement prepares"); + let exit_accounts = unique_exit_accounts(&inputs.account_data); + let exit_balances_before = exit_accounts + .iter() + .map(|account| (account.clone(), Balances::balance(account))) + .collect::>(); + let reward_balance_before = Balances::balance(&reward_account); + let miner_reserved_before = Balances::reserved_balance(&miner); + + assert_eq!(bundle_before.status, BundleStatus::Claimed); + assert_eq!(MinerActiveBundles::::get(&miner).as_slice(), &[fixture.bundle_id]); + assert_eq!( + RegisteredAggregators::::get(&miner) + .expect("registered aggregator") + .active_jobs, + 1 + ); + for nullifier in &nullifiers { + assert!(Wormhole::is_nullifier_locked(nullifier)); + assert!(!Wormhole::is_nullifier_used(nullifier)); + } + + assert_ok!(MinerAggregation::submit_l1_aggregate( + RuntimeOrigin::signed(miner.clone()), + fixture.bundle_id, + fixture.l1_proof_bytes + )); + + let settled_bundle = Bundles::::get(fixture.bundle_id).expect("bundle stored"); + assert_eq!(settled_bundle.status, BundleStatus::Settled); + for candidate_id in settled_bundle.ordered_candidates.iter() { + let candidate = L0Candidates::::get(candidate_id).expect("candidate stored"); + assert_eq!( + candidate.status, + L0CandidateStatus::Settled { bundle_id: fixture.bundle_id } + ); + } + for nullifier in &nullifiers { + assert!(!Wormhole::is_nullifier_locked(nullifier)); + assert!(Wormhole::is_nullifier_used(nullifier)); + } + for (account, balance_before) in exit_balances_before { + let mut expected_balance = + balance_before + expected_exit_amount_for(&inputs.account_data, &account); + if account == reward_account { + expected_balance = expected_balance + + candidate_before.aggregation_tip + + prepared.aggregation_prover_fee; + } + if account == miner { + expected_balance += bundle_before.miner_bond; + } + assert_eq!(Balances::balance(&account), expected_balance); + } + if !exit_accounts.contains(&reward_account) { + let mut expected_reward_balance = reward_balance_before + + candidate_before.aggregation_tip + + prepared.aggregation_prover_fee; + if reward_account == miner { + expected_reward_balance += bundle_before.miner_bond; + } + assert_eq!(Balances::balance(&reward_account), expected_reward_balance); + } + assert_eq!( + Balances::reserved_balance(&miner), + miner_reserved_before - bundle_before.miner_bond + ); + assert!(MinerActiveBundles::::get(&miner).is_empty()); + assert_eq!( + RegisteredAggregators::::get(&miner) + .expect("registered aggregator") + .active_jobs, + 0 + ); + System::assert_has_event( + crate::Event::::BundleSettled { bundle_id: fixture.bundle_id, miner }.into(), + ); + }); +} + +#[test] +fn l1_fixture_rejects_wrong_bundle_aggregator_address() { + new_test_ext().execute_with(|| { + let Some(fixture) = claim_l1_fixture_bundle() else { + return; + }; + Bundles::::mutate(fixture.bundle_id, |bundle| { + bundle.as_mut().expect("bundle stored").aggregator_address = *account_id(42).as_ref(); + }); + + assert_noop!( + MinerAggregation::submit_l1_aggregate( + RuntimeOrigin::signed(account_id(2)), + fixture.bundle_id, + fixture.l1_proof_bytes + ), + Error::::ProofMismatch + ); + }); +} + +#[test] +fn l1_fixture_rejects_wrong_bundle_block_number() { + new_test_ext().execute_with(|| { + let Some(fixture) = claim_l1_fixture_bundle() else { + return; + }; + Bundles::::mutate(fixture.bundle_id, |bundle| { + bundle.as_mut().expect("bundle stored").group_key.block_number += 1; + }); + + assert_noop!( + MinerAggregation::submit_l1_aggregate( + RuntimeOrigin::signed(account_id(2)), + fixture.bundle_id, + fixture.l1_proof_bytes + ), + Error::::ProofMismatch + ); + }); +} + +#[test] +fn l1_fixture_rejects_wrong_bundle_block_hash() { + new_test_ext().execute_with(|| { + let Some(fixture) = claim_l1_fixture_bundle() else { + return; + }; + Bundles::::mutate(fixture.bundle_id, |bundle| { + bundle.as_mut().expect("bundle stored").group_key.block_hash = [0x55; 32]; + }); + + assert_noop!( + MinerAggregation::submit_l1_aggregate( + RuntimeOrigin::signed(account_id(2)), + fixture.bundle_id, + fixture.l1_proof_bytes + ), + Error::::ProofMismatch + ); + }); +} + +#[test] +fn l1_fixture_rejects_wrong_candidate_nullifier_set() { + new_test_ext().execute_with(|| { + let Some(fixture) = claim_l1_fixture_bundle() else { + return; + }; + L0Candidates::::mutate(fixture.candidate_id, |candidate| { + candidate.as_mut().expect("candidate stored").nullifiers[0] = [0x66; 32]; + }); + + assert_noop!( + MinerAggregation::submit_l1_aggregate( + RuntimeOrigin::signed(account_id(2)), + fixture.bundle_id, + fixture.l1_proof_bytes + ), + Error::::ProofMismatch + ); + }); +} + +#[test] +fn l1_fixture_rejects_wrong_candidate_exit_summary() { + new_test_ext().execute_with(|| { + let Some(fixture) = claim_l1_fixture_bundle() else { + return; + }; + L0Candidates::::mutate(fixture.candidate_id, |candidate| { + let candidate = candidate.as_mut().expect("candidate stored"); + candidate.exit_summary[0].summed_output_amount = + candidate.exit_summary[0].summed_output_amount.wrapping_add(1); + }); + + assert_noop!( + MinerAggregation::submit_l1_aggregate( + RuntimeOrigin::signed(account_id(2)), + fixture.bundle_id, + fixture.l1_proof_bytes + ), + Error::::ProofMismatch + ); + }); +} + +#[test] +fn claim_before_direct_l0_makes_direct_validation_fail() { + new_test_ext().execute_with(|| { + let (candidate_id, group_key) = submit_candidate(); + register_miner(); + assert_ok!(MinerAggregation::claim_bundle( + RuntimeOrigin::signed(account_id(2)), + group_key, + *account_id(2).as_ref(), + MinMinerBond::get() + )); + let candidate = L0Candidates::::get(candidate_id).expect("candidate stored"); + let nullifiers = candidate.nullifiers.to_vec(); + let err = Wormhole::ensure_nullifiers_available_for_direct_settlement(&nullifiers) + .expect_err("direct settlement should reject claimed nullifier"); + assert!(matches!(err, pallet_wormhole::Error::::NullifierLocked)); + }); +} + +#[test] +fn timeout_bundle_unlocks_nullifiers_and_returns_candidate() { + new_test_ext().execute_with(|| { + let (candidate_id, group_key) = submit_candidate(); + register_miner(); + assert_ok!(MinerAggregation::claim_bundle( + RuntimeOrigin::signed(account_id(2)), + group_key.clone(), + *account_id(2).as_ref(), + MinMinerBond::get() + )); + let candidate = L0Candidates::::get(candidate_id).expect("candidate stored"); + let L0CandidateStatus::Claimed { bundle_id } = candidate.status else { + panic!("candidate should be claimed"); + }; + + System::set_block_number(BundleProvingPeriod::get() + 2); + assert_ok!(MinerAggregation::timeout_bundle( + RuntimeOrigin::signed(account_id(1)), + bundle_id + )); + + let candidate = L0Candidates::::get(candidate_id).expect("candidate stored"); + assert_eq!(candidate.status, L0CandidateStatus::Pending); + for nullifier in candidate.nullifiers { + assert!(!Wormhole::is_nullifier_locked(&nullifier)); + } + assert_eq!(PendingQueues::::get(&group_key).as_slice(), &[candidate_id]); + assert!(MinerActiveBundles::::get(account_id(2)).is_empty()); + }); +} + +#[test] +fn timeout_bundle_refunds_expired_claimed_candidate() { + new_test_ext().execute_with(|| { + let (candidate_id, group_key) = submit_candidate(); + register_miner(); + assert_ok!(MinerAggregation::claim_bundle( + RuntimeOrigin::signed(account_id(2)), + group_key.clone(), + *account_id(2).as_ref(), + MinMinerBond::get() + )); + let candidate = L0Candidates::::get(candidate_id).expect("candidate stored"); + let L0CandidateStatus::Claimed { bundle_id } = candidate.status else { + panic!("candidate should be claimed"); + }; + assert_eq!(Balances::reserved_balance(&account_id(1)), 35); + + System::set_block_number(CandidateLifetime::get() + 1); + assert_ok!(MinerAggregation::timeout_bundle( + RuntimeOrigin::signed(account_id(1)), + bundle_id + )); + + let candidate = L0Candidates::::get(candidate_id).expect("candidate stored"); + assert_eq!(candidate.status, L0CandidateStatus::Expired); + assert!(PendingQueues::::get(&group_key).is_empty()); + assert_eq!(Balances::reserved_balance(&account_id(1)), 0); + }); +} + +#[test] +fn timeout_partially_slashes_miner_bond() { + new_test_ext().execute_with(|| { + let (_candidate_id, group_key) = submit_candidate(); + register_miner(); + assert_ok!(MinerAggregation::claim_bundle( + RuntimeOrigin::signed(account_id(2)), + group_key, + *account_id(2).as_ref(), + MinMinerBond::get() + )); + let bundle_id = MinerActiveBundles::::get(account_id(2))[0]; + let miner_total_before = total_balance(&account_id(2)); + let expected_slash = MinerTimeoutSlash::get() * MinMinerBond::get(); + + System::set_block_number(BundleProvingPeriod::get() + 2); + assert_ok!(MinerAggregation::timeout_bundle( + RuntimeOrigin::signed(account_id(1)), + bundle_id + )); + + assert_eq!(total_balance(&account_id(2)), miner_total_before - expected_slash); + assert_eq!(Balances::reserved_balance(&account_id(2)), 100); + assert_eq!(Bundles::::get(bundle_id).expect("bundle stored").miner_bond, 0); + }); +} + +#[test] +fn active_jobs_timeout_decrements_consistently() { + new_test_ext().execute_with(|| { + let (_candidate_id, group_key) = submit_candidate(); + register_miner(); + assert_ok!(MinerAggregation::claim_bundle( + RuntimeOrigin::signed(account_id(2)), + group_key, + *account_id(2).as_ref(), + MinMinerBond::get() + )); + let bundle_id = MinerActiveBundles::::get(account_id(2))[0]; + assert_eq!( + RegisteredAggregators::::get(account_id(2)) + .expect("registered") + .active_jobs, + 1 + ); + assert_ok!(MinerAggregation::ensure_aggregator_active_jobs_consistent(&account_id(2))); + + System::set_block_number(BundleProvingPeriod::get() + 2); + assert_ok!(MinerAggregation::timeout_bundle( + RuntimeOrigin::signed(account_id(1)), + bundle_id + )); + + assert!(MinerActiveBundles::::get(account_id(2)).is_empty()); + assert_eq!( + RegisteredAggregators::::get(account_id(2)) + .expect("registered") + .active_jobs, + 0 + ); + assert_ok!(MinerAggregation::ensure_aggregator_active_jobs_consistent(&account_id(2))); + }); +} + +#[test] +fn invalid_l1_full_verification_failure_slashes_assigned_miner() { + new_test_ext().execute_with(|| { + let (_candidate_id, bundle_id, _nullifiers) = claim_candidate_bundle(); + let mut bundle = Bundles::::get(bundle_id).expect("bundle stored"); + let miner_total_before = total_balance(&account_id(2)); + let expected_slash = InvalidL1ProofSlash::get() * MinMinerBond::get(); + + let slashed = + MinerAggregation::record_invalid_l1_verification_failure(bundle_id, &mut bundle) + .expect("slashing succeeds"); + let remaining_miner_bond = bundle.miner_bond; + Bundles::::insert(bundle_id, bundle); + + assert_eq!(slashed, expected_slash); + assert_eq!(remaining_miner_bond, MinMinerBond::get() - expected_slash); + assert_eq!(total_balance(&account_id(2)), miner_total_before - expected_slash); + assert_eq!( + Bundles::::get(bundle_id).expect("bundle stored").status, + BundleStatus::Claimed + ); + assert_eq!(MinerActiveBundles::::get(account_id(2)).as_slice(), &[bundle_id]); + }); +} + +#[test] +fn submit_l1_aggregate_rejects_malformed_proof_before_verification() { + new_test_ext().execute_with(|| { + let (_candidate_id, group_key) = submit_candidate(); + register_miner(); + assert_ok!(MinerAggregation::claim_bundle( + RuntimeOrigin::signed(account_id(2)), + group_key, + *account_id(2).as_ref(), + MinMinerBond::get() + )); + let bundle_id = MinerActiveBundles::::get(account_id(2))[0]; + + assert_noop!( + MinerAggregation::submit_l1_aggregate( + RuntimeOrigin::signed(account_id(2)), + bundle_id, + Vec::new() + ), + Error::::MalformedL1Proof + ); + }); +} + +#[test] +fn active_jobs_settlement_decrements_consistently() { + new_test_ext().execute_with(|| { + let (candidate_id, bundle_id, nullifiers) = claim_candidate_bundle(); + let bundle = Bundles::::get(bundle_id).expect("bundle stored"); + let account_data = public_outputs_from_candidate(candidate_id); + assert_eq!( + RegisteredAggregators::::get(account_id(2)) + .expect("registered") + .active_jobs, + 1 + ); + assert_ok!(MinerAggregation::ensure_aggregator_active_jobs_consistent(&account_id(2))); + + assert_ok!(MinerAggregation::settle_verified_l1_bundle( + bundle_id, + bundle, + nullifiers, + &account_data, + VolumeFeeRateBps::get() + )); + + assert!(MinerActiveBundles::::get(account_id(2)).is_empty()); + assert_eq!( + RegisteredAggregators::::get(account_id(2)) + .expect("registered") + .active_jobs, + 0 + ); + assert_ok!(MinerAggregation::ensure_aggregator_active_jobs_consistent(&account_id(2))); + }); +} + +#[test] +fn submit_l1_aggregate_settlement_failure_preserves_nullifier_locks() { + new_test_ext().execute_with(|| { + let (candidate_id, bundle_id, nullifiers) = claim_candidate_bundle(); + + fail_verified_l1_settlement(candidate_id, bundle_id); + + for nullifier in nullifiers { + assert!(Wormhole::is_nullifier_locked(&nullifier)); + assert!(!Wormhole::is_nullifier_used(&nullifier)); + } + }); +} + +#[test] +fn submit_l1_aggregate_settlement_failure_preserves_candidate_status() { + new_test_ext().execute_with(|| { + let (candidate_id, bundle_id, _nullifiers) = claim_candidate_bundle(); + + fail_verified_l1_settlement(candidate_id, bundle_id); + + let candidate = L0Candidates::::get(candidate_id).expect("candidate stored"); + assert_eq!(candidate.status, L0CandidateStatus::Claimed { bundle_id }); + assert_eq!( + Bundles::::get(bundle_id).expect("bundle stored").status, + BundleStatus::Claimed + ); + }); +} + +#[test] +fn submit_l1_aggregate_settlement_failure_preserves_miner_active_bundle() { + new_test_ext().execute_with(|| { + let (candidate_id, bundle_id, _nullifiers) = claim_candidate_bundle(); + + fail_verified_l1_settlement(candidate_id, bundle_id); + + assert_eq!(MinerActiveBundles::::get(account_id(2)).as_slice(), &[bundle_id]); + assert_eq!( + RegisteredAggregators::::get(account_id(2)) + .expect("aggregator registered") + .active_jobs, + 1 + ); + }); +} + +#[test] +fn tips_are_paid_to_registered_reward_account() { + new_test_ext().execute_with(|| { + let reward_account = account_id(42); + let (candidate_id, bundle_id, nullifiers) = + claim_candidate_bundle_with_reward(reward_account.clone()); + System::set_block_number(1); + let bundle = Bundles::::get(bundle_id).expect("bundle stored"); + let candidate = L0Candidates::::get(candidate_id).expect("candidate stored"); + let aggregation_tip = candidate.aggregation_tip; + let account_data = public_outputs_from_candidate(candidate_id); + let expected_exit_amount = expected_exit_amount_for(&account_data, &reward_account); + let expected_fee_share = pallet_wormhole::Pallet::::prepare_public_output_settlement( + &account_data, + VolumeFeeRateBps::get(), + pallet_wormhole::SettlementKind::DelegatedL1 { + aggregation_reward_account: reward_account.clone(), + }, + ) + .expect("settlement prepares") + .aggregation_prover_fee; + let reward_balance_before = Balances::balance(&reward_account); + + assert_ok!(MinerAggregation::settle_verified_l1_bundle( + bundle_id, + bundle, + nullifiers, + &account_data, + VolumeFeeRateBps::get() + )); + + assert_eq!( + Balances::balance(&reward_account), + reward_balance_before + aggregation_tip + expected_exit_amount + expected_fee_share + ); + let candidate = L0Candidates::::get(candidate_id).expect("candidate stored"); + assert_eq!(candidate.status, L0CandidateStatus::Settled { bundle_id }); + }); +} + +#[test] +fn delegated_l1_pays_aggregation_prover_fee_share_to_registered_reward_account() { + new_test_ext().execute_with(|| { + let reward_account = account_id(42); + let (candidate_id, bundle_id, nullifiers) = + claim_candidate_bundle_with_reward(reward_account.clone()); + System::set_block_number(1); + let bundle = Bundles::::get(bundle_id).expect("bundle stored"); + let candidate = L0Candidates::::get(candidate_id).expect("candidate stored"); + let account_data = public_outputs_from_candidate(candidate_id); + let prepared = pallet_wormhole::Pallet::::prepare_public_output_settlement( + &account_data, + VolumeFeeRateBps::get(), + pallet_wormhole::SettlementKind::DelegatedL1 { + aggregation_reward_account: reward_account.clone(), + }, + ) + .expect("settlement prepares"); + let fee_share = prepared.aggregation_prover_fee; + let expected_exit_amount = expected_exit_amount_for(&account_data, &reward_account); + let reward_balance_before = Balances::balance(&reward_account); + + assert!(fee_share > 0); + assert_ok!(MinerAggregation::settle_verified_l1_bundle( + bundle_id, + bundle, + nullifiers, + &account_data, + VolumeFeeRateBps::get() + )); + + assert_eq!( + Balances::balance(&reward_account), + reward_balance_before + candidate.aggregation_tip + expected_exit_amount + fee_share + ); + System::assert_has_event( + crate::Event::::AggregationRewardPaid { + bundle_id, + reward_account, + tips_paid: candidate.aggregation_tip, + fee_share_paid: fee_share, + } + .into(), + ); + }); +} + +#[test] +fn pending_invalid_candidate_challenge_rewards_challenger() { + new_test_ext().execute_with(|| { + let (candidate_id, group_key) = submit_invalid_candidate(); + let challenger = account_id(2); + let submitter = account_id(1); + let challenger_balance_before = Balances::balance(&challenger); + let submitter_total_before = total_balance(&submitter); + let expected_reward = InvalidCandidateChallengeReward::get() * ValidityBond::get(); + + assert_ok!(MinerAggregation::challenge_invalid_l0_candidate( + RuntimeOrigin::signed(challenger.clone()), + candidate_id + )); + + assert_eq!(Balances::balance(&challenger), challenger_balance_before + expected_reward); + assert_eq!(total_balance(&submitter), submitter_total_before - ValidityBond::get()); + assert_eq!(Balances::reserved_balance(&submitter), 0); + assert!(PendingQueues::::get(&group_key).is_empty()); + assert_eq!( + L0Candidates::::get(candidate_id).expect("candidate stored").status, + L0CandidateStatus::ChallengedInvalid + ); + }); +} + +#[test] +fn pending_valid_candidate_challenge_does_not_slash() { + new_test_ext().execute_with(|| { + let (candidate_id, _group_key) = submit_candidate(); + let reserved_before = Balances::reserved_balance(&account_id(1)); + let total_before = total_balance(&account_id(1)); + + assert_noop!( + MinerAggregation::challenge_invalid_l0_candidate( + RuntimeOrigin::signed(account_id(2)), + candidate_id + ), + Error::::CandidateValid + ); + + let candidate = L0Candidates::::get(candidate_id).expect("candidate stored"); + assert_eq!(candidate.status, L0CandidateStatus::Pending); + assert_eq!(Balances::reserved_balance(&account_id(1)), reserved_before); + assert_eq!(total_balance(&account_id(1)), total_before); + }); +} + +#[test] +fn claimed_invalid_candidate_challenge_unlocks_nullifiers() { + new_test_ext().execute_with(|| { + let (candidate_id, bundle_id, nullifiers) = claim_invalid_candidate_bundle(); + for nullifier in &nullifiers { + assert!(Wormhole::is_nullifier_locked(nullifier)); + } + + assert_ok!(MinerAggregation::challenge_invalid_l0_in_bundle( + RuntimeOrigin::signed(account_id(3)), + bundle_id, + candidate_id + )); + + for nullifier in &nullifiers { + assert!(!Wormhole::is_nullifier_locked(nullifier)); + assert!(!Wormhole::is_nullifier_used(nullifier)); + } + assert_eq!( + L0Candidates::::get(candidate_id).expect("candidate stored").status, + L0CandidateStatus::ChallengedInvalid + ); + assert_eq!( + Bundles::::get(bundle_id).expect("bundle stored").status, + BundleStatus::Challenged + ); + }); +} + +#[test] +fn claimed_invalid_candidate_challenge_requeues_other_candidates() { + new_test_ext().execute_with(|| { + let (candidate_id, bundle_id, _nullifiers) = claim_invalid_candidate_bundle(); + let synthetic_id = add_synthetic_claimed_candidate_to_bundle(bundle_id); + let synthetic_nullifier = + L0Candidates::::get(synthetic_id).expect("candidate stored").nullifiers[0]; + assert!(Wormhole::is_nullifier_locked(&synthetic_nullifier)); + + assert_ok!(MinerAggregation::challenge_invalid_l0_in_bundle( + RuntimeOrigin::signed(account_id(3)), + bundle_id, + candidate_id + )); + + let synthetic = L0Candidates::::get(synthetic_id).expect("candidate stored"); + assert_eq!(synthetic.status, L0CandidateStatus::Pending); + assert!(!Wormhole::is_nullifier_locked(&synthetic_nullifier)); + assert_eq!(PendingQueues::::get(&synthetic.group_key).as_slice(), &[synthetic_id]); + }); +} + +#[test] +fn claimed_invalid_candidate_challenge_decrements_active_jobs() { + new_test_ext().execute_with(|| { + let (candidate_id, bundle_id, _nullifiers) = claim_invalid_candidate_bundle(); + let miner_total_before = total_balance(&account_id(2)); + let challenger_balance_before = Balances::balance(&account_id(3)); + let expected_miner_slash = InvalidClaimSlash::get() * MinMinerBond::get(); + let expected_challenge_reward = + InvalidCandidateChallengeReward::get() * ValidityBond::get(); + + assert_ok!(MinerAggregation::challenge_invalid_l0_in_bundle( + RuntimeOrigin::signed(account_id(3)), + bundle_id, + candidate_id + )); + + assert!(MinerActiveBundles::::get(account_id(2)).is_empty()); + assert_eq!( + RegisteredAggregators::::get(account_id(2)) + .expect("aggregator registered") + .active_jobs, + 0 + ); + assert_eq!(Balances::reserved_balance(&account_id(2)), 100); + assert_eq!(total_balance(&account_id(2)), miner_total_before - expected_miner_slash); + assert_eq!( + Balances::balance(&account_id(3)), + challenger_balance_before + expected_challenge_reward + ); + }); +} + +#[test] +fn drop_expired_candidate_refunds_reserves_and_removes_queue_entry() { + new_test_ext().execute_with(|| { + let (candidate_id, group_key) = submit_candidate(); + assert_eq!(Balances::reserved_balance(&account_id(1)), 35); + + System::set_block_number(CandidateLifetime::get() + 1); + assert_ok!(MinerAggregation::drop_expired_candidate( + RuntimeOrigin::signed(account_id(2)), + candidate_id + )); + + let candidate = L0Candidates::::get(candidate_id).expect("candidate stored"); + assert_eq!(candidate.status, L0CandidateStatus::Expired); + assert!(PendingQueues::::get(&group_key).is_empty()); + assert_eq!(Balances::reserved_balance(&account_id(1)), 0); + }); +} diff --git a/pallets/miner-aggregation/src/weights.rs b/pallets/miner-aggregation/src/weights.rs new file mode 100644 index 00000000..17fa6679 --- /dev/null +++ b/pallets/miner-aggregation/src/weights.rs @@ -0,0 +1,135 @@ +use core::marker::PhantomData; +use frame_support::weights::Weight; + +// Conservative placeholder weights for delegated L1 aggregation. +// +// These values are intentionally explicit but are not benchmark-generated. +// TODO: Replace them with autogenerated benchmark output before merging. +const SUBMIT_L0_CANDIDATE: Weight = Weight::from_parts(150_000_000, 0); +const REGISTER_AGGREGATOR: Weight = Weight::from_parts(25_000_000, 0); +const UPDATE_AGGREGATOR: Weight = Weight::from_parts(25_000_000, 0); +const UNREGISTER_AGGREGATOR: Weight = Weight::from_parts(25_000_000, 0); +const CLAIM_BUNDLE: Weight = Weight::from_parts(175_000_000, 0); +const SUBMIT_L1_AGGREGATE_CHEAP_REJECT: Weight = Weight::from_parts(75_000_000, 0); +const SUBMIT_L1_AGGREGATE_VALID_PROOF: Weight = Weight::from_parts(750_000_000, 0); +const TIMEOUT_BUNDLE: Weight = Weight::from_parts(75_000_000, 0); +const CHALLENGE_INVALID_L0_CANDIDATE: Weight = Weight::from_parts(600_000_000, 0); +const CHALLENGE_INVALID_L0_IN_BUNDLE: Weight = Weight::from_parts(700_000_000, 0); +const DROP_EXPIRED_CANDIDATE: Weight = Weight::from_parts(35_000_000, 0); + +pub trait WeightInfo { + fn submit_l0_candidate() -> Weight; + fn register_aggregator() -> Weight; + fn update_aggregator() -> Weight; + fn unregister_aggregator() -> Weight; + fn claim_bundle() -> Weight; + fn timeout_bundle() -> Weight; + fn submit_l1_aggregate_cheap_reject() -> Weight; + fn submit_l1_aggregate_valid_proof() -> Weight; + fn submit_l1_aggregate() -> Weight; + fn challenge_invalid_l0_candidate() -> Weight; + fn challenge_invalid_l0_in_bundle() -> Weight; + fn drop_expired_candidate() -> Weight; +} + +pub struct SubstrateWeight(PhantomData); + +impl WeightInfo for SubstrateWeight { + fn submit_l0_candidate() -> Weight { + SUBMIT_L0_CANDIDATE + } + + fn register_aggregator() -> Weight { + REGISTER_AGGREGATOR + } + + fn update_aggregator() -> Weight { + UPDATE_AGGREGATOR + } + + fn unregister_aggregator() -> Weight { + UNREGISTER_AGGREGATOR + } + + fn claim_bundle() -> Weight { + CLAIM_BUNDLE + } + + fn timeout_bundle() -> Weight { + TIMEOUT_BUNDLE + } + + fn submit_l1_aggregate_cheap_reject() -> Weight { + SUBMIT_L1_AGGREGATE_CHEAP_REJECT + } + + fn submit_l1_aggregate_valid_proof() -> Weight { + SUBMIT_L1_AGGREGATE_VALID_PROOF + } + + fn submit_l1_aggregate() -> Weight { + Self::submit_l1_aggregate_valid_proof() + } + + fn challenge_invalid_l0_candidate() -> Weight { + CHALLENGE_INVALID_L0_CANDIDATE + } + + fn challenge_invalid_l0_in_bundle() -> Weight { + CHALLENGE_INVALID_L0_IN_BUNDLE + } + + fn drop_expired_candidate() -> Weight { + DROP_EXPIRED_CANDIDATE + } +} + +impl WeightInfo for () { + fn submit_l0_candidate() -> Weight { + SUBMIT_L0_CANDIDATE + } + + fn register_aggregator() -> Weight { + REGISTER_AGGREGATOR + } + + fn update_aggregator() -> Weight { + UPDATE_AGGREGATOR + } + + fn unregister_aggregator() -> Weight { + UNREGISTER_AGGREGATOR + } + + fn claim_bundle() -> Weight { + CLAIM_BUNDLE + } + + fn timeout_bundle() -> Weight { + TIMEOUT_BUNDLE + } + + fn submit_l1_aggregate_cheap_reject() -> Weight { + SUBMIT_L1_AGGREGATE_CHEAP_REJECT + } + + fn submit_l1_aggregate_valid_proof() -> Weight { + SUBMIT_L1_AGGREGATE_VALID_PROOF + } + + fn submit_l1_aggregate() -> Weight { + Self::submit_l1_aggregate_valid_proof() + } + + fn challenge_invalid_l0_candidate() -> Weight { + CHALLENGE_INVALID_L0_CANDIDATE + } + + fn challenge_invalid_l0_in_bundle() -> Weight { + CHALLENGE_INVALID_L0_IN_BUNDLE + } + + fn drop_expired_candidate() -> Weight { + DROP_EXPIRED_CANDIDATE + } +} diff --git a/pallets/miner-aggregation/test-data/expected_bundle.json b/pallets/miner-aggregation/test-data/expected_bundle.json new file mode 100644 index 00000000..dc678573 --- /dev/null +++ b/pallets/miner-aggregation/test-data/expected_bundle.json @@ -0,0 +1,160 @@ +{ + "l0_candidates": [ + "l0_candidate_0.hex" + ], + "l1_aggregate": "l1_aggregate.hex", + "aggregator_address": "0200000000000000000000000000000000000000000000000000000000000000", + "asset_id": 0, + "volume_fee_bps": 10, + "block_hash": "a47a040727bce5a4c12f55e91e6cc9f6ec9aca51060a9fe6ad445a614639a2c8", + "block_number": 1, + "total_exit_slots": 32, + "exits": [ + { + "summed_output_amount": 887, + "exit_account": "be36df3efbb982854f48093637c8d4571ce92f68c0762133e86a122886053f8f" + }, + { + "summed_output_amount": 0, + "exit_account": "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + "summed_output_amount": 440, + "exit_account": "e435efda037969339d021ce0a192e72a9e123e24942b3defa327876f357abfac" + }, + { + "summed_output_amount": 0, + "exit_account": "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + "summed_output_amount": 678, + "exit_account": "863c4e0d9db88550295cc48bb08488f8e4f3a577470e6f7b7087583f3a254873" + }, + { + "summed_output_amount": 0, + "exit_account": "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + "summed_output_amount": 567, + "exit_account": "9d1f3fcfed70c0ea694088789c46f3122b89a2d60e4e4d67389daecebdf6bdce" + }, + { + "summed_output_amount": 0, + "exit_account": "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + "summed_output_amount": 1120, + "exit_account": "e220391a99f15c724947394a504796b23678b61fcb3e795ed44451c70129fb9c" + }, + { + "summed_output_amount": 0, + "exit_account": "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + "summed_output_amount": 442, + "exit_account": "40f8e3d2f0a2abd81f7f58e700dad67f60e8b1ee144b1de6248a4db90ae6df77" + }, + { + "summed_output_amount": 0, + "exit_account": "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + "summed_output_amount": 445, + "exit_account": "21ec8e915dea37e08762f8663104d0f32e5d2a812bb23cf679f31ae881f3cb52" + }, + { + "summed_output_amount": 0, + "exit_account": "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + "summed_output_amount": 1461, + "exit_account": "0ca74f8a8a602f821c64429672376c5b3b0f4d33745f9c3c9c629550c81eb984" + }, + { + "summed_output_amount": 0, + "exit_account": "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + "summed_output_amount": 148, + "exit_account": "773d024efb8a5552d941df129bd536b8987fbb05fedd4656e8db30f2c5ce4947" + }, + { + "summed_output_amount": 0, + "exit_account": "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + "summed_output_amount": 224, + "exit_account": "552bf0c2394ae831c9ad2d772b339f4275ef455a6bb521d5be7ffeb21f58b411" + }, + { + "summed_output_amount": 0, + "exit_account": "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + "summed_output_amount": 181, + "exit_account": "4e009bebd7d46e0ab75003f92c5ca41c54978ea91f2a66100503c142546d0a82" + }, + { + "summed_output_amount": 0, + "exit_account": "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + "summed_output_amount": 599, + "exit_account": "a42ac4d6ce690210f38b532c81443eda19c7c2047e2ff5e11447b070608dfb27" + }, + { + "summed_output_amount": 0, + "exit_account": "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + "summed_output_amount": 1301, + "exit_account": "cde2304ddaf087e1097b383793e9975e4eb575017bbe1ef03d895788e54998b7" + }, + { + "summed_output_amount": 0, + "exit_account": "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + "summed_output_amount": 358, + "exit_account": "6a9e74c5ac1856189b64b338626a90f8bbef0704fa7b7d7ffbf392909363eeb8" + }, + { + "summed_output_amount": 0, + "exit_account": "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + "summed_output_amount": 957, + "exit_account": "6305d547687e54aee4d17dc9f33fc584776b878ef6d2c6522785c145aab7056a" + }, + { + "summed_output_amount": 0, + "exit_account": "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + "summed_output_amount": 166, + "exit_account": "92d704b5ddbd0059615f64761285e0da77dcdfe285fdf3e4dd7d4ae57a75b347" + }, + { + "summed_output_amount": 0, + "exit_account": "0000000000000000000000000000000000000000000000000000000000000000" + } + ], + "nullifiers": [ + "18c09077b62e273d650d1665c64869c00d4ac657092da76753ee19cd84aa952d", + "c6306fdf45973f254252f412aea21181ba8e33a04f5c39a9f123d3f95402d2c0", + "cf9c5d7dd64caed3112c3f76167a4e0d0f52300e9534a17eb305ea7334bb2013", + "671ff527956b7efe70b34f4e92ddcceebad8cd99ed188406698e744391621446", + "de6adb5434fd2c3c3894e0f7823b89a54e32a400fc2cd94a3a68998f2e2905ab", + "400425f36208f1ec3b3eaf9f78d85036a8ed9f594704db984c45ce97b0afdb81", + "19b1fb0e50891358bcbbd531bbb99fb644f9feddd518eaed0b46f115ffe63ae4", + "64af58a48c74169db2652e51870a993adf141a0e4cc8e47c7a2fcef44a89d1d1", + "77d1734005ed2a5eb65acb43cb9f724d7e92d749617e0b0c037df08f6e5a17de", + "2ed1f54354e7229b5ed65f49e9208ff0d3dd4a789d08b982876fe1e8b022cd25", + "86952f9c570279b34ad3fe27df1c14ae673ed93efb32c33dfef07cb7aae3c27a", + "dd29bc300a2920c608dbcf31721e9efee2e02a90aa7754b29430a824a902da59", + "b15ec962d5a79806cda3d546fae3ad89760070b6762086ca473ded79c632a544", + "c0fbb95f42975020fec41460f456293783c2b50b6c9464b2c8b2ae418e32f539", + "9c3a16e64478d497695a026dbc964a2761f7f3f2cb86f5e157f6c5829716324f", + "0155d243017d56c20ad6b75ec2edf8eabfaa998821a347099d5e63691748358a" + ] +} \ No newline at end of file diff --git a/pallets/miner-aggregation/test-data/l0_candidate_0.hex b/pallets/miner-aggregation/test-data/l0_candidate_0.hex new file mode 100644 index 00000000..cf7b3cff --- /dev/null +++ b/pallets/miner-aggregation/test-data/l0_candidate_0.hex @@ -0,0 +1 @@ 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 diff --git a/pallets/miner-aggregation/test-data/l1_aggregate.hex b/pallets/miner-aggregation/test-data/l1_aggregate.hex new file mode 100644 index 00000000..0c686fb4 --- /dev/null +++ b/pallets/miner-aggregation/test-data/l1_aggregate.hex @@ -0,0 +1 @@ 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 diff --git a/pallets/wormhole/build.rs b/pallets/wormhole/build.rs index d58ca389..8ecfa89e 100644 --- a/pallets/wormhole/build.rs +++ b/pallets/wormhole/build.rs @@ -1,6 +1,6 @@ //! Build script for pallet-wormhole. //! -//! Generates circuit binaries (aggregated_verifier.bin, aggregated_common.bin) at build time. +//! Generates circuit binaries at build time. //! This ensures the binaries are always consistent with the circuit crate version and //! eliminates the need to commit large binary files to the repository. //! @@ -9,6 +9,13 @@ use std::{env, path::Path, time::Instant}; +fn env_flag(name: &str) -> bool { + matches!( + env::var(name).as_deref(), + Ok("1") | Ok("true") | Ok("TRUE") | Ok("yes") | Ok("YES") | Ok("on") | Ok("ON") + ) +} + /// Compute Poseidon2 hash of bytes and return hex string fn poseidon_hex(data: &[u8]) -> String { let hash = qp_poseidon_core::hash_bytes(data); @@ -29,26 +36,43 @@ fn print_bin_hash(dir: &Path, filename: &str) { } fn main() { + println!("cargo:rerun-if-env-changed=QP_NUM_LEAF_PROOFS"); + println!("cargo:rerun-if-env-changed=QP_NUM_LAYER0_PROOFS"); + println!("cargo:rerun-if-env-changed=QP_GENERATE_LAYER1"); + println!("cargo:rustc-check-cfg=cfg(wormhole_layer1_verifier)"); + let out_dir = env::var("OUT_DIR").expect("OUT_DIR not set"); let num_leaf_proofs: usize = env::var("QP_NUM_LEAF_PROOFS") .unwrap_or_else(|_| "16".to_string()) .parse() .expect("QP_NUM_LEAF_PROOFS must be a valid usize"); + let generate_layer1 = env_flag("QP_GENERATE_LAYER1"); + let num_layer0_proofs = if generate_layer1 { + let value: usize = env::var("QP_NUM_LAYER0_PROOFS") + .expect("QP_NUM_LAYER0_PROOFS must be set when QP_GENERATE_LAYER1=true") + .parse() + .expect("QP_NUM_LAYER0_PROOFS must be a valid usize"); + println!("cargo:rustc-cfg=wormhole_layer1_verifier"); + Some(value) + } else { + None + }; // cargo:warning= messages are shown during build when the script runs println!( - "cargo:warning=[pallet-wormhole] Generating ZK circuit binaries (num_leaf_proofs={})...", - num_leaf_proofs + "cargo:warning=[pallet-wormhole] Generating ZK circuit binaries (num_leaf_proofs={}, num_layer0_proofs={})...", + num_leaf_proofs, + num_layer0_proofs.unwrap_or(0) ); let start = Instant::now(); - // Generate all circuit binaries (leaf + layer-0 aggregated, no prover, no layer-1) + // Generate verifier artifacts only. Prover artifacts are intentionally not embedded in runtime. qp_wormhole_circuit_builder::generate_all_circuit_binaries( Path::new(&out_dir), false, // include_prover = false num_leaf_proofs, - None, // num_layer0_proofs - no layer-1 aggregation + num_layer0_proofs, ) .expect("Failed to generate circuit binaries"); @@ -65,4 +89,8 @@ fn main() { print_bin_hash(out_path, "dummy_proof.bin"); print_bin_hash(out_path, "aggregated_common.bin"); print_bin_hash(out_path, "aggregated_verifier.bin"); + if num_layer0_proofs.is_some() { + print_bin_hash(out_path, "layer1_common.bin"); + print_bin_hash(out_path, "layer1_verifier.bin"); + } } diff --git a/pallets/wormhole/src/lib.rs b/pallets/wormhole/src/lib.rs index 9b4ff8fe..0327e287 100644 --- a/pallets/wormhole/src/lib.rs +++ b/pallets/wormhole/src/lib.rs @@ -24,11 +24,32 @@ lazy_static! { }; } +#[cfg(wormhole_layer1_verifier)] +lazy_static! { + static ref LAYER1_VERIFIER: Option = { + let verifier_bytes = include_bytes!(concat!(env!("OUT_DIR"), "/layer1_verifier.bin")); + let common_bytes = include_bytes!(concat!(env!("OUT_DIR"), "/layer1_common.bin")); + WormholeVerifier::new_from_bytes(verifier_bytes, common_bytes).ok() + }; +} + /// Getter for the aggregated proof verifier pub fn get_aggregated_verifier() -> Result<&'static WormholeVerifier, &'static str> { AGGREGATED_VERIFIER.as_ref().ok_or("Aggregated verifier not available") } +/// Getter for the layer-1 aggregated proof verifier. +#[cfg(wormhole_layer1_verifier)] +pub fn get_layer1_verifier() -> Result<&'static WormholeVerifier, &'static str> { + LAYER1_VERIFIER.as_ref().ok_or("Layer1 verifier not available") +} + +/// Getter for the layer-1 aggregated proof verifier when L1 artifacts were not generated. +#[cfg(not(wormhole_layer1_verifier))] +pub fn get_layer1_verifier() -> Result<&'static WormholeVerifier, &'static str> { + Err("Layer1 verifier not available") +} + /// Scale factor for quantizing amounts from 12 to 2 decimal places (10^10). /// Amounts in the circuit are stored as u32 with 2 decimal places of precision. /// On-chain amounts use 12 decimal places, so we multiply by this factor when @@ -48,15 +69,17 @@ pub mod pallet { fungibles::{self}, BuildGenesisConfig, Currency, }, + transactional, }; use frame_system::pallet_prelude::*; use pallet_zk_tree::ZkTreeRecorder; use qp_wormhole_verifier::{ - parse_aggregated_public_inputs, AggregatedPublicCircuitInputs, ProofWithPublicInputs, C, D, - F, + parse_aggregated_public_inputs, parse_layer1_aggregated_public_inputs, + AggregatedPublicCircuitInputs, Layer1AggregatedPublicCircuitInputs, ProofWithPublicInputs, + PublicInputsByAccount, C, D, F, }; use sp_runtime::{ - traits::{MaybeDisplay, One, Saturating, Zero}, + traits::{CheckedAdd, MaybeDisplay, One, Saturating, Zero}, transaction_validity::{ InvalidTransaction, TransactionSource, TransactionValidity, ValidTransaction, }, @@ -66,6 +89,24 @@ pub mod pallet { pub type BalanceOf = ::NativeBalance; pub type AssetBalanceOf = ::AssetBalance; + #[derive(Clone, PartialEq, Eq, RuntimeDebug)] + pub enum SettlementKind { + DirectL0, + DelegatedL1 { aggregation_reward_account: AccountId }, + } + + #[derive(Clone, PartialEq, Eq, RuntimeDebug)] + pub struct PreparedPublicOutputSettlement { + pub transfers: Vec<(AccountId, Balance)>, + pub total_exit_amount: Balance, + pub total_fee: Balance, + pub burn_amount: Balance, + pub block_author_fee: Balance, + pub aggregation_prover_fee: Balance, + pub block_author: Option, + pub aggregation_reward_account: Option, + } + #[pallet::pallet] pub struct Pallet(_); @@ -180,11 +221,17 @@ pub mod pallet { #[pallet::constant] type VolumeFeeRateBps: Get; - /// Proportion of volume fees to burn (not mint). The remainder goes to the block author. - /// Example: Permill::from_percent(50) means 50% burned, 50% to miner. + /// Proportion of volume fees to burn (not mint). For direct L0 settlements, the remainder + /// goes to the block author when one is available. For delegated L1 settlements, the + /// non-burned remainder is split between the aggregation prover and block author. #[pallet::constant] type VolumeFeesBurnRate: Get; + /// Proportion of the non-burned delegated L1 fee paid to the aggregation prover. + /// Direct L0 settlement ignores this value to preserve existing fee behavior. + #[pallet::constant] + type AggregationProverFeeShare: Get; + /// Weight information for pallet operations. type WeightInfo: WeightInfo; @@ -209,11 +256,22 @@ pub mod pallet { >; } + #[derive(Encode, Decode, Clone, PartialEq, Eq, TypeInfo, MaxEncodedLen)] + pub struct NullifierLock { + pub bundle_id: [u8; 32], + pub expires_at: BlockNumber, + } + #[pallet::storage] #[pallet::getter(fn used_nullifiers)] pub(super) type UsedNullifiers = StorageMap<_, Blake2_128Concat, [u8; 32], bool, ValueQuery>; + #[pallet::storage] + #[pallet::getter(fn locked_nullifiers)] + pub type LockedNullifiers = + StorageMap<_, Blake2_128Concat, [u8; 32], NullifierLock>, OptionQuery>; + /// Transfer count per recipient - used to generate unique leaf indices in the ZK trie. #[pallet::storage] #[pallet::getter(fn transfer_count)] @@ -263,17 +321,31 @@ pub mod pallet { exit_amount: BalanceOf, nullifiers: Vec<[u8; 32]>, }, + WormholeFeeSettled { + total_fee: BalanceOf, + burn_amount: BalanceOf, + block_author_fee: BalanceOf, + aggregation_prover_fee: BalanceOf, + }, } #[pallet::error] pub enum Error { InvalidPublicInputs, NullifierAlreadyUsed, + NullifierLocked, + DuplicateNullifier, + NullifierNotLocked, + NullifierLockMismatch, BlockNotFound, AggregatedVerifierNotAvailable, AggregatedProofDeserializationFailed, AggregatedVerificationFailed, InvalidAggregatedPublicInputs, + Layer1VerifierNotAvailable, + Layer1ProofDeserializationFailed, + InvalidLayer1PublicInputs, + Layer1VerificationFailed, /// The volume fee rate in the proof doesn't match the configured rate InvalidVolumeFeeRate, /// Transfer amount is below the minimum required @@ -321,6 +393,7 @@ pub mod pallet { /// If ZK verification fails, we return full weight since the work was done. #[pallet::call_index(2)] #[pallet::weight(::WeightInfo::verify_aggregated_proof())] + #[transactional] pub fn verify_aggregated_proof( origin: OriginFor, proof_bytes: Vec, @@ -347,160 +420,22 @@ pub mod pallet { }, }; - // Mark nullifiers as used (validate_proof only checks existence) - let mut nullifier_list = Vec::<[u8; 32]>::new(); - for nullifier in &aggregated_inputs.nullifiers { - let nullifier_bytes: [u8; 32] = (*nullifier) - .as_ref() - .try_into() - .map_err(|_| Error::::InvalidAggregatedPublicInputs)?; - UsedNullifiers::::insert(nullifier_bytes, true); - nullifier_list.push(nullifier_bytes); - } - - // Get the minting account for recording transfer proofs - let mint_account = T::MintingAccount::get(); - - // First pass: compute total exit amount and prepare account data - let mut total_exit_amount: BalanceOf = Zero::zero(); - let mut processed_accounts: Vec<( - ::AccountId, - BalanceOf, - )> = Vec::with_capacity(aggregated_inputs.account_data.len()); - - for (idx, account_data) in aggregated_inputs.account_data.iter().enumerate() { - // Skip dummy account slots (exit_account == 0 with zero amount) - // Dummy proofs from aggregation padding have all-zero exit accounts - // Also skip deduplicated slots (the circuit zeros out duplicate exit accounts) - let exit_account_bytes: [u8; 32] = - (*account_data.exit_account).as_ref().try_into().map_err(|e| { - log::error!("Failed to convert exit_account at idx {}: {:?}", idx, e); - Error::::InvalidAggregatedPublicInputs - })?; - - if exit_account_bytes == [0u8; 32] || account_data.summed_output_amount == 0 { - continue; - } - - // Convert output amount to Balance type (scale up from quantized value) - let exit_balance_u128 = (account_data.summed_output_amount as u128) - .saturating_mul(crate::SCALE_DOWN_FACTOR); - let exit_balance: BalanceOf = exit_balance_u128.try_into().map_err(|_| { - log::error!("Failed to convert exit_balance at idx {}", idx); - Error::::InvalidAggregatedPublicInputs - })?; + let nullifier_list = Self::collect_aggregated_nullifier_bytes(&aggregated_inputs)?; + let prepared = Self::prepare_public_output_settlement( + &aggregated_inputs.account_data, + aggregated_inputs.volume_fee_bps, + SettlementKind::DirectL0, + )?; - // Decode exit account from public inputs - let exit_account = - ::AccountId::decode(&mut &exit_account_bytes[..]) - .map_err(|_| Error::::InvalidAggregatedPublicInputs)?; - - total_exit_amount = total_exit_amount.saturating_add(exit_balance); - processed_accounts.push((exit_account, exit_balance)); - } - - // Ensure total exit amount meets the minimum transfer requirement - ensure!( - total_exit_amount >= T::MinimumTransferAmount::get(), - Error::::TransferAmountBelowMinimum - ); + // Mark nullifiers as used (validate_proof only checks availability) + Self::mark_nullifiers_used(&nullifier_list)?; // Emit event for each exit account Self::deposit_event(Event::ProofVerified { - exit_amount: total_exit_amount, + exit_amount: prepared.total_exit_amount, nullifiers: nullifier_list, }); - - // Compute the total fee from the input amounts - // fee = total_output_amount * volume_fee_bps / (10000 - volume_fee_bps) - // This is the fee that was deducted from input to get output. - let fee_bps = T::VolumeFeeRateBps::get() as u128; - let total_exit_u128: u128 = total_exit_amount.try_into().map_err(|_| { - log::error!("Failed to convert total_exit_amount to u128"); - Error::::InvalidAggregatedPublicInputs - })?; - let total_fee_u128 = total_exit_u128 - .saturating_mul(fee_bps) - .checked_div(10000u128.saturating_sub(fee_bps)) - .unwrap_or(0); - - // Fee distribution: configurable portion burned, remainder to miner - // - // Original deposit locked `input_amount` in an unspendable account (tokens still - // exist). On exit we mint `output_amount` to user, where: input >= output + fee - // - // Fee split (controlled by VolumeFeesBurnRate): - // - burn_amount = fee * burn_rate (reduces total issuance via Currency::burn) - // - miner_fee = fee - burn_amount (minted to block author via increase_balance) - // - // Supply accounting: - // - Minting exit amounts: increases balances but NOT issuance by sum(output_amounts) - // - Minting miner fee: increases balance but NOT issuance (increase_balance) - // - Burning: decreases total issuance by burn_amount - // - Net change: +sum(output_amounts) - burn_amount - let burn_rate = T::VolumeFeesBurnRate::get(); - let mut burn_amount_u128 = burn_rate * total_fee_u128; - let miner_fee_u128 = total_fee_u128.saturating_sub(burn_amount_u128); - let miner_fee: BalanceOf = miner_fee_u128.try_into().map_err(|_| { - log::error!("Failed to convert miner_fee_u128 to BalanceOf"); - Error::::InvalidAggregatedPublicInputs - })?; - - // Mint miner's portion of volume fee to block author - // If no author is found, add to burn amount instead of silently losing it - if !miner_fee.is_zero() { - let digest = frame_system::Pallet::::digest(); - if let Some(author) = qp_wormhole::extract_author_from_digest::< - ::AccountId, - _, - >(digest.logs.iter().cloned()) - { - >::increase_balance( - &author, - miner_fee, - frame_support::traits::tokens::Precision::Exact, - )?; - } else { - // No block author found - add miner fee to burn amount - log::warn!( - "No block author found, burning miner fee of {:?} instead", - miner_fee - ); - burn_amount_u128 = burn_amount_u128.saturating_add(miner_fee_u128); - } - } - - // Burn the total burn amount (base burn + any orphaned miner fee) - let burn_amount: BalanceOf = burn_amount_u128.try_into().map_err(|_| { - log::error!("Failed to convert burn_amount_u128 to BalanceOf"); - Error::::InvalidAggregatedPublicInputs - })?; - if !burn_amount.is_zero() { - let current = >::total_issuance(); - >::set_total_issuance( - current.saturating_sub(burn_amount), - ); - } - - // Process transfers and record proofs - for (exit_account, exit_balance) in &processed_accounts { - // Native token transfer - mint tokens to the exit account - >::increase_balance( - exit_account, - *exit_balance, - frame_support::traits::tokens::Precision::Exact, - )?; - - // Record transfer proof for the minted tokens - let from_account: ::WormholeAccountId = mint_account.clone().into(); - let to_account: ::WormholeAccountId = exit_account.clone().into(); - Self::record_transfer( - T::AssetId::default(), - &from_account, - &to_account, - *exit_balance, - ); - } + Self::apply_public_output_settlement(prepared)?; // Success - use declared weight (actual_weight: None means use declared weight) Ok(PostDispatchInfo { actual_weight: None, pays_fee: Pays::No }) @@ -547,6 +482,170 @@ pub mod pallet { } impl Pallet { + pub fn is_nullifier_used(nullifier: &[u8; 32]) -> bool { + UsedNullifiers::::contains_key(*nullifier) + } + + pub fn is_nullifier_locked(nullifier: &[u8; 32]) -> bool { + LockedNullifiers::::contains_key(*nullifier) + } + + pub fn ensure_no_duplicate_nullifiers(nullifiers: &[[u8; 32]]) -> Result<(), Error> { + let mut sorted = nullifiers.to_vec(); + sorted.sort(); + for pair in sorted.windows(2) { + if pair[0] == pair[1] { + return Err(Error::::DuplicateNullifier); + } + } + Ok(()) + } + + pub fn ensure_nullifiers_available_for_direct_settlement( + nullifiers: &[[u8; 32]], + ) -> Result<(), Error> { + Self::ensure_no_duplicate_nullifiers(nullifiers)?; + for nullifier in nullifiers { + ensure!(!Self::is_nullifier_used(nullifier), Error::::NullifierAlreadyUsed); + ensure!(!Self::is_nullifier_locked(nullifier), Error::::NullifierLocked); + } + Ok(()) + } + + pub fn lock_nullifiers_for_bundle( + bundle_id: [u8; 32], + expires_at: BlockNumberFor, + nullifiers: &[[u8; 32]], + ) -> Result<(), Error> { + Self::ensure_nullifiers_available_for_direct_settlement(nullifiers)?; + + for nullifier in nullifiers { + LockedNullifiers::::insert(*nullifier, NullifierLock { bundle_id, expires_at }); + } + + Ok(()) + } + + pub fn unlock_nullifiers_for_bundle( + bundle_id: [u8; 32], + nullifiers: &[[u8; 32]], + ) -> Result<(), Error> { + Self::ensure_no_duplicate_nullifiers(nullifiers)?; + + for nullifier in nullifiers { + let lock = + LockedNullifiers::::get(*nullifier).ok_or(Error::::NullifierNotLocked)?; + ensure!(lock.bundle_id == bundle_id, Error::::NullifierLockMismatch); + } + + for nullifier in nullifiers { + LockedNullifiers::::remove(*nullifier); + } + + Ok(()) + } + + pub fn mark_nullifiers_used(nullifiers: &[[u8; 32]]) -> Result<(), Error> { + Self::ensure_no_duplicate_nullifiers(nullifiers)?; + + for nullifier in nullifiers { + UsedNullifiers::::insert(*nullifier, true); + } + + Ok(()) + } + + pub fn mark_locked_nullifiers_used( + bundle_id: [u8; 32], + nullifiers: &[[u8; 32]], + ) -> Result<(), Error> { + Self::ensure_nullifiers_locked_by_bundle(bundle_id, nullifiers)?; + + for nullifier in nullifiers { + UsedNullifiers::::insert(*nullifier, true); + LockedNullifiers::::remove(*nullifier); + } + + Ok(()) + } + + pub fn ensure_nullifiers_locked_by_bundle( + bundle_id: [u8; 32], + nullifiers: &[[u8; 32]], + ) -> Result<(), Error> { + Self::ensure_no_duplicate_nullifiers(nullifiers)?; + + for nullifier in nullifiers { + let lock = + LockedNullifiers::::get(*nullifier).ok_or(Error::::NullifierNotLocked)?; + ensure!(lock.bundle_id == bundle_id, Error::::NullifierLockMismatch); + } + + Ok(()) + } + + fn collect_aggregated_nullifier_bytes( + inputs: &AggregatedPublicCircuitInputs, + ) -> Result, Error> { + inputs + .nullifiers + .iter() + .map(|nullifier| { + (*nullifier) + .as_ref() + .try_into() + .map_err(|_| Error::::InvalidAggregatedPublicInputs) + }) + .collect() + } + + pub fn deserialize_aggregated_proof( + proof_bytes: &[u8], + ) -> Result, Error> { + let verifier = crate::get_aggregated_verifier() + .map_err(|_| Error::::AggregatedVerifierNotAvailable)?; + ProofWithPublicInputs::::from_bytes( + proof_bytes.to_vec(), + &verifier.circuit_data.common, + ) + .map_err(|_| Error::::AggregatedProofDeserializationFailed) + } + + pub fn parse_aggregated_inputs_from_proof( + proof: &ProofWithPublicInputs, + ) -> Result> { + parse_aggregated_public_inputs(proof) + .map_err(|_| Error::::InvalidAggregatedPublicInputs) + } + + pub fn verify_aggregated_proof_for_candidate( + proof_bytes: &[u8], + ) -> Result> { + let verifier = crate::get_aggregated_verifier() + .map_err(|_| Error::::AggregatedVerifierNotAvailable)?; + let proof = Self::deserialize_aggregated_proof(proof_bytes)?; + let inputs = Self::parse_aggregated_inputs_from_proof(&proof)?; + ensure!(inputs.asset_id == 0, Error::::NonNativeAssetNotSupported); + ensure!( + inputs.volume_fee_bps == T::VolumeFeeRateBps::get(), + Error::::InvalidVolumeFeeRate + ); + let block_number = BlockNumberFor::::from(inputs.block_data.block_number); + let block_hash = frame_system::Pallet::::block_hash(block_number); + ensure!(block_hash != T::Hash::default(), Error::::BlockNotFound); + ensure!( + block_hash.as_ref() == inputs.block_data.block_hash.as_ref(), + Error::::InvalidPublicInputs + ); + + verifier.verify(proof).map_err(|e| { + log::error!("Candidate aggregated proof verification failed: {:?}", e); + Error::::AggregatedVerificationFailed + })?; + + Ok(inputs) + } + /// Validate an aggregated proof (cheap checks + full ZK verification). /// Called by both validate_unsigned (pool gating) and dispatch (defense-in-depth). /// @@ -558,13 +657,8 @@ pub mod pallet { ) -> Result<(ProofWithPublicInputs, AggregatedPublicCircuitInputs), Error> { let verifier = crate::get_aggregated_verifier() .map_err(|_| Error::::AggregatedVerifierNotAvailable)?; - let proof = ProofWithPublicInputs::::from_bytes( - proof_bytes.to_vec(), - &verifier.circuit_data.common, - ) - .map_err(|_| Error::::AggregatedProofDeserializationFailed)?; - let inputs = parse_aggregated_public_inputs(&proof) - .map_err(|_| Error::::InvalidAggregatedPublicInputs)?; + let proof = Self::deserialize_aggregated_proof(proof_bytes)?; + let inputs = Self::parse_aggregated_inputs_from_proof(&proof)?; ensure!(inputs.asset_id == 0, Error::::NonNativeAssetNotSupported); ensure!( inputs.volume_fee_bps == T::VolumeFeeRateBps::get(), @@ -577,16 +671,8 @@ pub mod pallet { block_hash.as_ref() == inputs.block_data.block_hash.as_ref(), Error::::InvalidPublicInputs ); - for nullifier in &inputs.nullifiers { - let bytes: [u8; 32] = (*nullifier) - .as_ref() - .try_into() - .map_err(|_| Error::::InvalidAggregatedPublicInputs)?; - ensure!( - !UsedNullifiers::::contains_key(bytes), - Error::::NullifierAlreadyUsed - ); - } + let nullifiers = Self::collect_aggregated_nullifier_bytes(&inputs)?; + Self::ensure_nullifiers_available_for_direct_settlement(&nullifiers)?; // Full ZK verification - if this fails, full verification weight was consumed verifier.verify(proof.clone()).map_err(|e| { @@ -597,6 +683,236 @@ pub mod pallet { Ok((proof, inputs)) } + /// Deserialize a layer-1 aggregated proof using the layer-1 common circuit data. + /// + /// This intentionally does not verify the proof. Callers can parse public inputs and run + /// cheap bundle/effects checks before paying the full ZK verification cost. + pub fn deserialize_layer1_proof( + proof_bytes: &[u8], + ) -> Result, Error> { + let verifier = + crate::get_layer1_verifier().map_err(|_| Error::::Layer1VerifierNotAvailable)?; + ProofWithPublicInputs::::from_bytes( + proof_bytes.to_vec(), + &verifier.circuit_data.common, + ) + .map_err(|_| Error::::Layer1ProofDeserializationFailed) + } + + /// Parse layer-1 public inputs from an already-deserialized proof. + pub fn parse_layer1_inputs_from_proof( + proof: &ProofWithPublicInputs, + ) -> Result> { + parse_layer1_aggregated_public_inputs(proof) + .map_err(|_| Error::::InvalidLayer1PublicInputs) + } + + /// Verify an already-deserialized layer-1 aggregated proof. + pub fn verify_layer1_proof(proof: &ProofWithPublicInputs) -> Result<(), Error> { + let verifier = + crate::get_layer1_verifier().map_err(|_| Error::::Layer1VerifierNotAvailable)?; + verifier.verify_ref(proof).map_err(|e| { + log::error!("Layer-1 aggregated proof verification failed: {:?}", e); + Error::::Layer1VerificationFailed + }) + } + + pub fn settle_public_outputs( + account_data: &[PublicInputsByAccount], + volume_fee_bps: u32, + ) -> Result, Error> { + let prepared = Self::prepare_public_output_settlement( + account_data, + volume_fee_bps, + SettlementKind::DirectL0, + )?; + Self::apply_public_output_settlement(prepared) + } + + pub fn prepare_public_output_settlement( + account_data: &[PublicInputsByAccount], + volume_fee_bps: u32, + settlement_kind: SettlementKind<::AccountId>, + ) -> Result< + PreparedPublicOutputSettlement<::AccountId, BalanceOf>, + Error, + > { + let mut total_exit_amount: BalanceOf = Zero::zero(); + let mut transfers: Vec<(::AccountId, BalanceOf)> = + Vec::with_capacity(account_data.len()); + + for (idx, account_data) in account_data.iter().enumerate() { + let exit_account_bytes: [u8; 32] = + (*account_data.exit_account).as_ref().try_into().map_err(|e| { + log::error!("Failed to convert exit_account at idx {}: {:?}", idx, e); + Error::::InvalidAggregatedPublicInputs + })?; + + if exit_account_bytes == [0u8; 32] || account_data.summed_output_amount == 0 { + continue; + } + + let exit_balance_u128 = (account_data.summed_output_amount as u128) + .saturating_mul(crate::SCALE_DOWN_FACTOR); + let exit_balance: BalanceOf = exit_balance_u128.try_into().map_err(|_| { + log::error!("Failed to convert exit_balance at idx {}", idx); + Error::::InvalidAggregatedPublicInputs + })?; + + let exit_account = + ::AccountId::decode(&mut &exit_account_bytes[..]) + .map_err(|_| Error::::InvalidAggregatedPublicInputs)?; + + total_exit_amount = + total_exit_amount.checked_add(&exit_balance).ok_or_else(|| { + log::error!("Failed to add exit_balance at idx {}", idx); + Error::::InvalidAggregatedPublicInputs + })?; + transfers.push((exit_account, exit_balance)); + } + + ensure!( + total_exit_amount >= T::MinimumTransferAmount::get(), + Error::::TransferAmountBelowMinimum + ); + + let fee_bps = volume_fee_bps as u128; + ensure!(fee_bps < 10_000, Error::::InvalidAggregatedPublicInputs); + let total_exit_u128: u128 = total_exit_amount.try_into().map_err(|_| { + log::error!("Failed to convert total_exit_amount to u128"); + Error::::InvalidAggregatedPublicInputs + })?; + let total_fee_u128 = total_exit_u128 + .saturating_mul(fee_bps) + .checked_div(10000u128.saturating_sub(fee_bps)) + .unwrap_or(0); + + let burn_rate = T::VolumeFeesBurnRate::get(); + let mut burn_amount_u128 = burn_rate * total_fee_u128; + let non_burned_fee_u128 = total_fee_u128.saturating_sub(burn_amount_u128); + let (aggregation_reward_account, aggregation_prover_fee_u128) = match settlement_kind { + SettlementKind::DirectL0 => (None, 0), + SettlementKind::DelegatedL1 { aggregation_reward_account } => ( + Some(aggregation_reward_account), + T::AggregationProverFeeShare::get() * non_burned_fee_u128, + ), + }; + let block_author_fee_u128 = + non_burned_fee_u128.saturating_sub(aggregation_prover_fee_u128); + let block_author = if block_author_fee_u128 == 0 { + None + } else { + let digest = frame_system::Pallet::::digest(); + qp_wormhole::extract_author_from_digest::<::AccountId, _>( + digest.logs.iter().cloned(), + ) + }; + if block_author.is_none() { + burn_amount_u128 = burn_amount_u128.saturating_add(block_author_fee_u128); + } + + let total_fee: BalanceOf = total_fee_u128.try_into().map_err(|_| { + log::error!("Failed to convert total_fee_u128 to BalanceOf"); + Error::::InvalidAggregatedPublicInputs + })?; + let burn_amount: BalanceOf = burn_amount_u128.try_into().map_err(|_| { + log::error!("Failed to convert burn_amount_u128 to BalanceOf"); + Error::::InvalidAggregatedPublicInputs + })?; + let block_author_fee: BalanceOf = + if block_author.is_some() { block_author_fee_u128 } else { 0 } + .try_into() + .map_err(|_| { + log::error!("Failed to convert block_author_fee_u128 to BalanceOf"); + Error::::InvalidAggregatedPublicInputs + })?; + let aggregation_prover_fee: BalanceOf = + aggregation_prover_fee_u128.try_into().map_err(|_| { + log::error!("Failed to convert aggregation_prover_fee_u128 to BalanceOf"); + Error::::InvalidAggregatedPublicInputs + })?; + + Ok(PreparedPublicOutputSettlement { + transfers, + total_exit_amount, + total_fee, + burn_amount, + block_author_fee, + aggregation_prover_fee, + block_author, + aggregation_reward_account, + }) + } + + pub fn apply_public_output_settlement( + prepared: PreparedPublicOutputSettlement< + ::AccountId, + BalanceOf, + >, + ) -> Result, Error> { + let mint_account = T::MintingAccount::get(); + + if !prepared.block_author_fee.is_zero() { + let author = prepared + .block_author + .as_ref() + .ok_or(Error::::InvalidAggregatedPublicInputs)?; + >::increase_balance( + author, + prepared.block_author_fee, + frame_support::traits::tokens::Precision::Exact, + ) + .map_err(|_| Error::::InvalidAggregatedPublicInputs)?; + } + + if !prepared.aggregation_prover_fee.is_zero() { + let reward_target = prepared + .aggregation_reward_account + .as_ref() + .ok_or(Error::::InvalidAggregatedPublicInputs)?; + >::increase_balance( + reward_target, + prepared.aggregation_prover_fee, + frame_support::traits::tokens::Precision::Exact, + ) + .map_err(|_| Error::::InvalidAggregatedPublicInputs)?; + } + + if !prepared.burn_amount.is_zero() { + let current = >::total_issuance(); + >::set_total_issuance( + current.saturating_sub(prepared.burn_amount), + ); + } + + for (exit_account, exit_balance) in &prepared.transfers { + >::increase_balance( + exit_account, + *exit_balance, + frame_support::traits::tokens::Precision::Exact, + ) + .map_err(|_| Error::::InvalidAggregatedPublicInputs)?; + + let from_account: ::WormholeAccountId = mint_account.clone().into(); + let to_account: ::WormholeAccountId = exit_account.clone().into(); + Self::record_transfer( + T::AssetId::default(), + &from_account, + &to_account, + *exit_balance, + ); + } + + Self::deposit_event(Event::WormholeFeeSettled { + total_fee: prepared.total_fee, + burn_amount: prepared.burn_amount, + block_author_fee: prepared.block_author_fee, + aggregation_prover_fee: prepared.aggregation_prover_fee, + }); + + Ok(prepared.total_exit_amount) + } + /// Record a transfer in the ZK tree and emit events. /// /// This inserts the transfer data into the 4-ary Poseidon Merkle tree diff --git a/pallets/wormhole/src/mock.rs b/pallets/wormhole/src/mock.rs index dab7c7f1..0d352526 100644 --- a/pallets/wormhole/src/mock.rs +++ b/pallets/wormhole/src/mock.rs @@ -124,6 +124,8 @@ parameter_types! { pub const VolumeFeeRateBps: u32 = 10; /// Proportion of volume fees to burn (50% burned, 50% to miner) pub const VolumeFeesBurnRate: Permill = Permill::from_percent(50); + /// Proportion of non-burned delegated fees paid to aggregation prover. + pub const AggregationProverFeeShare: Permill = Permill::from_percent(25); } impl pallet_wormhole::Config for Test { @@ -137,6 +139,7 @@ impl pallet_wormhole::Config for Test { type MinimumTransferAmount = MinimumTransferAmount; type VolumeFeeRateBps = VolumeFeeRateBps; type VolumeFeesBurnRate = VolumeFeesBurnRate; + type AggregationProverFeeShare = AggregationProverFeeShare; type WormholeAccountId = AccountId; type WeightInfo = crate::weights::SubstrateWeight; type ZkTree = (); // Disabled in tests - use () no-op implementation diff --git a/pallets/wormhole/src/tests.rs b/pallets/wormhole/src/tests.rs index 1ea8c487..c5f923a8 100644 --- a/pallets/wormhole/src/tests.rs +++ b/pallets/wormhole/src/tests.rs @@ -8,7 +8,9 @@ mod wormhole_tests { Currency, }, }; + use qp_wormhole_verifier::{BytesDigest, PublicInputsByAccount}; use sp_core::crypto::AccountId32; + use sp_runtime::DigestItem; /// Well-known test secret for genesis endowment (matches runtime preset). /// This secret can be used with `quantus wormhole prove` to spend funds @@ -31,6 +33,289 @@ mod wormhole_tests { AccountId32::new(TEST_ADDRESS) } + #[test] + fn layer1_verifier_getter_reflects_build_configuration() { + #[cfg(wormhole_layer1_verifier)] + assert!(crate::get_layer1_verifier().is_ok()); + + #[cfg(not(wormhole_layer1_verifier))] + assert_eq!(crate::get_layer1_verifier().unwrap_err(), "Layer1 verifier not available"); + } + + #[test] + fn layer1_deserialization_uses_layer1_artifact_state() { + new_test_ext().execute_with(|| { + let err = Wormhole::deserialize_layer1_proof(&[]).unwrap_err(); + + #[cfg(wormhole_layer1_verifier)] + assert!(matches!(err, crate::Error::::Layer1ProofDeserializationFailed)); + + #[cfg(not(wormhole_layer1_verifier))] + assert!(matches!(err, crate::Error::::Layer1VerifierNotAvailable)); + }); + } + + #[test] + fn direct_l0_nullifier_validation_rejects_used_locked_and_duplicates() { + new_test_ext().execute_with(|| { + let n1 = [1u8; 32]; + let n2 = [2u8; 32]; + let bundle_id = [9u8; 32]; + + assert_ok!(Wormhole::ensure_nullifiers_available_for_direct_settlement(&[n1, n2])); + + let err = + Wormhole::ensure_nullifiers_available_for_direct_settlement(&[n1, n1]).unwrap_err(); + assert!(matches!(err, crate::Error::::DuplicateNullifier)); + + assert_ok!(Wormhole::mark_nullifiers_used(&[n1])); + let err = + Wormhole::ensure_nullifiers_available_for_direct_settlement(&[n1]).unwrap_err(); + assert!(matches!(err, crate::Error::::NullifierAlreadyUsed)); + + assert_ok!(Wormhole::lock_nullifiers_for_bundle(bundle_id, 10, &[n2])); + let err = + Wormhole::ensure_nullifiers_available_for_direct_settlement(&[n2]).unwrap_err(); + assert!(matches!(err, crate::Error::::NullifierLocked)); + }); + } + + #[test] + fn nullifier_lock_helpers_manage_lock_lifecycle() { + new_test_ext().execute_with(|| { + let n1 = [1u8; 32]; + let n2 = [2u8; 32]; + let bundle_id = [7u8; 32]; + let other_bundle_id = [8u8; 32]; + + assert_ok!(Wormhole::lock_nullifiers_for_bundle(bundle_id, 10, &[n1, n2])); + assert!(Wormhole::is_nullifier_locked(&n1)); + assert!(Wormhole::is_nullifier_locked(&n2)); + assert_eq!(Wormhole::locked_nullifiers(n1).unwrap().bundle_id, bundle_id); + + let err = Wormhole::unlock_nullifiers_for_bundle(other_bundle_id, &[n1]).unwrap_err(); + assert!(matches!(err, crate::Error::::NullifierLockMismatch)); + + assert_ok!(Wormhole::unlock_nullifiers_for_bundle(bundle_id, &[n1])); + assert!(!Wormhole::is_nullifier_locked(&n1)); + assert!(Wormhole::is_nullifier_locked(&n2)); + + assert_ok!(Wormhole::mark_locked_nullifiers_used(bundle_id, &[n2])); + assert!(!Wormhole::is_nullifier_locked(&n2)); + assert!(Wormhole::is_nullifier_used(&n2)); + }); + } + + fn public_output(account: AccountId, summed_output_amount: u32) -> PublicInputsByAccount { + PublicInputsByAccount { + summed_output_amount, + exit_account: BytesDigest::new_unchecked(*account.as_ref()), + } + } + + fn set_block_author(preimage: [u8; 32]) -> AccountId { + let author = qp_wormhole::derive_wormhole_account(preimage); + System::deposit_log(DigestItem::PreRuntime(*b"pow_", preimage.to_vec())); + author + } + + fn expected_total_fee(total_exit_amount: Balance) -> Balance { + let fee_bps = VolumeFeeRateBps::get() as Balance; + total_exit_amount + .saturating_mul(fee_bps) + .checked_div(10_000u128.saturating_sub(fee_bps)) + .unwrap_or(0) + } + + fn expected_fee_split( + total_exit_amount: Balance, + delegated: bool, + has_author: bool, + ) -> (Balance, Balance, Balance, Balance) { + let total_fee = expected_total_fee(total_exit_amount); + let base_burn = VolumeFeesBurnRate::get() * total_fee; + let non_burned_fee = total_fee.saturating_sub(base_burn); + let aggregation_prover_fee = + if delegated { AggregationProverFeeShare::get() * non_burned_fee } else { 0 }; + let block_author_share = non_burned_fee.saturating_sub(aggregation_prover_fee); + let block_author_fee = if has_author { block_author_share } else { 0 }; + let burn_amount = + if has_author { base_burn } else { base_burn.saturating_add(block_author_share) }; + (total_fee, burn_amount, block_author_fee, aggregation_prover_fee) + } + + #[test] + fn public_output_settlement_prepare_rejects_below_minimum_without_writes() { + new_test_ext().execute_with(|| { + let recipient = account_id(3); + let balance_before = Balances::balance(&recipient); + let transfer_count_before = Wormhole::transfer_count(&recipient); + + let err = Wormhole::prepare_public_output_settlement( + &[public_output(recipient.clone(), 1)], + VolumeFeeRateBps::get(), + crate::SettlementKind::DirectL0, + ) + .unwrap_err(); + + assert!(matches!(err, crate::Error::::TransferAmountBelowMinimum)); + assert_eq!(Balances::balance(&recipient), balance_before); + assert_eq!(Wormhole::transfer_count(&recipient), transfer_count_before); + }); + } + + #[test] + fn public_output_settlement_prepare_and_apply_mints_and_records_transfer() { + new_test_ext().execute_with(|| { + let recipient = account_id(3); + let balance_before = Balances::balance(&recipient); + let transfer_count_before = Wormhole::transfer_count(&recipient); + + let prepared = Wormhole::prepare_public_output_settlement( + &[public_output(recipient.clone(), 1_000)], + VolumeFeeRateBps::get(), + crate::SettlementKind::DirectL0, + ) + .unwrap(); + + assert_eq!(prepared.total_exit_amount, 10 * UNIT); + assert_eq!(prepared.transfers.as_slice(), &[(recipient.clone(), 10 * UNIT)]); + assert_eq!(prepared.block_author_fee, 0); + + assert_ok!(Wormhole::apply_public_output_settlement(prepared)); + + assert_eq!(Balances::balance(&recipient), balance_before + 10 * UNIT); + assert_eq!(Wormhole::transfer_count(&recipient), transfer_count_before + 1); + }); + } + + #[test] + fn direct_l0_fee_behavior_preserved() { + new_test_ext().execute_with(|| { + System::set_block_number(1); + let recipient = account_id(3); + let author = set_block_author([7u8; 32]); + let total_exit_amount = 10 * UNIT; + let (total_fee, burn_amount, block_author_fee, aggregation_prover_fee) = + expected_fee_split(total_exit_amount, false, true); + let author_balance_before = Balances::balance(&author); + + let prepared = Wormhole::prepare_public_output_settlement( + &[public_output(recipient, 1_000)], + VolumeFeeRateBps::get(), + crate::SettlementKind::DirectL0, + ) + .unwrap(); + + assert_eq!(prepared.total_fee, total_fee); + assert_eq!(prepared.burn_amount, burn_amount); + assert_eq!(prepared.block_author_fee, block_author_fee); + assert_eq!(prepared.aggregation_prover_fee, aggregation_prover_fee); + assert_eq!(prepared.block_author, Some(author.clone())); + assert_eq!(prepared.aggregation_reward_account, None); + + assert_ok!(Wormhole::apply_public_output_settlement(prepared)); + + assert_eq!(Balances::balance(&author), author_balance_before + block_author_fee); + System::assert_has_event( + crate::Event::::WormholeFeeSettled { + total_fee, + burn_amount, + block_author_fee, + aggregation_prover_fee, + } + .into(), + ); + }); + } + + #[test] + fn delegated_l1_pays_aggregation_prover_fee_share() { + new_test_ext().execute_with(|| { + let recipient = account_id(3); + let reward_account = account_id(4); + let total_exit_amount = 10 * UNIT; + let (total_fee, burn_amount, block_author_fee, aggregation_prover_fee) = + expected_fee_split(total_exit_amount, true, false); + let reward_balance_before = Balances::balance(&reward_account); + + let prepared = Wormhole::prepare_public_output_settlement( + &[public_output(recipient, 1_000)], + VolumeFeeRateBps::get(), + crate::SettlementKind::DelegatedL1 { + aggregation_reward_account: reward_account.clone(), + }, + ) + .unwrap(); + + assert_eq!(prepared.total_fee, total_fee); + assert_eq!(prepared.burn_amount, burn_amount); + assert_eq!(prepared.block_author_fee, block_author_fee); + assert_eq!(prepared.aggregation_prover_fee, aggregation_prover_fee); + assert_eq!(prepared.aggregation_reward_account, Some(reward_account.clone())); + + assert_ok!(Wormhole::apply_public_output_settlement(prepared)); + + assert_eq!( + Balances::balance(&reward_account), + reward_balance_before + aggregation_prover_fee + ); + }); + } + + #[test] + fn no_author_redirects_block_author_fee_share_to_burn() { + new_test_ext().execute_with(|| { + let recipient = account_id(3); + let reward_account = account_id(4); + let total_exit_amount = 10 * UNIT; + let (_total_fee, burn_amount, block_author_fee, aggregation_prover_fee) = + expected_fee_split(total_exit_amount, true, false); + + let prepared = Wormhole::prepare_public_output_settlement( + &[public_output(recipient, 1_000)], + VolumeFeeRateBps::get(), + crate::SettlementKind::DelegatedL1 { aggregation_reward_account: reward_account }, + ) + .unwrap(); + + assert_eq!(prepared.block_author, None); + assert_eq!(prepared.block_author_fee, block_author_fee); + assert_eq!(prepared.aggregation_prover_fee, aggregation_prover_fee); + assert_eq!(prepared.burn_amount, burn_amount); + }); + } + + #[test] + fn settlement_helper_used_by_both_direct_and_delegated_paths() { + new_test_ext().execute_with(|| { + let recipient = account_id(3); + let reward_account = account_id(4); + + let direct = Wormhole::prepare_public_output_settlement( + &[public_output(recipient.clone(), 1_000)], + VolumeFeeRateBps::get(), + crate::SettlementKind::DirectL0, + ) + .unwrap(); + let delegated = Wormhole::prepare_public_output_settlement( + &[public_output(recipient, 1_000)], + VolumeFeeRateBps::get(), + crate::SettlementKind::DelegatedL1 { + aggregation_reward_account: reward_account.clone(), + }, + ) + .unwrap(); + + assert_eq!(direct.total_exit_amount, delegated.total_exit_amount); + assert_eq!(direct.total_fee, delegated.total_fee); + assert_eq!(direct.transfers, delegated.transfers); + assert_eq!(direct.aggregation_prover_fee, 0); + assert!(delegated.aggregation_prover_fee > 0); + assert_eq!(delegated.aggregation_reward_account, Some(reward_account)); + }); + } + #[test] fn record_transfer_increments_count() { new_test_ext().execute_with(|| { @@ -406,6 +691,36 @@ mod aggregated_proof_tests { }); } + #[test] + fn test_verify_aggregated_proof_fails_with_locked_nullifier() { + new_test_ext().execute_with(|| { + let proof = deserialize_test_proof(); + let inputs = parse_aggregated_public_inputs(&proof).expect("Should parse"); + + // Set up block hash to match the proof + let block_number = inputs.block_data.block_number as u64; + let block_hash_bytes: [u8; 32] = + inputs.block_data.block_hash.as_ref().try_into().unwrap(); + let block_hash = H256::from(block_hash_bytes); + frame_system::BlockHash::::insert(block_number, block_hash); + + let nullifier = inputs.nullifiers.first().expect("fixture has nullifiers"); + let nullifier_bytes: [u8; 32] = nullifier.as_ref().try_into().unwrap(); + assert_ok!(Wormhole::lock_nullifiers_for_bundle( + [7u8; 32], + block_number + 10, + &[nullifier_bytes] + )); + + let proof_bytes = get_test_proof_bytes(); + let result = Wormhole::verify_aggregated_proof(RawOrigin::None.into(), proof_bytes); + + assert!(result.is_err()); + let err = result.unwrap_err(); + assert_eq!(err.error, Error::::NullifierLocked.into()); + }); + } + #[test] fn test_verify_aggregated_proof_fails_with_wrong_block_hash() { new_test_ext().execute_with(|| { diff --git a/runtime/Cargo.toml b/runtime/Cargo.toml index 548590d4..4f643285 100644 --- a/runtime/Cargo.toml +++ b/runtime/Cargo.toml @@ -31,6 +31,7 @@ pallet-assets.workspace = true pallet-assets-holder = { workspace = true, default-features = false } pallet-balances.workspace = true pallet-conviction-voting.workspace = true +pallet-miner-aggregation.workspace = true pallet-mining-rewards.workspace = true pallet-multisig.workspace = true pallet-preimage.workspace = true @@ -101,6 +102,7 @@ std = [ "pallet-assets/std", "pallet-balances/std", "pallet-conviction-voting/std", + "pallet-miner-aggregation/std", "pallet-mining-rewards/std", "pallet-multisig/std", "pallet-preimage/std", @@ -151,6 +153,7 @@ runtime-benchmarks = [ "pallet-assets/runtime-benchmarks", "pallet-balances/runtime-benchmarks", "pallet-conviction-voting/runtime-benchmarks", + "pallet-miner-aggregation/runtime-benchmarks", "pallet-mining-rewards/runtime-benchmarks", "pallet-multisig/runtime-benchmarks", "pallet-preimage/runtime-benchmarks", diff --git a/runtime/src/benchmarks.rs b/runtime/src/benchmarks.rs index d9892d3d..eb9198c1 100644 --- a/runtime/src/benchmarks.rs +++ b/runtime/src/benchmarks.rs @@ -35,4 +35,5 @@ frame_benchmarking::define_benchmarks!( [pallet_scheduler, Scheduler] [pallet_qpow, QPoW] [pallet_wormhole, Wormhole] + [pallet_miner_aggregation, MinerAggregation] ); diff --git a/runtime/src/configs/mod.rs b/runtime/src/configs/mod.rs index 272a26e6..20c15f4d 100644 --- a/runtime/src/configs/mod.rs +++ b/runtime/src/configs/mod.rs @@ -742,8 +742,10 @@ parameter_types! { pub const WormholeMinimumTransferAmount: Balance = UNIT / 10; /// Volume fee rate in basis points (10 bps = 0.1%) pub const VolumeFeeRateBps: u32 = 10; - /// Proportion of volume fees to burn (50% burned, 50% to miner) + /// Proportion of volume fees to burn. pub const VolumeFeesBurnRate: Permill = Permill::from_percent(50); + /// Proportion of non-burned delegated L1 fees paid to aggregation prover. + pub const AggregationProverFeeShare: Permill = Permill::from_percent(50); } impl pallet_wormhole::Config for Runtime { @@ -759,11 +761,55 @@ impl pallet_wormhole::Config for Runtime { type MinimumTransferAmount = WormholeMinimumTransferAmount; type VolumeFeeRateBps = VolumeFeeRateBps; type VolumeFeesBurnRate = VolumeFeesBurnRate; + type AggregationProverFeeShare = AggregationProverFeeShare; type WormholeAccountId = AccountId32; type WeightInfo = pallet_wormhole::weights::SubstrateWeight; type ZkTree = ZkTree; } +parameter_types! { + pub const MinerAggregationMaxL0ProofBytes: u32 = 256 * 1024; + pub const MinerAggregationMaxNullifiersPerL0: u32 = 64; + pub const MinerAggregationMaxExitSlotsPerL0: u32 = 128; + pub const MinerAggregationMaxCandidatesPerQueue: u32 = 128; + pub const MinerAggregationCandidateLifetime: BlockNumber = 256; + pub const MinerAggregationStorageBond: Balance = UNIT / 100; + pub const MinerAggregationValidityBond: Balance = UNIT / 10; + pub const MinerAggregationNumLayer0Proofs: u32 = 2; + pub const MinerAggregationCircuitId: [u8; 32] = [0u8; 32]; + pub const MinerAggregationMaxActiveBundlesPerMiner: u32 = 4; + pub const MinerAggregationBundleProvingPeriod: BlockNumber = 64; + pub const MinerAggregationMinMinerBond: Balance = UNIT; + pub const MinerAggregationMaxL1ProofBytes: u32 = 512 * 1024; + pub const MinerAggregationMinerTimeoutSlash: Permill = Permill::from_percent(10); + pub const MinerAggregationInvalidL1ProofSlash: Permill = Permill::from_percent(10); + pub const MinerAggregationInvalidClaimSlash: Permill = Permill::from_percent(25); + pub const MinerAggregationInvalidCandidateChallengeReward: Permill = Permill::from_percent(50); +} + +impl pallet_miner_aggregation::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type Currency = Balances; + type MaxL0ProofBytes = MinerAggregationMaxL0ProofBytes; + type MaxNullifiersPerL0 = MinerAggregationMaxNullifiersPerL0; + type MaxExitSlotsPerL0 = MinerAggregationMaxExitSlotsPerL0; + type MaxCandidatesPerQueue = MinerAggregationMaxCandidatesPerQueue; + type CandidateLifetime = MinerAggregationCandidateLifetime; + type StorageBond = MinerAggregationStorageBond; + type ValidityBond = MinerAggregationValidityBond; + type NumLayer0Proofs = MinerAggregationNumLayer0Proofs; + type CircuitId = MinerAggregationCircuitId; + type MaxActiveBundlesPerMiner = MinerAggregationMaxActiveBundlesPerMiner; + type BundleProvingPeriod = MinerAggregationBundleProvingPeriod; + type MinMinerBond = MinerAggregationMinMinerBond; + type MaxL1ProofBytes = MinerAggregationMaxL1ProofBytes; + type MinerTimeoutSlash = MinerAggregationMinerTimeoutSlash; + type InvalidL1ProofSlash = MinerAggregationInvalidL1ProofSlash; + type InvalidClaimSlash = MinerAggregationInvalidClaimSlash; + type InvalidCandidateChallengeReward = MinerAggregationInvalidCandidateChallengeReward; + type WeightInfo = pallet_miner_aggregation::weights::SubstrateWeight; +} + impl pallet_zk_tree::Config for Runtime { type AssetId = AssetId; type Balance = Balance; diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs index c87731e6..a3a0af40 100644 --- a/runtime/src/lib.rs +++ b/runtime/src/lib.rs @@ -259,4 +259,7 @@ mod runtime { #[runtime::pallet_index(21)] pub type ZkTree = pallet_zk_tree; + + #[runtime::pallet_index(22)] + pub type MinerAggregation = pallet_miner_aggregation; } diff --git a/scripts/e2e-delegated-l1-aggregation.sh b/scripts/e2e-delegated-l1-aggregation.sh new file mode 100755 index 00000000..afb7c3b4 --- /dev/null +++ b/scripts/e2e-delegated-l1-aggregation.sh @@ -0,0 +1,34 @@ +#!/usr/bin/env bash +set -euo pipefail + +ROOT="$(cd "$(dirname "$0")/../.." && pwd)" +CHAIN_DIR="$ROOT/chain" +MINER_DIR="$ROOT/quantus-miner" +BINS_DIR="${BINS_DIR:-$ROOT/target/delegated-l1-fixture-bins}" +L0_PROOF="${L0_PROOF:-$CHAIN_DIR/pallets/miner-aggregation/test-data/l0_candidate_0.hex}" + +echo "Generating delegated L1 fixtures with release-mode proving" +"$CHAIN_DIR/scripts/generate-delegated-l1-fixture.sh" + +echo "Running chain delegated L1 settlement E2E fixture in release mode" +( + cd "$CHAIN_DIR" + QP_GENERATE_LAYER1=true QP_NUM_LAYER0_PROOFS=1 \ + cargo test --release -p pallet-miner-aggregation \ + submit_l1_aggregate_accepts_valid_fixture_and_settles_bundle -- --nocapture +) + +echo "Running miner mocked claim/prove/submit worker flow" +( + cd "$MINER_DIR" + cargo test -p miner-service mocked_worker_processes_claimed_bundle_end_to_end -- --nocapture +) + +echo "Running miner real L1 prover fixture in release mode" +( + cd "$MINER_DIR" + ZK_AGGREGATION_TEST_BINS_DIR="$BINS_DIR" \ + ZK_AGGREGATION_TEST_L0_PROOF="$L0_PROOF" \ + cargo test --release -p miner-service \ + zk_aggregation_prove_generates_l1_proof_from_fixture_when_configured -- --nocapture +) diff --git a/scripts/generate-delegated-l1-fixture.sh b/scripts/generate-delegated-l1-fixture.sh new file mode 100755 index 00000000..4458039d --- /dev/null +++ b/scripts/generate-delegated-l1-fixture.sh @@ -0,0 +1,23 @@ +#!/usr/bin/env bash +set -euo pipefail + +ROOT="$(cd "$(dirname "$0")/../.." && pwd)" +OUT="${1:-$ROOT/chain/pallets/miner-aggregation/test-data}" +BINS_DIR="${BINS_DIR:-$ROOT/target/delegated-l1-fixture-bins}" +L0_PROOF="${L0_PROOF:-$ROOT/chain/pallets/wormhole/test-data/aggregated.hex}" +QP_NUM_LEAF_PROOFS="${QP_NUM_LEAF_PROOFS:-16}" +QP_NUM_LAYER0_PROOFS="${QP_NUM_LAYER0_PROOFS:-1}" +AGGREGATOR_ADDRESS="${AGGREGATOR_ADDRESS:-0200000000000000000000000000000000000000000000000000000000000000}" + +cd "$ROOT/qp-zk-circuits" + +cargo run --release -p qp-wormhole-circuit-builder -- \ + --output "$BINS_DIR" \ + --num-leaf-proofs "$QP_NUM_LEAF_PROOFS" \ + --num-layer0-proofs "$QP_NUM_LAYER0_PROOFS" + +cargo run --release -p qp-wormhole-aggregator --example generate_l1_fixture -- \ + --bins-dir "$BINS_DIR" \ + --out "$OUT" \ + --aggregator-address "$AGGREGATOR_ADDRESS" \ + --l0-proof "$L0_PROOF"