From af0ea93d4e435b41b449d2baa45c078f9d3a2c7d Mon Sep 17 00:00:00 2001 From: Ethan Date: Fri, 8 May 2026 01:08:03 -0500 Subject: [PATCH 01/13] *Adds miner aggregation and proof locking *Enables staged miner aggregation in the runtime and uses matching circuit artifacts for bundled proof generation and verification. *Improves settlement safety by locking nullifiers while bundles are assembled, rejecting duplicates and reused inputs, and adding optional layer-1 verifier support for multi-stage aggregation. --- Cargo.lock | 46 +- Cargo.toml | 12 +- docs/delegated-l1-aggregation.md | 55 ++ pallets/miner-aggregation/Cargo.toml | 48 + pallets/miner-aggregation/README.md | 30 + pallets/miner-aggregation/src/lib.rs | 1069 ++++++++++++++++++++++ pallets/miner-aggregation/src/mock.rs | 183 ++++ pallets/miner-aggregation/src/tests.rs | 351 +++++++ pallets/miner-aggregation/src/weights.rs | 74 ++ pallets/wormhole/build.rs | 38 +- pallets/wormhole/src/lib.rs | 389 +++++++- pallets/wormhole/src/tests.rs | 107 ++- runtime/Cargo.toml | 3 + runtime/src/configs/mod.rs | 39 +- runtime/src/lib.rs | 3 + 15 files changed, 2386 insertions(+), 61 deletions(-) create mode 100644 docs/delegated-l1-aggregation.md create mode 100644 pallets/miner-aggregation/Cargo.toml create mode 100644 pallets/miner-aggregation/README.md create mode 100644 pallets/miner-aggregation/src/lib.rs create mode 100644 pallets/miner-aggregation/src/mock.rs create mode 100644 pallets/miner-aggregation/src/tests.rs create mode 100644 pallets/miner-aggregation/src/weights.rs diff --git a/Cargo.lock b/Cargo.lock index 41e77fc7..6d949654 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -6605,6 +6605,30 @@ dependencies = [ "sp-runtime", ] +[[package]] +name = "pallet-miner-aggregation" +version = "0.1.0" +dependencies = [ + "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 +8381,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?branch=miner-aggr#b0896a7b336fa468334da8178bfe9182f391e865" dependencies = [ "anyhow", "hex", @@ -8375,8 +8398,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?branch=miner-aggr#b0896a7b336fa468334da8178bfe9182f391e865" dependencies = [ "anyhow", "hex", @@ -8388,8 +8410,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?branch=miner-aggr#b0896a7b336fa468334da8178bfe9182f391e865" dependencies = [ "anyhow", "clap", @@ -8402,8 +8423,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?branch=miner-aggr#b0896a7b336fa468334da8178bfe9182f391e865" dependencies = [ "anyhow", ] @@ -8411,8 +8431,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?branch=miner-aggr#b0896a7b336fa468334da8178bfe9182f391e865" dependencies = [ "anyhow", "qp-plonky2", @@ -8424,8 +8443,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?branch=miner-aggr#b0896a7b336fa468334da8178bfe9182f391e865" dependencies = [ "anyhow", "qp-plonky2-verifier", @@ -8435,8 +8453,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?branch=miner-aggr#b0896a7b336fa468334da8178bfe9182f391e865" dependencies = [ "anyhow", "hex", @@ -8566,6 +8583,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..cb944db4 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -15,6 +15,7 @@ members = [ "node", "pallets/frame-system", "pallets/mining-rewards", + "pallets/miner-aggregation", "pallets/multisig", "pallets/qpow", "pallets/reversible-transfers", @@ -133,6 +134,7 @@ zeroize = { version = "1.7.0", default-features = false } # Own dependencies pallet-balances = { version = "46.0.0", default-features = false } pallet-mining-rewards = { path = "./pallets/mining-rewards", default-features = false } +pallet-miner-aggregation = { path = "./pallets/miner-aggregation", default-features = false } pallet-multisig = { path = "./pallets/multisig", default-features = false } pallet-qpow = { path = "./pallets/qpow", default-features = false } pallet-reversible-transfers = { path = "./pallets/reversible-transfers", 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", branch = "miner-aggr", default-features = false } +qp-wormhole-circuit-builder = { version = "2.0.1", git = "https://github.com/Quantus-Network/qp-zk-circuits", branch = "miner-aggr", default-features = false } +qp-wormhole-prover = { version = "2.0.1", git = "https://github.com/Quantus-Network/qp-zk-circuits", branch = "miner-aggr", default-features = false } +qp-wormhole-verifier = { version = "2.0.1", git = "https://github.com/Quantus-Network/qp-zk-circuits", branch = "miner-aggr", default-features = false } +qp-zk-circuits-common = { version = "2.0.1", git = "https://github.com/Quantus-Network/qp-zk-circuits", branch = "miner-aggr", 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..424567ba --- /dev/null +++ b/docs/delegated-l1-aggregation.md @@ -0,0 +1,55 @@ +# 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. +- Invalid-candidate challenge currently handles pending candidates only. Claimed-bundle challenge and partial miner slashing are left for the next hardening pass. +- The external miner has separate ZK aggregation CLI/config/worker-pool scaffolding, but the chain RPC watcher and L1 prover submission loop are not complete. +- The full local E2E needs generated L1 prover/verifier artifacts and client L0 proof fixtures. + +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`. diff --git a/pallets/miner-aggregation/Cargo.toml b/pallets/miner-aggregation/Cargo.toml new file mode 100644 index 00000000..46c1fe2b --- /dev/null +++ b/pallets/miner-aggregation/Cargo.toml @@ -0,0 +1,48 @@ +[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-support.workspace = true +frame-system.workspace = true +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 = [ + "frame-support/runtime-benchmarks", + "frame-system/runtime-benchmarks", + "pallet-wormhole/runtime-benchmarks", +] +std = [ + "codec/std", + "frame-support/std", + "frame-system/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..4199f803 --- /dev/null +++ b/pallets/miner-aggregation/README.md @@ -0,0 +1,30 @@ +# 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 + +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 current pallet tests use +precomputed fixture proof bytes and do not generate proofs. + +MVP limitations: + +- Claimed-bundle invalid-candidate challenge and partial miner slashing are not implemented yet. +- L1 proof settlement is wired to the L1 verifier helper, but the test suite currently covers cheap + rejection only because no local L1 aggregate proof fixture is available. diff --git a/pallets/miner-aggregation/src/lib.rs b/pallets/miner-aggregation/src/lib.rs new file mode 100644 index 00000000..6c6be3cb --- /dev/null +++ b/pallets/miner-aggregation/src/lib.rs @@ -0,0 +1,1069 @@ +#![cfg_attr(not(feature = "std"), no_std)] + +extern crate alloc; +pub use pallet::*; +pub mod weights; +pub use weights::*; + +#[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::{Currency, ReservableCurrency}, + BoundedVec, + }; + use frame_system::pallet_prelude::*; + use qp_wormhole_verifier::{ + AggregatedPublicCircuitInputs, BytesDigest, Layer1AggregatedPublicCircuitInputs, + L0_AGGREGATED_PUBLIC_INPUT_LAYOUT_VERSION, + }; + use sp_runtime::traits::{Saturating, Zero}; + + 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, + 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; + + #[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; + + 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, + }, + BundleClaimed { + bundle_id: BundleId, + miner: T::AccountId, + group_key: BundleGroupKey, + }, + BundleTimedOut { + bundle_id: BundleId, + }, + BundleSettled { + bundle_id: BundleId, + miner: T::AccountId, + }, + L0CandidateChallengedInvalid { + candidate_id: CandidateId, + challenger: T::AccountId, + }, + 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, + } + + #[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())] + pub fn register_aggregator( + origin: OriginFor, + reward_address: [u8; 32], + max_active_jobs: u32, + bond: BalanceOf, + ) -> DispatchResult { + let account = ensure_signed(origin)?; + let registered_at = frame_system::Pallet::::block_number(); + if !bond.is_zero() { + ::Currency::reserve(&account, bond) + .map_err(|_| Error::::BondReservationFailed)?; + } + RegisteredAggregators::::insert( + &account, + AggregatorInfo { + registered_at, + reward_address, + bond, + max_active_jobs, + active_jobs: 0, + }, + ); + Self::deposit_event(Event::AggregatorRegistered { account }); + Ok(()) + } + + #[pallet::call_index(2)] + #[pallet::weight(::WeightInfo::claim_bundle())] + 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!(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, + 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::deposit_event(Event::BundleClaimed { bundle_id, miner, group_key }); + Ok(()) + } + + #[pallet::call_index(3)] + #[pallet::weight(::WeightInfo::timeout_bundle())] + 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)?; + ::Currency::unreserve(&bundle.assigned_miner, bundle.miner_bond); + Self::remove_active_bundle(&bundle.assigned_miner, bundle_id); + Self::decrement_active_jobs(&bundle.assigned_miner); + bundle.status = BundleStatus::Expired; + Bundles::::insert(bundle_id, bundle); + + Self::deposit_event(Event::BundleTimedOut { bundle_id }); + Ok(()) + } + + #[pallet::call_index(4)] + #[pallet::weight(::WeightInfo::submit_l1_aggregate())] + 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)?; + pallet_wormhole::Pallet::::verify_layer1_proof(&proof) + .map_err(|_| Error::::L1ProofRejected)?; + + let nullifiers = Self::layer1_nullifier_bytes(&inputs)?; + pallet_wormhole::Pallet::::mark_locked_nullifiers_used(bundle_id, &nullifiers) + .map_err(|_| Error::::NullifierUnavailable)?; + pallet_wormhole::Pallet::::settle_public_outputs( + &inputs.account_data, + inputs.volume_fee_bps, + ) + .map_err(|_| Error::::ProofMismatch)?; + + let reward_account = Self::reward_account(&bundle); + for candidate_id in bundle.ordered_candidates.iter() { + L0Candidates::::try_mutate(candidate_id, |candidate| -> DispatchResult { + let candidate = candidate.as_mut().ok_or(Error::::CandidateNotFound)?; + 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); + let settled_miner = bundle.assigned_miner.clone(); + bundle.status = BundleStatus::Settled; + Bundles::::insert(bundle_id, bundle); + Self::deposit_event(Event::BundleSettled { bundle_id, miner: settled_miner }); + Ok(()) + } + + #[pallet::call_index(5)] + #[pallet::weight(::WeightInfo::challenge_invalid_l0_candidate())] + 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 + ); + + match pallet_wormhole::Pallet::::verify_aggregated_proof_for_candidate( + candidate.proof_bytes.as_slice(), + ) { + Ok(_) => return Err(Error::::CandidateValid.into()), + Err(pallet_wormhole::Error::::AggregatedVerificationFailed) => {}, + Err(_) => return Err(Error::::ChallengeVerificationUnavailable.into()), + } + + Self::remove_selected_from_queue(&candidate.group_key, &[candidate_id])?; + Self::refund_candidate_storage_and_tip(&candidate); + let (_slashed, _remaining) = ::Currency::slash_reserved( + &candidate.submitter, + candidate.validity_bond, + ); + L0Candidates::::mutate(candidate_id, |stored| { + if let Some(stored) = stored { + stored.status = L0CandidateStatus::ChallengedInvalid; + } + }); + + Self::deposit_event(Event::L0CandidateChallengedInvalid { candidate_id, challenger }); + Ok(()) + } + + #[pallet::call_index(6)] + #[pallet::weight(::WeightInfo::drop_expired_candidate())] + 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(()) + } + } + + impl Pallet { + 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 { + 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::, _>>() + } + + fn ensure_l1_matches_bundle( + bundle: &BundleOf, + inputs: &Layer1AggregatedPublicCircuitInputs, + ) -> Result<(), Error> { + 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!(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 reward_account(bundle: &BundleOf) -> T::AccountId { + match T::AccountId::decode(&mut &bundle.aggregator_address[..]) { + Ok(account) => account, + Err(_) => bundle.assigned_miner.clone(), + } + } + + 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..c769d90c --- /dev/null +++ b/pallets/miner-aggregation/src/mock.rs @@ -0,0 +1,183 @@ +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); +} + +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 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; +} + +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 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)], + 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..1911b775 --- /dev/null +++ b/pallets/miner-aggregation/src/tests.rs @@ -0,0 +1,351 @@ +use crate::{ + mock::*, + pallet::{ + BundleStatus, Bundles, Error, L0CandidateStatus, L0Candidates, MinerActiveBundles, + PendingQueues, RegisteredAggregators, + }, +}; +use frame_support::{assert_noop, assert_ok}; +use qp_wormhole_verifier::parse_aggregated_public_inputs; +use sp_core::H256; + +const AGGREGATED_PROOF_HEX: &str = include_str!("../../wormhole/test-data/aggregated.hex"); + +fn proof_bytes() -> Vec { + hex::decode(AGGREGATED_PROOF_HEX.trim()).expect("valid aggregated proof 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 register_miner() { + let reward_account = account_id(2); + let reward_address: [u8; 32] = *reward_account.as_ref(); + assert_ok!(MinerAggregation::register_aggregator( + RuntimeOrigin::signed(account_id(2)), + reward_address, + 2, + 100 + )); +} + +#[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 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_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 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 challenge_valid_candidate_does_not_slash_submitter() { + new_test_ext().execute_with(|| { + let (candidate_id, _group_key) = submit_candidate(); + let reserved_before = Balances::reserved_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); + }); +} + +#[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..43f20d2b --- /dev/null +++ b/pallets/miner-aggregation/src/weights.rs @@ -0,0 +1,74 @@ +use core::marker::PhantomData; +use frame_support::weights::Weight; + +pub trait WeightInfo { + fn submit_l0_candidate() -> Weight; + fn register_aggregator() -> Weight; + fn claim_bundle() -> Weight; + fn timeout_bundle() -> Weight; + fn submit_l1_aggregate() -> Weight; + fn challenge_invalid_l0_candidate() -> Weight; + fn drop_expired_candidate() -> Weight; +} + +pub struct SubstrateWeight(PhantomData); + +impl WeightInfo for SubstrateWeight { + fn submit_l0_candidate() -> Weight { + Weight::from_parts(100_000_000, 0) + } + + fn register_aggregator() -> Weight { + Weight::from_parts(10_000_000, 0) + } + + fn claim_bundle() -> Weight { + Weight::from_parts(100_000_000, 0) + } + + fn timeout_bundle() -> Weight { + Weight::from_parts(50_000_000, 0) + } + + fn submit_l1_aggregate() -> Weight { + Weight::from_parts(500_000_000, 0) + } + + fn challenge_invalid_l0_candidate() -> Weight { + Weight::from_parts(500_000_000, 0) + } + + fn drop_expired_candidate() -> Weight { + Weight::from_parts(25_000_000, 0) + } +} + +impl WeightInfo for () { + fn submit_l0_candidate() -> Weight { + Weight::from_parts(100_000_000, 0) + } + + fn register_aggregator() -> Weight { + Weight::from_parts(10_000_000, 0) + } + + fn claim_bundle() -> Weight { + Weight::from_parts(100_000_000, 0) + } + + fn timeout_bundle() -> Weight { + Weight::from_parts(50_000_000, 0) + } + + fn submit_l1_aggregate() -> Weight { + Weight::from_parts(500_000_000, 0) + } + + fn challenge_invalid_l0_candidate() -> Weight { + Weight::from_parts(500_000_000, 0) + } + + fn drop_expired_candidate() -> Weight { + Weight::from_parts(25_000_000, 0) + } +} 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..9b85b5d6 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 @@ -52,8 +73,9 @@ pub mod pallet { 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}, @@ -209,11 +231,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)] @@ -269,11 +302,19 @@ pub mod pallet { 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 @@ -335,8 +376,9 @@ pub mod pallet { // Determine weight based on which stage failed let actual_weight = match e { // ZK verification was attempted - full weight consumed - Error::::AggregatedVerificationFailed => - Some(::WeightInfo::verify_aggregated_proof()), + Error::::AggregatedVerificationFailed => { + Some(::WeightInfo::verify_aggregated_proof()) + }, // Failed before ZK verification - minimal weight _ => Some(::WeightInfo::pre_validate_proof()), }; @@ -347,16 +389,9 @@ 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); - } + // Mark nullifiers as used (validate_proof only checks availability) + let nullifier_list = Self::collect_aggregated_nullifier_bytes(&aggregated_inputs)?; + Self::mark_nullifiers_used(&nullifier_list)?; // Get the minting account for recording transfer proofs let mint_account = T::MintingAccount::get(); @@ -459,7 +494,8 @@ pub mod pallet { &author, miner_fee, frame_support::traits::tokens::Precision::Exact, - )?; + ) + .map_err(|_| Error::::InvalidAggregatedPublicInputs)?; } else { // No block author found - add miner fee to burn amount log::warn!( @@ -489,7 +525,8 @@ pub mod pallet { exit_account, *exit_balance, frame_support::traits::tokens::Precision::Exact, - )?; + ) + .map_err(|_| Error::::InvalidAggregatedPublicInputs)?; // Record transfer proof for the minted tokens let from_account: ::WormholeAccountId = mint_account.clone().into(); @@ -547,6 +584,161 @@ 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_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 { + UsedNullifiers::::insert(*nullifier, true); + LockedNullifiers::::remove(*nullifier); + } + + 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 +750,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 +764,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 +776,150 @@ 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 mint_account = T::MintingAccount::get(); + let mut total_exit_amount: BalanceOf = Zero::zero(); + let mut processed_accounts: 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.saturating_add(exit_balance); + processed_accounts.push((exit_account, exit_balance)); + } + + ensure!( + total_exit_amount >= T::MinimumTransferAmount::get(), + Error::::TransferAmountBelowMinimum + ); + + let fee_bps = volume_fee_bps 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); + + 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 + })?; + + 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, + ) + .map_err(|_| Error::::InvalidAggregatedPublicInputs)?; + } else { + burn_amount_u128 = burn_amount_u128.saturating_add(miner_fee_u128); + } + } + + 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), + ); + } + + for (exit_account, exit_balance) in &processed_accounts { + >::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, + ); + } + + Ok(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/tests.rs b/pallets/wormhole/src/tests.rs index 1ea8c487..30947fb9 100644 --- a/pallets/wormhole/src/tests.rs +++ b/pallets/wormhole/src/tests.rs @@ -31,6 +31,79 @@ 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)); + }); + } + #[test] fn record_transfer_increments_count() { new_test_ext().execute_with(|| { @@ -406,6 +479,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(|| { @@ -466,8 +569,8 @@ mod aggregated_proof_tests { let mut total = 0u128; for account_data in &inputs.account_data { if account_data.summed_output_amount > 0 { - total += (account_data.summed_output_amount as u128) * - crate::SCALE_DOWN_FACTOR; + total += (account_data.summed_output_amount as u128) + * crate::SCALE_DOWN_FACTOR; } } total diff --git a/runtime/Cargo.toml b/runtime/Cargo.toml index 548590d4..9e8df562 100644 --- a/runtime/Cargo.toml +++ b/runtime/Cargo.toml @@ -32,6 +32,7 @@ pallet-assets-holder = { workspace = true, default-features = false } pallet-balances.workspace = true pallet-conviction-voting.workspace = true pallet-mining-rewards.workspace = true +pallet-miner-aggregation.workspace = true pallet-multisig.workspace = true pallet-preimage.workspace = true pallet-qpow.workspace = true @@ -102,6 +103,7 @@ std = [ "pallet-balances/std", "pallet-conviction-voting/std", "pallet-mining-rewards/std", + "pallet-miner-aggregation/std", "pallet-multisig/std", "pallet-preimage/std", "pallet-qpow/std", @@ -152,6 +154,7 @@ runtime-benchmarks = [ "pallet-balances/runtime-benchmarks", "pallet-conviction-voting/runtime-benchmarks", "pallet-mining-rewards/runtime-benchmarks", + "pallet-miner-aggregation/runtime-benchmarks", "pallet-multisig/runtime-benchmarks", "pallet-preimage/runtime-benchmarks", "pallet-qpow/runtime-benchmarks", diff --git a/runtime/src/configs/mod.rs b/runtime/src/configs/mod.rs index 272a26e6..87efef2e 100644 --- a/runtime/src/configs/mod.rs +++ b/runtime/src/configs/mod.rs @@ -687,8 +687,8 @@ impl qp_high_security::HighSecurityInspector for HighSec pallet_reversible_transfers::Call::schedule_transfer { .. } ) | RuntimeCall::ReversibleTransfers( pallet_reversible_transfers::Call::schedule_asset_transfer { .. } - ) | RuntimeCall::ReversibleTransfers(pallet_reversible_transfers::Call::cancel { .. }) | - RuntimeCall::ReversibleTransfers( + ) | RuntimeCall::ReversibleTransfers(pallet_reversible_transfers::Call::cancel { .. }) + | RuntimeCall::ReversibleTransfers( pallet_reversible_transfers::Call::recover_funds { .. } ) ) @@ -764,6 +764,41 @@ impl pallet_wormhole::Config for Runtime { 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; +} + +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 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; } From c02df2a062de71708c95bff926bee18bef0bf197 Mon Sep 17 00:00:00 2001 From: Ethan Date: Fri, 8 May 2026 17:45:40 -0500 Subject: [PATCH 02/13] *fmt --- Cargo.toml | 4 ++-- pallets/miner-aggregation/src/lib.rs | 14 +++++++------- pallets/wormhole/src/lib.rs | 5 ++--- pallets/wormhole/src/tests.rs | 4 ++-- runtime/Cargo.toml | 6 +++--- runtime/src/configs/mod.rs | 4 ++-- 6 files changed, 18 insertions(+), 19 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index cb944db4..655cd2b8 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -14,8 +14,8 @@ members = [ "miner-api", "node", "pallets/frame-system", - "pallets/mining-rewards", "pallets/miner-aggregation", + "pallets/mining-rewards", "pallets/multisig", "pallets/qpow", "pallets/reversible-transfers", @@ -133,8 +133,8 @@ zeroize = { version = "1.7.0", default-features = false } # Own dependencies pallet-balances = { version = "46.0.0", default-features = false } -pallet-mining-rewards = { path = "./pallets/mining-rewards", 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 } pallet-reversible-transfers = { path = "./pallets/reversible-transfers", default-features = false } diff --git a/pallets/miner-aggregation/src/lib.rs b/pallets/miner-aggregation/src/lib.rs index 6c6be3cb..bdb8516f 100644 --- a/pallets/miner-aggregation/src/lib.rs +++ b/pallets/miner-aggregation/src/lib.rs @@ -503,8 +503,8 @@ pub mod pallet { .ok_or(Error::::AggregatorNotRegistered)?; ensure!(info.active_jobs < info.max_active_jobs, Error::::TooManyActiveJobs); ensure!( - MinerActiveBundles::::get(&miner).len() - < T::MaxActiveBundlesPerMiner::get() as usize, + MinerActiveBundles::::get(&miner).len() < + T::MaxActiveBundlesPerMiner::get() as usize, Error::::ActiveBundleLimit ); ensure!(group_key.circuit_id == T::CircuitId::get(), Error::::UnsupportedCircuit); @@ -812,9 +812,9 @@ pub mod pallet { let Some(candidate) = L0Candidates::::get(candidate_id) else { continue; }; - if candidate.status != L0CandidateStatus::Pending - || candidate.group_key != *group_key - || now > candidate.expires_at + if candidate.status != L0CandidateStatus::Pending || + candidate.group_key != *group_key || + now > candidate.expires_at { continue; } @@ -949,8 +949,8 @@ pub mod pallet { Error::::ProofMismatch ); ensure!( - Self::digest_to_bytes(&inputs.block_data.block_hash)? - == bundle.group_key.block_hash, + Self::digest_to_bytes(&inputs.block_data.block_hash)? == + bundle.group_key.block_hash, Error::::ProofMismatch ); ensure!( diff --git a/pallets/wormhole/src/lib.rs b/pallets/wormhole/src/lib.rs index 9b85b5d6..e8523ac0 100644 --- a/pallets/wormhole/src/lib.rs +++ b/pallets/wormhole/src/lib.rs @@ -376,9 +376,8 @@ pub mod pallet { // Determine weight based on which stage failed let actual_weight = match e { // ZK verification was attempted - full weight consumed - Error::::AggregatedVerificationFailed => { - Some(::WeightInfo::verify_aggregated_proof()) - }, + Error::::AggregatedVerificationFailed => + Some(::WeightInfo::verify_aggregated_proof()), // Failed before ZK verification - minimal weight _ => Some(::WeightInfo::pre_validate_proof()), }; diff --git a/pallets/wormhole/src/tests.rs b/pallets/wormhole/src/tests.rs index 30947fb9..2d7993e8 100644 --- a/pallets/wormhole/src/tests.rs +++ b/pallets/wormhole/src/tests.rs @@ -569,8 +569,8 @@ mod aggregated_proof_tests { let mut total = 0u128; for account_data in &inputs.account_data { if account_data.summed_output_amount > 0 { - total += (account_data.summed_output_amount as u128) - * crate::SCALE_DOWN_FACTOR; + total += (account_data.summed_output_amount as u128) * + crate::SCALE_DOWN_FACTOR; } } total diff --git a/runtime/Cargo.toml b/runtime/Cargo.toml index 9e8df562..4f643285 100644 --- a/runtime/Cargo.toml +++ b/runtime/Cargo.toml @@ -31,8 +31,8 @@ pallet-assets.workspace = true pallet-assets-holder = { workspace = true, default-features = false } pallet-balances.workspace = true pallet-conviction-voting.workspace = true -pallet-mining-rewards.workspace = true pallet-miner-aggregation.workspace = true +pallet-mining-rewards.workspace = true pallet-multisig.workspace = true pallet-preimage.workspace = true pallet-qpow.workspace = true @@ -102,8 +102,8 @@ std = [ "pallet-assets/std", "pallet-balances/std", "pallet-conviction-voting/std", - "pallet-mining-rewards/std", "pallet-miner-aggregation/std", + "pallet-mining-rewards/std", "pallet-multisig/std", "pallet-preimage/std", "pallet-qpow/std", @@ -153,8 +153,8 @@ runtime-benchmarks = [ "pallet-assets/runtime-benchmarks", "pallet-balances/runtime-benchmarks", "pallet-conviction-voting/runtime-benchmarks", - "pallet-mining-rewards/runtime-benchmarks", "pallet-miner-aggregation/runtime-benchmarks", + "pallet-mining-rewards/runtime-benchmarks", "pallet-multisig/runtime-benchmarks", "pallet-preimage/runtime-benchmarks", "pallet-qpow/runtime-benchmarks", diff --git a/runtime/src/configs/mod.rs b/runtime/src/configs/mod.rs index 87efef2e..3697705b 100644 --- a/runtime/src/configs/mod.rs +++ b/runtime/src/configs/mod.rs @@ -687,8 +687,8 @@ impl qp_high_security::HighSecurityInspector for HighSec pallet_reversible_transfers::Call::schedule_transfer { .. } ) | RuntimeCall::ReversibleTransfers( pallet_reversible_transfers::Call::schedule_asset_transfer { .. } - ) | RuntimeCall::ReversibleTransfers(pallet_reversible_transfers::Call::cancel { .. }) - | RuntimeCall::ReversibleTransfers( + ) | RuntimeCall::ReversibleTransfers(pallet_reversible_transfers::Call::cancel { .. }) | + RuntimeCall::ReversibleTransfers( pallet_reversible_transfers::Call::recover_funds { .. } ) ) From 87649e6881317c6a08ac61571f79857c1450a822 Mon Sep 17 00:00:00 2001 From: Ethan Date: Fri, 8 May 2026 19:06:33 -0500 Subject: [PATCH 03/13] *Makes aggregate settlement atomic *Adds transactional execution around bundle and proof flows so failed settlement rolls back cleanly instead of leaving partial state behind. *Refactors public output settlement into prepare/apply steps, validates locked nullifiers before consuming them, and keeps locks, claim status, and active job tracking intact when post-verification settlement fails. *Improves fee and amount validation with safer arithmetic and adds regression tests for rollback behavior and settlement preparation. --- pallets/miner-aggregation/src/lib.rs | 101 +++++--- pallets/miner-aggregation/src/tests.rs | 91 ++++++- pallets/wormhole/src/lib.rs | 334 +++++++++++-------------- pallets/wormhole/src/tests.rs | 57 ++++- 4 files changed, 365 insertions(+), 218 deletions(-) diff --git a/pallets/miner-aggregation/src/lib.rs b/pallets/miner-aggregation/src/lib.rs index bdb8516f..6bcb0c34 100644 --- a/pallets/miner-aggregation/src/lib.rs +++ b/pallets/miner-aggregation/src/lib.rs @@ -18,12 +18,12 @@ pub mod pallet { use frame_support::{ pallet_prelude::*, traits::{Currency, ReservableCurrency}, - BoundedVec, + transactional, BoundedVec, }; use frame_system::pallet_prelude::*; use qp_wormhole_verifier::{ AggregatedPublicCircuitInputs, BytesDigest, Layer1AggregatedPublicCircuitInputs, - L0_AGGREGATED_PUBLIC_INPUT_LAYOUT_VERSION, + PublicInputsByAccount, L0_AGGREGATED_PUBLIC_INPUT_LAYOUT_VERSION, }; use sp_runtime::traits::{Saturating, Zero}; @@ -490,6 +490,7 @@ pub mod pallet { #[pallet::call_index(2)] #[pallet::weight(::WeightInfo::claim_bundle())] + #[transactional] pub fn claim_bundle( origin: OriginFor, group_key: BundleGroupKey, @@ -503,8 +504,8 @@ pub mod pallet { .ok_or(Error::::AggregatorNotRegistered)?; ensure!(info.active_jobs < info.max_active_jobs, Error::::TooManyActiveJobs); ensure!( - MinerActiveBundles::::get(&miner).len() < - T::MaxActiveBundlesPerMiner::get() as usize, + MinerActiveBundles::::get(&miner).len() + < T::MaxActiveBundlesPerMiner::get() as usize, Error::::ActiveBundleLimit ); ensure!(group_key.circuit_id == T::CircuitId::get(), Error::::UnsupportedCircuit); @@ -583,6 +584,7 @@ pub mod pallet { #[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)?; @@ -623,6 +625,7 @@ pub mod pallet { #[pallet::call_index(4)] #[pallet::weight(::WeightInfo::submit_l1_aggregate())] + #[transactional] pub fn submit_l1_aggregate( origin: OriginFor, bundle_id: BundleId, @@ -633,7 +636,7 @@ pub mod pallet { proof_bytes.len() <= T::MaxL1ProofBytes::get() as usize, Error::::L1ProofTooLarge ); - let mut bundle = Bundles::::get(bundle_id).ok_or(Error::::BundleNotFound)?; + let bundle = Bundles::::get(bundle_id).ok_or(Error::::BundleNotFound)?; ensure!(submitter == bundle.assigned_miner, Error::::NotAssignedMiner); ensure!( matches!(bundle.status, BundleStatus::Claimed | BundleStatus::Proving), @@ -651,36 +654,18 @@ pub mod pallet { .map_err(|_| Error::::L1ProofRejected)?; let nullifiers = Self::layer1_nullifier_bytes(&inputs)?; - pallet_wormhole::Pallet::::mark_locked_nullifiers_used(bundle_id, &nullifiers) - .map_err(|_| Error::::NullifierUnavailable)?; - pallet_wormhole::Pallet::::settle_public_outputs( + Self::settle_verified_l1_bundle( + bundle_id, + bundle, + nullifiers, &inputs.account_data, inputs.volume_fee_bps, ) - .map_err(|_| Error::::ProofMismatch)?; - - let reward_account = Self::reward_account(&bundle); - for candidate_id in bundle.ordered_candidates.iter() { - L0Candidates::::try_mutate(candidate_id, |candidate| -> DispatchResult { - let candidate = candidate.as_mut().ok_or(Error::::CandidateNotFound)?; - 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); - let settled_miner = bundle.assigned_miner.clone(); - bundle.status = BundleStatus::Settled; - Bundles::::insert(bundle_id, bundle); - Self::deposit_event(Event::BundleSettled { bundle_id, miner: settled_miner }); - Ok(()) } #[pallet::call_index(5)] #[pallet::weight(::WeightInfo::challenge_invalid_l0_candidate())] + #[transactional] pub fn challenge_invalid_l0_candidate( origin: OriginFor, candidate_id: CandidateId, @@ -719,6 +704,7 @@ pub mod pallet { #[pallet::call_index(6)] #[pallet::weight(::WeightInfo::drop_expired_candidate())] + #[transactional] pub fn drop_expired_candidate( origin: OriginFor, candidate_id: CandidateId, @@ -744,6 +730,55 @@ pub mod pallet { } impl Pallet { + 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)?; + pallet_wormhole::Pallet::::ensure_nullifiers_locked_by_bundle( + bundle_id, + &nullifiers, + ) + .map_err(|_| Error::::NullifierUnavailable)?; + + pallet_wormhole::Pallet::::apply_public_output_settlement( + prepared, + Some(&reward_account), + ) + .map_err(|_| Error::::ProofMismatch)?; + pallet_wormhole::Pallet::::mark_locked_nullifiers_used(bundle_id, &nullifiers) + .map_err(|_| Error::::NullifierUnavailable)?; + + for candidate_id in bundle.ordered_candidates.iter() { + L0Candidates::::try_mutate(candidate_id, |candidate| -> DispatchResult { + let candidate = candidate.as_mut().ok_or(Error::::CandidateNotFound)?; + 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); + let settled_miner = bundle.assigned_miner.clone(); + bundle.status = BundleStatus::Settled; + Bundles::::insert(bundle_id, bundle); + Self::deposit_event(Event::BundleSettled { bundle_id, miner: settled_miner }); + Ok(()) + } + fn reserve_candidate_funds( submitter: &T::AccountId, storage_bond: BalanceOf, @@ -812,9 +847,9 @@ pub mod pallet { let Some(candidate) = L0Candidates::::get(candidate_id) else { continue; }; - if candidate.status != L0CandidateStatus::Pending || - candidate.group_key != *group_key || - now > candidate.expires_at + if candidate.status != L0CandidateStatus::Pending + || candidate.group_key != *group_key + || now > candidate.expires_at { continue; } @@ -949,8 +984,8 @@ pub mod pallet { Error::::ProofMismatch ); ensure!( - Self::digest_to_bytes(&inputs.block_data.block_hash)? == - bundle.group_key.block_hash, + Self::digest_to_bytes(&inputs.block_data.block_hash)? + == bundle.group_key.block_hash, Error::::ProofMismatch ); ensure!( diff --git a/pallets/miner-aggregation/src/tests.rs b/pallets/miner-aggregation/src/tests.rs index 1911b775..0dbf892e 100644 --- a/pallets/miner-aggregation/src/tests.rs +++ b/pallets/miner-aggregation/src/tests.rs @@ -6,7 +6,7 @@ use crate::{ }, }; use frame_support::{assert_noop, assert_ok}; -use qp_wormhole_verifier::parse_aggregated_public_inputs; +use qp_wormhole_verifier::{parse_aggregated_public_inputs, BytesDigest, PublicInputsByAccount}; use sp_core::H256; const AGGREGATED_PROOF_HEX: &str = include_str!("../../wormhole/test-data/aggregated.hex"); @@ -47,6 +47,48 @@ fn register_miner() { )); } +fn claim_candidate_bundle() -> ([u8; 32], [u8; 32], Vec<[u8; 32]>) { + 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 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 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(|| { @@ -311,6 +353,53 @@ fn submit_l1_aggregate_rejects_malformed_proof_before_verification() { }); } +#[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 challenge_valid_candidate_does_not_slash_submitter() { new_test_ext().execute_with(|| { diff --git a/pallets/wormhole/src/lib.rs b/pallets/wormhole/src/lib.rs index e8523ac0..ccc3e292 100644 --- a/pallets/wormhole/src/lib.rs +++ b/pallets/wormhole/src/lib.rs @@ -69,6 +69,7 @@ pub mod pallet { fungibles::{self}, BuildGenesisConfig, Currency, }, + transactional, }; use frame_system::pallet_prelude::*; use pallet_zk_tree::ZkTreeRecorder; @@ -78,7 +79,7 @@ pub mod pallet { PublicInputsByAccount, C, D, F, }; use sp_runtime::{ - traits::{MaybeDisplay, One, Saturating, Zero}, + traits::{CheckedAdd, MaybeDisplay, One, Saturating, Zero}, transaction_validity::{ InvalidTransaction, TransactionSource, TransactionValidity, ValidTransaction, }, @@ -88,6 +89,23 @@ 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, + } + #[pallet::pallet] pub struct Pallet(_); @@ -362,6 +380,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, @@ -376,8 +395,9 @@ pub mod pallet { // Determine weight based on which stage failed let actual_weight = match e { // ZK verification was attempted - full weight consumed - Error::::AggregatedVerificationFailed => - Some(::WeightInfo::verify_aggregated_proof()), + Error::::AggregatedVerificationFailed => { + Some(::WeightInfo::verify_aggregated_proof()) + }, // Failed before ZK verification - minimal weight _ => Some(::WeightInfo::pre_validate_proof()), }; @@ -388,155 +408,22 @@ pub mod pallet { }, }; - // Mark nullifiers as used (validate_proof only checks availability) let nullifier_list = Self::collect_aggregated_nullifier_bytes(&aggregated_inputs)?; - Self::mark_nullifiers_used(&nullifier_list)?; - - // Get the minting account for recording transfer proofs - let mint_account = T::MintingAccount::get(); + let prepared = Self::prepare_public_output_settlement( + &aggregated_inputs.account_data, + aggregated_inputs.volume_fee_bps, + SettlementKind::DirectL0, + )?; - // 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 - })?; - - // 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, - ) - .map_err(|_| Error::::InvalidAggregatedPublicInputs)?; - } 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, - ) - .map_err(|_| Error::::InvalidAggregatedPublicInputs)?; - - // 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, None)?; // Success - use declared weight (actual_weight: None means use declared weight) Ok(PostDispatchInfo { actual_weight: None, pays_fee: Pays::No }) @@ -659,6 +546,20 @@ pub mod pallet { 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)?; @@ -668,11 +569,6 @@ pub mod pallet { ensure!(lock.bundle_id == bundle_id, Error::::NullifierLockMismatch); } - for nullifier in nullifiers { - UsedNullifiers::::insert(*nullifier, true); - LockedNullifiers::::remove(*nullifier); - } - Ok(()) } @@ -813,12 +709,25 @@ pub mod pallet { account_data: &[PublicInputsByAccount], volume_fee_bps: u32, ) -> Result, Error> { - let mint_account = T::MintingAccount::get(); + let prepared = Self::prepare_public_output_settlement( + account_data, + volume_fee_bps, + SettlementKind::DirectL0, + )?; + Self::apply_public_output_settlement(prepared, None) + } + + 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 processed_accounts: Vec<( - ::AccountId, - BalanceOf, - )> = Vec::with_capacity(account_data.len()); + 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] = @@ -842,8 +751,12 @@ pub mod pallet { ::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)); + 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!( @@ -852,6 +765,7 @@ pub mod pallet { ); 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 @@ -863,42 +777,98 @@ pub mod pallet { 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 - })?; - - if !miner_fee.is_zero() { + let non_burned_fee_u128 = total_fee_u128.saturating_sub(burn_amount_u128); + let aggregation_prover_fee_u128 = match settlement_kind { + SettlementKind::DirectL0 => 0, + SettlementKind::DelegatedL1 { aggregation_reward_account: _ } => 0, + }; + 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(); - 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, - ) - .map_err(|_| Error::::InvalidAggregatedPublicInputs)?; - } else { - burn_amount_u128 = burn_amount_u128.saturating_add(miner_fee_u128); - } + 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 })?; - if !burn_amount.is_zero() { + 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, + }) + } + + pub fn apply_public_output_settlement( + prepared: PreparedPublicOutputSettlement< + ::AccountId, + BalanceOf, + >, + reward_target: Option<&::AccountId>, + ) -> 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 = + reward_target.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(burn_amount), + current.saturating_sub(prepared.burn_amount), ); } - for (exit_account, exit_balance) in &processed_accounts { + for (exit_account, exit_balance) in &prepared.transfers { >::increase_balance( exit_account, *exit_balance, @@ -916,7 +886,7 @@ pub mod pallet { ); } - Ok(total_exit_amount) + Ok(prepared.total_exit_amount) } /// Record a transfer in the ZK tree and emit events. diff --git a/pallets/wormhole/src/tests.rs b/pallets/wormhole/src/tests.rs index 2d7993e8..b97066a4 100644 --- a/pallets/wormhole/src/tests.rs +++ b/pallets/wormhole/src/tests.rs @@ -8,6 +8,7 @@ mod wormhole_tests { Currency, }, }; + use qp_wormhole_verifier::{BytesDigest, PublicInputsByAccount}; use sp_core::crypto::AccountId32; /// Well-known test secret for genesis endowment (matches runtime preset). @@ -104,6 +105,58 @@ mod wormhole_tests { }); } + fn public_output(account: AccountId, summed_output_amount: u32) -> PublicInputsByAccount { + PublicInputsByAccount { + summed_output_amount, + exit_account: BytesDigest::new_unchecked(*account.as_ref()), + } + } + + #[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, None)); + + assert_eq!(Balances::balance(&recipient), balance_before + 10 * UNIT); + assert_eq!(Wormhole::transfer_count(&recipient), transfer_count_before + 1); + }); + } + #[test] fn record_transfer_increments_count() { new_test_ext().execute_with(|| { @@ -569,8 +622,8 @@ mod aggregated_proof_tests { let mut total = 0u128; for account_data in &inputs.account_data { if account_data.summed_output_amount > 0 { - total += (account_data.summed_output_amount as u128) * - crate::SCALE_DOWN_FACTOR; + total += (account_data.summed_output_amount as u128) + * crate::SCALE_DOWN_FACTOR; } } total From a72c7063f32a8e6da79bc652318fbf17b726e1b5 Mon Sep 17 00:00:00 2001 From: Ethan Date: Fri, 8 May 2026 19:15:43 -0500 Subject: [PATCH 04/13] *Enforces registered reward addresses *Rejects invalid or mismatched reward addresses so bundles, proofs, and payouts stay bound to the address registered by the aggregator. *Prevents silent fallback to the miner account during settlement, tightens proof validation against the claimed reward destination, and adds coverage for rejection and payout paths. --- pallets/miner-aggregation/src/lib.rs | 46 ++++--- pallets/miner-aggregation/src/tests.rs | 172 ++++++++++++++++++++++++- pallets/wormhole/src/lib.rs | 5 +- pallets/wormhole/src/tests.rs | 4 +- 4 files changed, 202 insertions(+), 25 deletions(-) diff --git a/pallets/miner-aggregation/src/lib.rs b/pallets/miner-aggregation/src/lib.rs index 6bcb0c34..77a764bc 100644 --- a/pallets/miner-aggregation/src/lib.rs +++ b/pallets/miner-aggregation/src/lib.rs @@ -374,6 +374,8 @@ pub mod pallet { CandidateValid, CandidateNotExpired, ChallengeVerificationUnavailable, + InvalidRewardAddress, + AggregatorAddressMismatch, } #[pallet::call] @@ -469,6 +471,7 @@ pub mod pallet { bond: BalanceOf, ) -> DispatchResult { let account = ensure_signed(origin)?; + Self::decode_registered_reward_address(&reward_address)?; let registered_at = frame_system::Pallet::::block_number(); if !bond.is_zero() { ::Currency::reserve(&account, bond) @@ -502,10 +505,14 @@ pub mod pallet { 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, + MinerActiveBundles::::get(&miner).len() < + T::MaxActiveBundlesPerMiner::get() as usize, Error::::ActiveBundleLimit ); ensure!(group_key.circuit_id == T::CircuitId::get(), Error::::UnsupportedCircuit); @@ -562,7 +569,7 @@ pub mod pallet { bundle_root, public_inputs_root, assigned_miner: miner.clone(), - aggregator_address, + aggregator_address: info.reward_address, claimed_at, deadline, miner_bond, @@ -737,7 +744,7 @@ pub mod pallet { account_data: &[PublicInputsByAccount], volume_fee_bps: u32, ) -> DispatchResult { - let reward_account = Self::reward_account(&bundle); + let reward_account = Self::reward_account(&bundle)?; let prepared = pallet_wormhole::Pallet::::prepare_public_output_settlement( account_data, volume_fee_bps, @@ -847,9 +854,9 @@ pub mod pallet { let Some(candidate) = L0Candidates::::get(candidate_id) else { continue; }; - if candidate.status != L0CandidateStatus::Pending - || candidate.group_key != *group_key - || now > candidate.expires_at + if candidate.status != L0CandidateStatus::Pending || + candidate.group_key != *group_key || + now > candidate.expires_at { continue; } @@ -970,7 +977,7 @@ pub mod pallet { .collect::, _>>() } - fn ensure_l1_matches_bundle( + pub(crate) fn ensure_l1_matches_bundle( bundle: &BundleOf, inputs: &Layer1AggregatedPublicCircuitInputs, ) -> Result<(), Error> { @@ -984,8 +991,8 @@ pub mod pallet { Error::::ProofMismatch ); ensure!( - Self::digest_to_bytes(&inputs.block_data.block_hash)? - == bundle.group_key.block_hash, + Self::digest_to_bytes(&inputs.block_data.block_hash)? == + bundle.group_key.block_hash, Error::::ProofMismatch ); ensure!( @@ -1017,11 +1024,20 @@ pub mod pallet { Ok(()) } - fn reward_account(bundle: &BundleOf) -> T::AccountId { - match T::AccountId::decode(&mut &bundle.aggregator_address[..]) { - Ok(account) => account, - Err(_) => bundle.assigned_miner.clone(), - } + 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) { diff --git a/pallets/miner-aggregation/src/tests.rs b/pallets/miner-aggregation/src/tests.rs index 0dbf892e..93b1249b 100644 --- a/pallets/miner-aggregation/src/tests.rs +++ b/pallets/miner-aggregation/src/tests.rs @@ -5,8 +5,11 @@ use crate::{ PendingQueues, RegisteredAggregators, }, }; -use frame_support::{assert_noop, assert_ok}; -use qp_wormhole_verifier::{parse_aggregated_public_inputs, BytesDigest, PublicInputsByAccount}; +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"); @@ -37,7 +40,10 @@ fn submit_candidate() -> ([u8; 32], crate::BundleGroupKey) { } fn register_miner() { - let reward_account = account_id(2); + 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)), @@ -48,12 +54,18 @@ fn register_miner() { } fn claim_candidate_bundle() -> ([u8; 32], [u8; 32], Vec<[u8; 32]>) { + claim_candidate_bundle_with_reward(account_id(2)) +} + +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(); + register_miner_with_reward(reward_account.clone()); assert_ok!(MinerAggregation::claim_bundle( RuntimeOrigin::signed(account_id(2)), group_key, - *account_id(2).as_ref(), + *reward_account.as_ref(), MinMinerBond::get() )); let candidate = L0Candidates::::get(candidate_id).expect("candidate stored"); @@ -64,6 +76,64 @@ fn claim_candidate_bundle() -> ([u8; 32], [u8; 32], Vec<[u8; 32]>) { (candidate_id, bundle_id, candidate.nullifiers.to_vec()) } +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 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 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, @@ -203,6 +273,55 @@ fn aggregator_registration_is_stored() { }); } +#[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(|| { @@ -248,6 +367,19 @@ fn claim_bundle_locks_nullifiers_and_marks_candidate_claimed() { }); } +#[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 claim_before_direct_l0_makes_direct_validation_fail() { new_test_ext().execute_with(|| { @@ -400,6 +532,36 @@ fn submit_l1_aggregate_settlement_failure_preserves_miner_active_bundle() { }); } +#[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()); + 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 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 + ); + let candidate = L0Candidates::::get(candidate_id).expect("candidate stored"); + assert_eq!(candidate.status, L0CandidateStatus::Settled { bundle_id }); + }); +} + #[test] fn challenge_valid_candidate_does_not_slash_submitter() { new_test_ext().execute_with(|| { diff --git a/pallets/wormhole/src/lib.rs b/pallets/wormhole/src/lib.rs index ccc3e292..3baa4e87 100644 --- a/pallets/wormhole/src/lib.rs +++ b/pallets/wormhole/src/lib.rs @@ -395,9 +395,8 @@ pub mod pallet { // Determine weight based on which stage failed let actual_weight = match e { // ZK verification was attempted - full weight consumed - Error::::AggregatedVerificationFailed => { - Some(::WeightInfo::verify_aggregated_proof()) - }, + Error::::AggregatedVerificationFailed => + Some(::WeightInfo::verify_aggregated_proof()), // Failed before ZK verification - minimal weight _ => Some(::WeightInfo::pre_validate_proof()), }; diff --git a/pallets/wormhole/src/tests.rs b/pallets/wormhole/src/tests.rs index b97066a4..68984650 100644 --- a/pallets/wormhole/src/tests.rs +++ b/pallets/wormhole/src/tests.rs @@ -622,8 +622,8 @@ mod aggregated_proof_tests { let mut total = 0u128; for account_data in &inputs.account_data { if account_data.summed_output_amount > 0 { - total += (account_data.summed_output_amount as u128) - * crate::SCALE_DOWN_FACTOR; + total += (account_data.summed_output_amount as u128) * + crate::SCALE_DOWN_FACTOR; } } total From 574eae03ac8e4b0cbf45ac2f69852f9e3462318c Mon Sep 17 00:00:00 2001 From: Ethan Date: Fri, 8 May 2026 19:23:22 -0500 Subject: [PATCH 05/13] *Fixes aggregator lifecycle and bond handling *Adds update and unregister flows so registration changes can safely resize or release reserved funds instead of leaving old bond amounts locked. *Blocks registration changes while work is still active and verifies active-job accounting after claim, timeout, and settlement to catch inconsistent state early. --- pallets/miner-aggregation/src/lib.rs | 163 ++++++++++++++-- pallets/miner-aggregation/src/tests.rs | 235 +++++++++++++++++++++++ pallets/miner-aggregation/src/weights.rs | 18 ++ 3 files changed, 400 insertions(+), 16 deletions(-) diff --git a/pallets/miner-aggregation/src/lib.rs b/pallets/miner-aggregation/src/lib.rs index 77a764bc..393a603a 100644 --- a/pallets/miner-aggregation/src/lib.rs +++ b/pallets/miner-aggregation/src/lib.rs @@ -316,6 +316,12 @@ pub mod pallet { AggregatorRegistered { account: T::AccountId, }, + AggregatorUpdated { + account: T::AccountId, + }, + AggregatorUnregistered { + account: T::AccountId, + }, BundleClaimed { bundle_id: BundleId, miner: T::AccountId, @@ -376,6 +382,8 @@ pub mod pallet { ChallengeVerificationUnavailable, InvalidRewardAddress, AggregatorAddressMismatch, + AggregatorHasActiveJobs, + ActiveJobAccountingInconsistent, } #[pallet::call] @@ -464,6 +472,7 @@ pub mod pallet { #[pallet::call_index(1)] #[pallet::weight(::WeightInfo::register_aggregator())] + #[transactional] pub fn register_aggregator( origin: OriginFor, reward_address: [u8; 32], @@ -471,23 +480,13 @@ pub mod pallet { bond: BalanceOf, ) -> DispatchResult { let account = ensure_signed(origin)?; - Self::decode_registered_reward_address(&reward_address)?; - let registered_at = frame_system::Pallet::::block_number(); - if !bond.is_zero() { - ::Currency::reserve(&account, bond) - .map_err(|_| Error::::BondReservationFailed)?; - } - RegisteredAggregators::::insert( + Self::set_aggregator_registration( &account, - AggregatorInfo { - registered_at, - reward_address, - bond, - max_active_jobs, - active_jobs: 0, - }, - ); - Self::deposit_event(Event::AggregatorRegistered { account }); + reward_address, + max_active_jobs, + bond, + true, + )?; Ok(()) } @@ -584,6 +583,7 @@ pub mod pallet { })?; 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(()) @@ -623,6 +623,7 @@ pub mod pallet { ::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)?; bundle.status = BundleStatus::Expired; Bundles::::insert(bundle_id, bundle); @@ -734,9 +735,138 @@ pub mod pallet { 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(()) + } + pub(crate) fn settle_verified_l1_bundle( bundle_id: BundleId, mut bundle: BundleOf, @@ -779,6 +909,7 @@ pub mod pallet { ::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); diff --git a/pallets/miner-aggregation/src/tests.rs b/pallets/miner-aggregation/src/tests.rs index 93b1249b..00154f5d 100644 --- a/pallets/miner-aggregation/src/tests.rs +++ b/pallets/miner-aggregation/src/tests.rs @@ -273,6 +273,171 @@ fn aggregator_registration_is_stored() { }); } +#[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(|| { @@ -461,6 +626,43 @@ fn timeout_bundle_refunds_expired_claimed_candidate() { }); } +#[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 submit_l1_aggregate_rejects_malformed_proof_before_verification() { new_test_ext().execute_with(|| { @@ -485,6 +687,39 @@ fn submit_l1_aggregate_rejects_malformed_proof_before_verification() { }); } +#[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(|| { diff --git a/pallets/miner-aggregation/src/weights.rs b/pallets/miner-aggregation/src/weights.rs index 43f20d2b..bc814215 100644 --- a/pallets/miner-aggregation/src/weights.rs +++ b/pallets/miner-aggregation/src/weights.rs @@ -4,6 +4,8 @@ use frame_support::weights::Weight; 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() -> Weight; @@ -22,6 +24,14 @@ impl WeightInfo for SubstrateWeight { Weight::from_parts(10_000_000, 0) } + fn update_aggregator() -> Weight { + Weight::from_parts(10_000_000, 0) + } + + fn unregister_aggregator() -> Weight { + Weight::from_parts(10_000_000, 0) + } + fn claim_bundle() -> Weight { Weight::from_parts(100_000_000, 0) } @@ -52,6 +62,14 @@ impl WeightInfo for () { Weight::from_parts(10_000_000, 0) } + fn update_aggregator() -> Weight { + Weight::from_parts(10_000_000, 0) + } + + fn unregister_aggregator() -> Weight { + Weight::from_parts(10_000_000, 0) + } + fn claim_bundle() -> Weight { Weight::from_parts(100_000_000, 0) } From 3b1161a436413dc765e118342b081717402a8b0e Mon Sep 17 00:00:00 2001 From: Ethan Date: Fri, 8 May 2026 19:35:32 -0500 Subject: [PATCH 06/13] *Adds delegated L1 prover fee sharing *Rewards delegated L1 aggregation with a configurable share of non-burned volume fees, so prover incentives are paid as part of settlement instead of relying only on tips. *Emits settlement and reward events for better accounting, keeps direct settlement fee behavior unchanged, and preserves burn handling when no block author is available. --- pallets/miner-aggregation/src/lib.rs | 27 ++++- pallets/miner-aggregation/src/mock.rs | 2 + pallets/miner-aggregation/src/tests.rs | 59 ++++++++- pallets/wormhole/src/lib.rs | 45 +++++-- pallets/wormhole/src/mock.rs | 3 + pallets/wormhole/src/tests.rs | 161 ++++++++++++++++++++++++- runtime/src/configs/mod.rs | 5 +- 7 files changed, 283 insertions(+), 19 deletions(-) diff --git a/pallets/miner-aggregation/src/lib.rs b/pallets/miner-aggregation/src/lib.rs index 393a603a..7371ef52 100644 --- a/pallets/miner-aggregation/src/lib.rs +++ b/pallets/miner-aggregation/src/lib.rs @@ -223,7 +223,10 @@ pub mod pallet { #[pallet::config] pub trait Config: frame_system::Config + pallet_wormhole::Config { type RuntimeEvent: From> + IsType<::RuntimeEvent>; - type Currency: ReservableCurrency; + type Currency: ReservableCurrency< + Self::AccountId, + Balance = ::NativeBalance, + >; #[pallet::constant] type MaxL0ProofBytes: Get; @@ -334,6 +337,12 @@ pub mod pallet { 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, @@ -883,23 +892,23 @@ pub mod pallet { }, ) .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, - Some(&reward_account), - ) - .map_err(|_| Error::::ProofMismatch)?; + 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(()) @@ -913,6 +922,12 @@ pub mod pallet { 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(()) } diff --git a/pallets/miner-aggregation/src/mock.rs b/pallets/miner-aggregation/src/mock.rs index c769d90c..4d2ee34d 100644 --- a/pallets/miner-aggregation/src/mock.rs +++ b/pallets/miner-aggregation/src/mock.rs @@ -118,6 +118,7 @@ parameter_types! { 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 { @@ -131,6 +132,7 @@ impl pallet_wormhole::Config for Test { type MinimumTransferAmount = MinimumTransferAmount; type VolumeFeeRateBps = VolumeFeeRateBps; type VolumeFeesBurnRate = VolumeFeesBurnRate; + type AggregationProverFeeShare = AggregationProverFeeShare; type WormholeAccountId = AccountId; type WeightInfo = pallet_wormhole::weights::SubstrateWeight; type ZkTree = (); diff --git a/pallets/miner-aggregation/src/tests.rs b/pallets/miner-aggregation/src/tests.rs index 00154f5d..fe70ae66 100644 --- a/pallets/miner-aggregation/src/tests.rs +++ b/pallets/miner-aggregation/src/tests.rs @@ -773,11 +773,21 @@ fn tips_are_paid_to_registered_reward_account() { 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( @@ -790,13 +800,60 @@ fn tips_are_paid_to_registered_reward_account() { assert_eq!( Balances::balance(&reward_account), - reward_balance_before + aggregation_tip + expected_exit_amount + 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 challenge_valid_candidate_does_not_slash_submitter() { new_test_ext().execute_with(|| { diff --git a/pallets/wormhole/src/lib.rs b/pallets/wormhole/src/lib.rs index 3baa4e87..0327e287 100644 --- a/pallets/wormhole/src/lib.rs +++ b/pallets/wormhole/src/lib.rs @@ -104,6 +104,7 @@ pub mod pallet { pub block_author_fee: Balance, pub aggregation_prover_fee: Balance, pub block_author: Option, + pub aggregation_reward_account: Option, } #[pallet::pallet] @@ -220,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; @@ -314,6 +321,12 @@ 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] @@ -422,7 +435,7 @@ pub mod pallet { exit_amount: prepared.total_exit_amount, nullifiers: nullifier_list, }); - Self::apply_public_output_settlement(prepared, None)?; + 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 }) @@ -713,7 +726,7 @@ pub mod pallet { volume_fee_bps, SettlementKind::DirectL0, )?; - Self::apply_public_output_settlement(prepared, None) + Self::apply_public_output_settlement(prepared) } pub fn prepare_public_output_settlement( @@ -777,9 +790,12 @@ pub mod pallet { 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_prover_fee_u128 = match settlement_kind { - SettlementKind::DirectL0 => 0, - SettlementKind::DelegatedL1 { aggregation_reward_account: _ } => 0, + 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); @@ -824,6 +840,7 @@ pub mod pallet { block_author_fee, aggregation_prover_fee, block_author, + aggregation_reward_account, }) } @@ -832,7 +849,6 @@ pub mod pallet { ::AccountId, BalanceOf, >, - reward_target: Option<&::AccountId>, ) -> Result, Error> { let mint_account = T::MintingAccount::get(); @@ -850,8 +866,10 @@ pub mod pallet { } if !prepared.aggregation_prover_fee.is_zero() { - let reward_target = - reward_target.ok_or(Error::::InvalidAggregatedPublicInputs)?; + let reward_target = prepared + .aggregation_reward_account + .as_ref() + .ok_or(Error::::InvalidAggregatedPublicInputs)?; >::increase_balance( reward_target, prepared.aggregation_prover_fee, @@ -885,6 +903,13 @@ pub mod pallet { ); } + 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) } 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 68984650..c5f923a8 100644 --- a/pallets/wormhole/src/tests.rs +++ b/pallets/wormhole/src/tests.rs @@ -10,6 +10,7 @@ mod wormhole_tests { }; 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 @@ -112,6 +113,37 @@ mod wormhole_tests { } } + 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(|| { @@ -150,13 +182,140 @@ mod wormhole_tests { 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, None)); + 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(|| { diff --git a/runtime/src/configs/mod.rs b/runtime/src/configs/mod.rs index 3697705b..c231d743 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,6 +761,7 @@ 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; From 76fd82d5bce4ac2d5a2f41e916dc41bc4ce54355 Mon Sep 17 00:00:00 2001 From: Ethan Date: Fri, 8 May 2026 19:47:48 -0500 Subject: [PATCH 07/13] *Adds slashing and bundled challenge handling *Adds configurable slashing and challenger rewards so timeouts, invalid proof submissions, and invalid claims are penalized instead of simply releasing reserved funds. *Allows invalid candidates to be challenged even after bundling, which restores unaffected work safely by unlocking nullifiers, re-queueing valid leftovers, and keeping miner job accounting consistent. *Updates runtime parameters, events, weights, and tests to cover the new dispute and penalty flow. --- pallets/miner-aggregation/src/lib.rs | 269 +++++++++++++++++++++-- pallets/miner-aggregation/src/mock.rs | 14 +- pallets/miner-aggregation/src/tests.rs | 253 ++++++++++++++++++++- pallets/miner-aggregation/src/weights.rs | 9 + runtime/src/configs/mod.rs | 8 + 5 files changed, 530 insertions(+), 23 deletions(-) diff --git a/pallets/miner-aggregation/src/lib.rs b/pallets/miner-aggregation/src/lib.rs index 7371ef52..c766860a 100644 --- a/pallets/miner-aggregation/src/lib.rs +++ b/pallets/miner-aggregation/src/lib.rs @@ -17,7 +17,7 @@ pub mod pallet { use codec::{Decode, Encode}; use frame_support::{ pallet_prelude::*, - traits::{Currency, ReservableCurrency}, + traits::{tokens::BalanceStatus, Currency, ReservableCurrency}, transactional, BoundedVec, }; use frame_system::pallet_prelude::*; @@ -25,7 +25,10 @@ pub mod pallet { AggregatedPublicCircuitInputs, BytesDigest, Layer1AggregatedPublicCircuitInputs, PublicInputsByAccount, L0_AGGREGATED_PUBLIC_INPUT_LAYOUT_VERSION, }; - use sp_runtime::traits::{Saturating, Zero}; + use sp_runtime::{ + traits::{Saturating, Zero}, + Permill, + }; pub type CandidateId = [u8; 32]; pub type BundleId = [u8; 32]; @@ -267,6 +270,18 @@ pub mod pallet { #[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; } @@ -347,6 +362,26 @@ pub mod pallet { 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, }, @@ -393,6 +428,7 @@ pub mod pallet { AggregatorAddressMismatch, AggregatorHasActiveJobs, ActiveJobAccountingInconsistent, + CandidateNotInBundle, } #[pallet::call] @@ -629,13 +665,27 @@ pub mod pallet { })?; } Self::return_unexpired_candidates_to_queue(&bundle.group_key, &candidate_ids, now)?; - ::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 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(()) } @@ -653,7 +703,7 @@ pub mod pallet { proof_bytes.len() <= T::MaxL1ProofBytes::get() as usize, Error::::L1ProofTooLarge ); - let bundle = Bundles::::get(bundle_id).ok_or(Error::::BundleNotFound)?; + 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), @@ -667,8 +717,16 @@ pub mod pallet { let inputs = pallet_wormhole::Pallet::::parse_layer1_inputs_from_proof(&proof) .map_err(|_| Error::::MalformedL1PublicInputs)?; Self::ensure_l1_matches_bundle(&bundle, &inputs)?; - pallet_wormhole::Pallet::::verify_layer1_proof(&proof) - .map_err(|_| Error::::L1ProofRejected)?; + 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( @@ -695,26 +753,119 @@ pub mod pallet { Error::::CandidateNotPending ); - match pallet_wormhole::Pallet::::verify_aggregated_proof_for_candidate( - candidate.proof_bytes.as_slice(), - ) { - Ok(_) => return Err(Error::::CandidateValid.into()), - Err(pallet_wormhole::Error::::AggregatedVerificationFailed) => {}, - Err(_) => return Err(Error::::ChallengeVerificationUnavailable.into()), - } + Self::ensure_l0_candidate_invalid(&candidate)?; Self::remove_selected_from_queue(&candidate.group_key, &[candidate_id])?; Self::refund_candidate_storage_and_tip(&candidate); - let (_slashed, _remaining) = ::Currency::slash_reserved( - &candidate.submitter, - candidate.validity_bond, - ); + 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(()) } @@ -876,6 +1027,81 @@ pub mod pallet { 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, @@ -1043,7 +1269,8 @@ pub mod pallet { let Some(candidate) = L0Candidates::::get(candidate_id) else { continue; }; - if now <= candidate.expires_at { + if now <= candidate.expires_at && candidate.status == L0CandidateStatus::Pending + { queue.try_push(*candidate_id).map_err(|_| Error::::QueueFull)?; } } diff --git a/pallets/miner-aggregation/src/mock.rs b/pallets/miner-aggregation/src/mock.rs index 4d2ee34d..29cbdbb1 100644 --- a/pallets/miner-aggregation/src/mock.rs +++ b/pallets/miner-aggregation/src/mock.rs @@ -152,6 +152,10 @@ parameter_types! { 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 { @@ -170,13 +174,21 @@ impl pallet_miner_aggregation::Config for Test { 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)], + 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) diff --git a/pallets/miner-aggregation/src/tests.rs b/pallets/miner-aggregation/src/tests.rs index fe70ae66..dd7947cd 100644 --- a/pallets/miner-aggregation/src/tests.rs +++ b/pallets/miner-aggregation/src/tests.rs @@ -39,6 +39,47 @@ fn submit_candidate() -> ([u8; 32], crate::BundleGroupKey) { (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)); } @@ -57,6 +98,23 @@ 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]>) { @@ -76,6 +134,36 @@ fn claim_candidate_bundle_with_reward( (candidate_id, bundle_id, candidate.nullifiers.to_vec()) } +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 @@ -626,6 +714,33 @@ fn timeout_bundle_refunds_expired_claimed_candidate() { }); } +#[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(|| { @@ -663,6 +778,31 @@ fn active_jobs_timeout_decrements_consistently() { }); } +#[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(|| { @@ -855,10 +995,37 @@ fn delegated_l1_pays_aggregation_prover_fee_share_to_registered_reward_account() } #[test] -fn challenge_valid_candidate_does_not_slash_submitter() { +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( @@ -871,6 +1038,90 @@ fn challenge_valid_candidate_does_not_slash_submitter() { 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 + ); }); } diff --git a/pallets/miner-aggregation/src/weights.rs b/pallets/miner-aggregation/src/weights.rs index bc814215..d3045265 100644 --- a/pallets/miner-aggregation/src/weights.rs +++ b/pallets/miner-aggregation/src/weights.rs @@ -10,6 +10,7 @@ pub trait WeightInfo { fn timeout_bundle() -> Weight; fn submit_l1_aggregate() -> Weight; fn challenge_invalid_l0_candidate() -> Weight; + fn challenge_invalid_l0_in_bundle() -> Weight; fn drop_expired_candidate() -> Weight; } @@ -48,6 +49,10 @@ impl WeightInfo for SubstrateWeight { Weight::from_parts(500_000_000, 0) } + fn challenge_invalid_l0_in_bundle() -> Weight { + Weight::from_parts(500_000_000, 0) + } + fn drop_expired_candidate() -> Weight { Weight::from_parts(25_000_000, 0) } @@ -86,6 +91,10 @@ impl WeightInfo for () { Weight::from_parts(500_000_000, 0) } + fn challenge_invalid_l0_in_bundle() -> Weight { + Weight::from_parts(500_000_000, 0) + } + fn drop_expired_candidate() -> Weight { Weight::from_parts(25_000_000, 0) } diff --git a/runtime/src/configs/mod.rs b/runtime/src/configs/mod.rs index c231d743..20c15f4d 100644 --- a/runtime/src/configs/mod.rs +++ b/runtime/src/configs/mod.rs @@ -781,6 +781,10 @@ parameter_types! { 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 { @@ -799,6 +803,10 @@ impl pallet_miner_aggregation::Config for Runtime { 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; } From 1c58ef649821f5ea204761f3dd35ea29f7cc89a5 Mon Sep 17 00:00:00 2001 From: Ethan Date: Fri, 8 May 2026 19:56:39 -0500 Subject: [PATCH 08/13] *Tightens L1 aggregate effect validation *Adds stronger MVP checks so settlement rejects mismatched exits, nullifiers, reordered effects, and inconsistent exit slot counts. *Clarifies that the bundle root remains metadata until the L1 circuit constrains it, and adds focused tests to lock in the intended verification behavior. --- pallets/miner-aggregation/src/lib.rs | 7 ++ pallets/miner-aggregation/src/tests.rs | 132 +++++++++++++++++++++++++ 2 files changed, 139 insertions(+) diff --git a/pallets/miner-aggregation/src/lib.rs b/pallets/miner-aggregation/src/lib.rs index c766860a..aa411c0e 100644 --- a/pallets/miner-aggregation/src/lib.rs +++ b/pallets/miner-aggregation/src/lib.rs @@ -204,6 +204,7 @@ pub mod pallet { 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, @@ -1354,6 +1355,8 @@ pub mod pallet { 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 @@ -1383,6 +1386,10 @@ pub mod pallet { 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!( diff --git a/pallets/miner-aggregation/src/tests.rs b/pallets/miner-aggregation/src/tests.rs index dd7947cd..50fbccd0 100644 --- a/pallets/miner-aggregation/src/tests.rs +++ b/pallets/miner-aggregation/src/tests.rs @@ -207,6 +207,27 @@ fn layer1_inputs_for_candidate( } } +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, @@ -633,6 +654,117 @@ fn submit_l1_aggregate_rejects_proof_with_wrong_aggregator_address() { }); } +#[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 claim_before_direct_l0_makes_direct_validation_fail() { new_test_ext().execute_with(|| { From 7255236c653a60ceb4eb502ebfff8d0f9ba67328 Mon Sep 17 00:00:00 2001 From: Ethan Date: Fri, 8 May 2026 20:44:14 -0500 Subject: [PATCH 09/13] *Adds L1 settlement fixture coverage *Verifies successful aggregate settlement against real L1 fixtures so the positive path no longer relies on cheap rejection checks alone. *Adds targeted mismatch cases to catch metadata drift before settlement and protect balance, bond, and nullifier handling. *Updates testing notes to document release-mode fixture generation and the environment needed to run the L1 proof path. --- pallets/miner-aggregation/README.md | 13 +- pallets/miner-aggregation/src/tests.rs | 287 +++++++++++++++++- .../test-data/expected_bundle.json | 160 ++++++++++ .../test-data/l0_candidate_0.hex | 1 + .../test-data/l1_aggregate.hex | 1 + scripts/generate-delegated-l1-fixture.sh | 23 ++ 6 files changed, 479 insertions(+), 6 deletions(-) create mode 100644 pallets/miner-aggregation/test-data/expected_bundle.json create mode 100644 pallets/miner-aggregation/test-data/l0_candidate_0.hex create mode 100644 pallets/miner-aggregation/test-data/l1_aggregate.hex create mode 100755 scripts/generate-delegated-l1-fixture.sh diff --git a/pallets/miner-aggregation/README.md b/pallets/miner-aggregation/README.md index 4199f803..853e6c5e 100644 --- a/pallets/miner-aggregation/README.md +++ b/pallets/miner-aggregation/README.md @@ -16,15 +16,18 @@ Current scope: - 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 current pallet tests use -precomputed fixture proof bytes and do not generate proofs. +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: -- Claimed-bundle invalid-candidate challenge and partial miner slashing are not implemented yet. -- L1 proof settlement is wired to the L1 verifier helper, but the test suite currently covers cheap - rejection only because no local L1 aggregate proof fixture is available. +- L1 fixture regeneration must use `chain/scripts/generate-delegated-l1-fixture.sh`, which runs + proving in release mode. +- 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. diff --git a/pallets/miner-aggregation/src/tests.rs b/pallets/miner-aggregation/src/tests.rs index 50fbccd0..540ab7f6 100644 --- a/pallets/miner-aggregation/src/tests.rs +++ b/pallets/miner-aggregation/src/tests.rs @@ -13,9 +13,23 @@ use qp_wormhole_verifier::{ 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 { - hex::decode(AGGREGATED_PROOF_HEX.trim()).expect("valid aggregated proof hex") + 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]) { @@ -134,6 +148,51 @@ fn claim_candidate_bundle_with_reward( (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 group_key = L0Candidates::::get(candidate_id).expect("candidate stored").group_key; + 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"), + }; + + 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"); @@ -176,6 +235,22 @@ fn public_outputs_from_candidate(candidate_id: [u8; 32]) -> Vec 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], @@ -765,6 +840,216 @@ fn bundle_root_is_metadata_until_constrained_by_l1_circuit() { }); } +#[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(|| { 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..16a353d6 --- /dev/null +++ b/pallets/miner-aggregation/test-data/l1_aggregate.hex @@ -0,0 +1 @@ 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 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" From 4978499252899b0ff3ce9d9af653a40707d01e70 Mon Sep 17 00:00:00 2001 From: Ethan Date: Fri, 8 May 2026 20:48:36 -0500 Subject: [PATCH 10/13] *fmt --- pallets/miner-aggregation/src/tests.rs | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/pallets/miner-aggregation/src/tests.rs b/pallets/miner-aggregation/src/tests.rs index 540ab7f6..b0ec0ff7 100644 --- a/pallets/miner-aggregation/src/tests.rs +++ b/pallets/miner-aggregation/src/tests.rs @@ -908,9 +908,9 @@ fn submit_l1_aggregate_accepts_valid_fixture_and_settles_bundle() { 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; + expected_balance = expected_balance + + candidate_before.aggregation_tip + + prepared.aggregation_prover_fee; } if account == miner { expected_balance += bundle_before.miner_bond; @@ -918,9 +918,9 @@ fn submit_l1_aggregate_accepts_valid_fixture_and_settles_bundle() { 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; + 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; } From 8776a21cb278e4a9aa9fe4c68947ced4e600c50c Mon Sep 17 00:00:00 2001 From: Ethan Date: Sat, 9 May 2026 16:55:31 -0500 Subject: [PATCH 11/13] *Pins circuit deps and documents weights *Pins the ZK circuit dependencies to an exact revision so downstream builds stay reproducible and aligned across related repos during delegated aggregation work. *Clarifies MVP limitations and the current dependency strategy, and documents that runtime weights are conservative placeholders rather than benchmark output. *Splits aggregate submission estimates by cheap-reject vs valid-proof paths and keeps the dispatchable on the safe upper bound until real benchmarks replace the placeholders. --- Cargo.lock | 14 ++--- Cargo.toml | 10 ++-- docs/delegated-l1-aggregation.md | 29 +++++++++- pallets/miner-aggregation/README.md | 7 +++ pallets/miner-aggregation/src/weights.rs | 74 +++++++++++++++++------- 5 files changed, 99 insertions(+), 35 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 6d949654..9d5e8b8f 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -8381,7 +8381,7 @@ dependencies = [ [[package]] name = "qp-wormhole-aggregator" version = "2.0.1" -source = "git+https://github.com/Quantus-Network/qp-zk-circuits?branch=miner-aggr#b0896a7b336fa468334da8178bfe9182f391e865" +source = "git+https://github.com/Quantus-Network/qp-zk-circuits?rev=982fd4de36019c108169fedcff348003a06ad465#982fd4de36019c108169fedcff348003a06ad465" dependencies = [ "anyhow", "hex", @@ -8398,7 +8398,7 @@ dependencies = [ [[package]] name = "qp-wormhole-circuit" version = "2.0.1" -source = "git+https://github.com/Quantus-Network/qp-zk-circuits?branch=miner-aggr#b0896a7b336fa468334da8178bfe9182f391e865" +source = "git+https://github.com/Quantus-Network/qp-zk-circuits?rev=982fd4de36019c108169fedcff348003a06ad465#982fd4de36019c108169fedcff348003a06ad465" dependencies = [ "anyhow", "hex", @@ -8410,7 +8410,7 @@ dependencies = [ [[package]] name = "qp-wormhole-circuit-builder" version = "2.0.1" -source = "git+https://github.com/Quantus-Network/qp-zk-circuits?branch=miner-aggr#b0896a7b336fa468334da8178bfe9182f391e865" +source = "git+https://github.com/Quantus-Network/qp-zk-circuits?rev=982fd4de36019c108169fedcff348003a06ad465#982fd4de36019c108169fedcff348003a06ad465" dependencies = [ "anyhow", "clap", @@ -8423,7 +8423,7 @@ dependencies = [ [[package]] name = "qp-wormhole-inputs" version = "2.0.1" -source = "git+https://github.com/Quantus-Network/qp-zk-circuits?branch=miner-aggr#b0896a7b336fa468334da8178bfe9182f391e865" +source = "git+https://github.com/Quantus-Network/qp-zk-circuits?rev=982fd4de36019c108169fedcff348003a06ad465#982fd4de36019c108169fedcff348003a06ad465" dependencies = [ "anyhow", ] @@ -8431,7 +8431,7 @@ dependencies = [ [[package]] name = "qp-wormhole-prover" version = "2.0.1" -source = "git+https://github.com/Quantus-Network/qp-zk-circuits?branch=miner-aggr#b0896a7b336fa468334da8178bfe9182f391e865" +source = "git+https://github.com/Quantus-Network/qp-zk-circuits?rev=982fd4de36019c108169fedcff348003a06ad465#982fd4de36019c108169fedcff348003a06ad465" dependencies = [ "anyhow", "qp-plonky2", @@ -8443,7 +8443,7 @@ dependencies = [ [[package]] name = "qp-wormhole-verifier" version = "2.0.1" -source = "git+https://github.com/Quantus-Network/qp-zk-circuits?branch=miner-aggr#b0896a7b336fa468334da8178bfe9182f391e865" +source = "git+https://github.com/Quantus-Network/qp-zk-circuits?rev=982fd4de36019c108169fedcff348003a06ad465#982fd4de36019c108169fedcff348003a06ad465" dependencies = [ "anyhow", "qp-plonky2-verifier", @@ -8453,7 +8453,7 @@ dependencies = [ [[package]] name = "qp-zk-circuits-common" version = "2.0.1" -source = "git+https://github.com/Quantus-Network/qp-zk-circuits?branch=miner-aggr#b0896a7b336fa468334da8178bfe9182f391e865" +source = "git+https://github.com/Quantus-Network/qp-zk-circuits?rev=982fd4de36019c108169fedcff348003a06ad465#982fd4de36019c108169fedcff348003a06ad465" dependencies = [ "anyhow", "hex", diff --git a/Cargo.toml b/Cargo.toml index 655cd2b8..0c1af5e1 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -157,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", git = "https://github.com/Quantus-Network/qp-zk-circuits", branch = "miner-aggr", default-features = false } -qp-wormhole-circuit-builder = { version = "2.0.1", git = "https://github.com/Quantus-Network/qp-zk-circuits", branch = "miner-aggr", default-features = false } -qp-wormhole-prover = { version = "2.0.1", git = "https://github.com/Quantus-Network/qp-zk-circuits", branch = "miner-aggr", default-features = false } -qp-wormhole-verifier = { version = "2.0.1", git = "https://github.com/Quantus-Network/qp-zk-circuits", branch = "miner-aggr", default-features = false } -qp-zk-circuits-common = { version = "2.0.1", git = "https://github.com/Quantus-Network/qp-zk-circuits", branch = "miner-aggr", 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 index 424567ba..9d33a49a 100644 --- a/docs/delegated-l1-aggregation.md +++ b/docs/delegated-l1-aggregation.md @@ -40,9 +40,32 @@ Current reward and bond model: MVP limitations: - L1 public inputs do not yet expose a constrained `bundle_root`; settlement compares the reconstructed public effects instead. -- Invalid-candidate challenge currently handles pending candidates only. Claimed-bundle challenge and partial miner slashing are left for the next hardening pass. -- The external miner has separate ZK aggregation CLI/config/worker-pool scaffolding, but the chain RPC watcher and L1 prover submission loop are not complete. -- The full local E2E needs generated L1 prover/verifier artifacts and client L0 proof fixtures. +- `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. +- 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. We need to replace them with autogenerated benchmark output before in future commits. ZK proving tests must use release mode: diff --git a/pallets/miner-aggregation/README.md b/pallets/miner-aggregation/README.md index 853e6c5e..a9387ee2 100644 --- a/pallets/miner-aggregation/README.md +++ b/pallets/miner-aggregation/README.md @@ -31,3 +31,10 @@ MVP limitations: - 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. +- These weights are not benchmark-generated and must be replaced with runtime benchmark output before release. diff --git a/pallets/miner-aggregation/src/weights.rs b/pallets/miner-aggregation/src/weights.rs index d3045265..17fa6679 100644 --- a/pallets/miner-aggregation/src/weights.rs +++ b/pallets/miner-aggregation/src/weights.rs @@ -1,6 +1,22 @@ 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; @@ -8,6 +24,8 @@ pub trait WeightInfo { 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; @@ -18,84 +36,100 @@ pub struct SubstrateWeight(PhantomData); impl WeightInfo for SubstrateWeight { fn submit_l0_candidate() -> Weight { - Weight::from_parts(100_000_000, 0) + SUBMIT_L0_CANDIDATE } fn register_aggregator() -> Weight { - Weight::from_parts(10_000_000, 0) + REGISTER_AGGREGATOR } fn update_aggregator() -> Weight { - Weight::from_parts(10_000_000, 0) + UPDATE_AGGREGATOR } fn unregister_aggregator() -> Weight { - Weight::from_parts(10_000_000, 0) + UNREGISTER_AGGREGATOR } fn claim_bundle() -> Weight { - Weight::from_parts(100_000_000, 0) + CLAIM_BUNDLE } fn timeout_bundle() -> Weight { - Weight::from_parts(50_000_000, 0) + 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 { - Weight::from_parts(500_000_000, 0) + Self::submit_l1_aggregate_valid_proof() } fn challenge_invalid_l0_candidate() -> Weight { - Weight::from_parts(500_000_000, 0) + CHALLENGE_INVALID_L0_CANDIDATE } fn challenge_invalid_l0_in_bundle() -> Weight { - Weight::from_parts(500_000_000, 0) + CHALLENGE_INVALID_L0_IN_BUNDLE } fn drop_expired_candidate() -> Weight { - Weight::from_parts(25_000_000, 0) + DROP_EXPIRED_CANDIDATE } } impl WeightInfo for () { fn submit_l0_candidate() -> Weight { - Weight::from_parts(100_000_000, 0) + SUBMIT_L0_CANDIDATE } fn register_aggregator() -> Weight { - Weight::from_parts(10_000_000, 0) + REGISTER_AGGREGATOR } fn update_aggregator() -> Weight { - Weight::from_parts(10_000_000, 0) + UPDATE_AGGREGATOR } fn unregister_aggregator() -> Weight { - Weight::from_parts(10_000_000, 0) + UNREGISTER_AGGREGATOR } fn claim_bundle() -> Weight { - Weight::from_parts(100_000_000, 0) + CLAIM_BUNDLE } fn timeout_bundle() -> Weight { - Weight::from_parts(50_000_000, 0) + 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 { - Weight::from_parts(500_000_000, 0) + Self::submit_l1_aggregate_valid_proof() } fn challenge_invalid_l0_candidate() -> Weight { - Weight::from_parts(500_000_000, 0) + CHALLENGE_INVALID_L0_CANDIDATE } fn challenge_invalid_l0_in_bundle() -> Weight { - Weight::from_parts(500_000_000, 0) + CHALLENGE_INVALID_L0_IN_BUNDLE } fn drop_expired_candidate() -> Weight { - Weight::from_parts(25_000_000, 0) + DROP_EXPIRED_CANDIDATE } } From 9ee53f33f432fe1e85aaad27a85f671e00dc0af2 Mon Sep 17 00:00:00 2001 From: Ethan Date: Sat, 9 May 2026 17:19:48 -0500 Subject: [PATCH 12/13] *Adds nullifier locking claim coverage *Ensures tests verify settlement inputs stay available before a bundle is claimed, then become locked once claimed. *Prevents regressions where direct settlement could proceed after claim and strengthens coverage around bundle state transitions. --- docs/delegated-l1-aggregation.md | 11 ++++++ pallets/miner-aggregation/README.md | 2 ++ pallets/miner-aggregation/src/tests.rs | 30 ++++++++++++---- .../test-data/l1_aggregate.hex | 2 +- scripts/e2e-delegated-l1-aggregation.sh | 34 +++++++++++++++++++ 5 files changed, 71 insertions(+), 8 deletions(-) create mode 100755 scripts/e2e-delegated-l1-aggregation.sh diff --git a/docs/delegated-l1-aggregation.md b/docs/delegated-l1-aggregation.md index 9d33a49a..1c67568f 100644 --- a/docs/delegated-l1-aggregation.md +++ b/docs/delegated-l1-aggregation.md @@ -76,3 +76,14 @@ 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/README.md b/pallets/miner-aggregation/README.md index a9387ee2..b6df24d3 100644 --- a/pallets/miner-aggregation/README.md +++ b/pallets/miner-aggregation/README.md @@ -28,6 +28,8 @@ 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. diff --git a/pallets/miner-aggregation/src/tests.rs b/pallets/miner-aggregation/src/tests.rs index b0ec0ff7..96e650e3 100644 --- a/pallets/miner-aggregation/src/tests.rs +++ b/pallets/miner-aggregation/src/tests.rs @@ -172,7 +172,16 @@ fn claim_l1_fixture_bundle() -> Option { 5 )); let candidate_id = sp_io::hashing::blake2_256(&l0_proof_bytes); - let group_key = L0Candidates::::get(candidate_id).expect("candidate stored").group_key; + 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)), @@ -185,6 +194,13 @@ fn claim_l1_fixture_bundle() -> Option { 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, @@ -908,9 +924,9 @@ fn submit_l1_aggregate_accepts_valid_fixture_and_settles_bundle() { 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; + expected_balance = expected_balance + + candidate_before.aggregation_tip + + prepared.aggregation_prover_fee; } if account == miner { expected_balance += bundle_before.miner_bond; @@ -918,9 +934,9 @@ fn submit_l1_aggregate_accepts_valid_fixture_and_settles_bundle() { 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; + 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; } diff --git a/pallets/miner-aggregation/test-data/l1_aggregate.hex b/pallets/miner-aggregation/test-data/l1_aggregate.hex index 16a353d6..0c686fb4 100644 --- a/pallets/miner-aggregation/test-data/l1_aggregate.hex +++ b/pallets/miner-aggregation/test-data/l1_aggregate.hex @@ -1 +1 @@ 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 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 +) From ea8fa514a54e797bdf55e5411a88d8af57b9f91d Mon Sep 17 00:00:00 2001 From: Ethan Date: Sun, 10 May 2026 20:16:16 -0500 Subject: [PATCH 13/13] *Adds benchmark hooks and nullifier tests *Prepares runtime benchmarking so weight generation can be wired in and documented before release, including the current fixture mismatch that blocks full regeneration. *Strengthens bundle-claim coverage by verifying claims fail cleanly when nullifiers are already locked or used, preserving queue state, balances, and job accounting. --- Cargo.lock | 1 + docs/delegated-l1-aggregation.md | 24 +- pallets/miner-aggregation/Cargo.toml | 7 + pallets/miner-aggregation/README.md | 23 +- pallets/miner-aggregation/src/benchmarking.rs | 373 ++++++++++++++++++ pallets/miner-aggregation/src/lib.rs | 2 + pallets/miner-aggregation/src/tests.rs | 94 ++++- runtime/src/benchmarks.rs | 1 + 8 files changed, 517 insertions(+), 8 deletions(-) create mode 100644 pallets/miner-aggregation/src/benchmarking.rs diff --git a/Cargo.lock b/Cargo.lock index 9d5e8b8f..5bb47116 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -6609,6 +6609,7 @@ dependencies = [ name = "pallet-miner-aggregation" version = "0.1.0" dependencies = [ + "frame-benchmarking", "frame-support", "frame-system", "hex", diff --git a/docs/delegated-l1-aggregation.md b/docs/delegated-l1-aggregation.md index 1c67568f..15f1952c 100644 --- a/docs/delegated-l1-aggregation.md +++ b/docs/delegated-l1-aggregation.md @@ -58,6 +58,8 @@ Dependency strategy: 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`, @@ -65,7 +67,27 @@ Runtime weights: `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. We need to replace them with autogenerated benchmark output before in future commits. +- 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: diff --git a/pallets/miner-aggregation/Cargo.toml b/pallets/miner-aggregation/Cargo.toml index 46c1fe2b..513e4bab 100644 --- a/pallets/miner-aggregation/Cargo.toml +++ b/pallets/miner-aggregation/Cargo.toml @@ -9,8 +9,10 @@ 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"] } @@ -32,14 +34,19 @@ 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", diff --git a/pallets/miner-aggregation/README.md b/pallets/miner-aggregation/README.md index b6df24d3..46d1ed8c 100644 --- a/pallets/miner-aggregation/README.md +++ b/pallets/miner-aggregation/README.md @@ -39,4 +39,25 @@ 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. -- These weights are not benchmark-generated and must be replaced with runtime benchmark output before release. +- 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 index aa411c0e..d65b9f49 100644 --- a/pallets/miner-aggregation/src/lib.rs +++ b/pallets/miner-aggregation/src/lib.rs @@ -5,6 +5,8 @@ pub use pallet::*; pub mod weights; pub use weights::*; +#[cfg(feature = "runtime-benchmarks")] +mod benchmarking; #[cfg(test)] mod mock; #[cfg(test)] diff --git a/pallets/miner-aggregation/src/tests.rs b/pallets/miner-aggregation/src/tests.rs index 96e650e3..2d6ccf14 100644 --- a/pallets/miner-aggregation/src/tests.rs +++ b/pallets/miner-aggregation/src/tests.rs @@ -732,6 +732,88 @@ fn claim_bundle_locks_nullifiers_and_marks_candidate_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(|| { @@ -924,9 +1006,9 @@ fn submit_l1_aggregate_accepts_valid_fixture_and_settles_bundle() { 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; + expected_balance = expected_balance + + candidate_before.aggregation_tip + + prepared.aggregation_prover_fee; } if account == miner { expected_balance += bundle_before.miner_bond; @@ -934,9 +1016,9 @@ fn submit_l1_aggregate_accepts_valid_fixture_and_settles_bundle() { 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; + 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; } 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] );