From 93c59472fb7c0472f9a422b26bed591ad7edbe5f Mon Sep 17 00:00:00 2001 From: illuzen Date: Sat, 11 Apr 2026 21:24:12 +0800 Subject: [PATCH 01/19] zk-trie implemented --- Cargo.lock | 19 ++ Cargo.toml | 2 + node/Cargo.toml | 2 + node/src/main.rs | 1 + node/src/rpc.rs | 7 +- node/src/zktrie_rpc.rs | 103 ++++++++ pallets/zk-trie/Cargo.toml | 47 ++++ pallets/zk-trie/src/lib.rs | 271 +++++++++++++++++++ pallets/zk-trie/src/tests.rs | 488 +++++++++++++++++++++++++++++++++++ pallets/zk-trie/src/tree.rs | 311 ++++++++++++++++++++++ runtime/Cargo.toml | 2 + runtime/src/apis.rs | 39 ++- runtime/src/configs/mod.rs | 5 + runtime/src/lib.rs | 3 + 14 files changed, 1298 insertions(+), 2 deletions(-) create mode 100644 node/src/zktrie_rpc.rs create mode 100644 pallets/zk-trie/Cargo.toml create mode 100644 pallets/zk-trie/src/lib.rs create mode 100644 pallets/zk-trie/src/tests.rs create mode 100644 pallets/zk-trie/src/tree.rs diff --git a/Cargo.lock b/Cargo.lock index 0371ef46..14e770dd 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -6947,6 +6947,23 @@ dependencies = [ "sp-trie", ] +[[package]] +name = "pallet-zk-trie" +version = "0.1.0" +dependencies = [ + "frame-support", + "frame-system", + "log", + "parity-scale-codec", + "qp-poseidon-core", + "scale-info", + "serde", + "sp-api", + "sp-core", + "sp-io", + "sp-runtime", +] + [[package]] name = "parity-bip39" version = "2.0.1" @@ -8522,6 +8539,7 @@ dependencies = [ "pallet-transaction-payment", "pallet-transaction-payment-rpc", "pallet-utility", + "pallet-zk-trie", "parity-scale-codec", "prometheus", "qp-dilithium-crypto", @@ -8602,6 +8620,7 @@ dependencies = [ "pallet-treasury", "pallet-utility", "pallet-wormhole", + "pallet-zk-trie", "parity-scale-codec", "primitive-types 0.13.1", "qp-dilithium-crypto", diff --git a/Cargo.toml b/Cargo.toml index 4a9412ff..eb11bc1e 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -21,6 +21,7 @@ members = [ "pallets/scheduler", "pallets/treasury", "pallets/wormhole", + "pallets/zk-trie", "primitives/consensus/qpow", "primitives/dilithium-crypto", "primitives/header", @@ -139,6 +140,7 @@ pallet-qpow = { path = "./pallets/qpow", default-features = false } pallet-reversible-transfers = { path = "./pallets/reversible-transfers", default-features = false } pallet-scheduler = { path = "./pallets/scheduler", default-features = false } pallet-wormhole = { path = "./pallets/wormhole", default-features = false } +pallet-zk-trie = { path = "./pallets/zk-trie", default-features = false } qp-dilithium-crypto = { path = "./primitives/dilithium-crypto", version = "0.3.1", default-features = false } qp-header = { path = "./primitives/header", default-features = false } qp-scheduler = { path = "./primitives/scheduler", default-features = false } diff --git a/node/Cargo.toml b/node/Cargo.toml index c8af5784..33106fed 100644 --- a/node/Cargo.toml +++ b/node/Cargo.toml @@ -36,6 +36,8 @@ pallet-transaction-payment-rpc.default-features = true pallet-transaction-payment-rpc.workspace = true pallet-utility.default-features = true pallet-utility.workspace = true +pallet-zk-trie.default-features = true +pallet-zk-trie.workspace = true prometheus.workspace = true qp-dilithium-crypto = { workspace = true } qp-poseidon.workspace = true diff --git a/node/src/main.rs b/node/src/main.rs index dc67ea5a..5b70bdaa 100644 --- a/node/src/main.rs +++ b/node/src/main.rs @@ -13,6 +13,7 @@ mod service; #[cfg(test)] mod tests; mod txwatch; +mod zktrie_rpc; #[allow(clippy::result_large_err)] fn main() -> sc_cli::Result<()> { diff --git a/node/src/rpc.rs b/node/src/rpc.rs index e0c319f0..29ebaea1 100644 --- a/node/src/rpc.rs +++ b/node/src/rpc.rs @@ -111,10 +111,14 @@ where C::Api: substrate_frame_rpc_system::AccountNonceApi, C::Api: pallet_transaction_payment_rpc::TransactionPaymentRuntimeApi, C::Api: sp_consensus_qpow::QPoWApi, + C::Api: pallet_zk_trie::ZkTrieApi, C::Api: BlockBuilder, P: TransactionPool + 'static, { - use crate::txwatch::{TxWatch, TxWatchApiServer}; + use crate::{ + txwatch::{TxWatch, TxWatchApiServer}, + zktrie_rpc::{ZkTrie, ZkTrieApiServer}, + }; use pallet_transaction_payment_rpc::{TransactionPayment, TransactionPaymentApiServer}; use substrate_frame_rpc_system::{System, SystemApiServer}; @@ -125,6 +129,7 @@ where module.merge(TransactionPayment::new(client.clone()).into_rpc())?; module.merge(Peer::new(network).into_rpc())?; module.merge(TxWatch::new(pool).into_rpc())?; + module.merge(ZkTrie::new(client).into_rpc())?; Ok(module) } diff --git a/node/src/zktrie_rpc.rs b/node/src/zktrie_rpc.rs new file mode 100644 index 00000000..f541368a --- /dev/null +++ b/node/src/zktrie_rpc.rs @@ -0,0 +1,103 @@ +//! ZK Trie RPC API implementation. +//! +//! Provides RPC methods for querying the ZK Merkle tree state and generating proofs. + +use std::sync::Arc; + +use jsonrpsee::{core::RpcResult, proc_macros::rpc}; +use pallet_zk_trie::{Hash256, ZkMerkleProofRpc, ZkTrieApi as ZkTrieRuntimeApi}; +use quantus_runtime::opaque::Block; +use serde::{Deserialize, Serialize}; +use sp_api::ProvideRuntimeApi; +use sp_blockchain::HeaderBackend; + +/// ZK Trie state information returned by the RPC. +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct ZkTrieState { + /// Current root hash of the ZK tree. + pub root: Hash256, + /// Number of leaves in the tree. + pub leaf_count: u64, + /// Current depth of the tree. + pub depth: u8, +} + +/// ZK Trie RPC API trait. +#[rpc(client, server)] +pub trait ZkTrieApi { + /// Get the current state of the ZK trie. + /// + /// Returns the current root hash, leaf count, and tree depth. + #[method(name = "zkTrie_getState")] + fn get_state(&self) -> RpcResult; + + /// Get a Merkle proof for a leaf at the given index. + /// + /// Returns `null` if the leaf index is out of bounds. + #[method(name = "zkTrie_getMerkleProof")] + fn get_merkle_proof(&self, leaf_index: u64) -> RpcResult>; +} + +/// ZK Trie RPC handler. +pub struct ZkTrie { + client: Arc, +} + +impl ZkTrie { + /// Create a new ZkTrie RPC handler. + pub fn new(client: Arc) -> Self { + Self { client } + } +} + +impl ZkTrieApiServer for ZkTrie +where + C: ProvideRuntimeApi, + C: HeaderBackend + Send + Sync + 'static, + C::Api: ZkTrieRuntimeApi, +{ + fn get_state(&self) -> RpcResult { + let best_hash = self.client.info().best_hash; + + let root = self.client.runtime_api().get_root(best_hash).map_err(|e| { + jsonrpsee::types::error::ErrorObject::owned( + 9000, + format!("Failed to get ZK trie root: {:?}", e), + None::<()>, + ) + })?; + + let leaf_count = self.client.runtime_api().get_leaf_count(best_hash).map_err(|e| { + jsonrpsee::types::error::ErrorObject::owned( + 9001, + format!("Failed to get ZK trie leaf count: {:?}", e), + None::<()>, + ) + })?; + + let depth = self.client.runtime_api().get_depth(best_hash).map_err(|e| { + jsonrpsee::types::error::ErrorObject::owned( + 9002, + format!("Failed to get ZK trie depth: {:?}", e), + None::<()>, + ) + })?; + + Ok(ZkTrieState { root, leaf_count, depth }) + } + + fn get_merkle_proof(&self, leaf_index: u64) -> RpcResult> { + let best_hash = self.client.info().best_hash; + + let proof = + self.client.runtime_api().get_merkle_proof(best_hash, leaf_index).map_err(|e| { + jsonrpsee::types::error::ErrorObject::owned( + 9003, + format!("Failed to get ZK merkle proof: {:?}", e), + None::<()>, + ) + })?; + + Ok(proof) + } +} diff --git a/pallets/zk-trie/Cargo.toml b/pallets/zk-trie/Cargo.toml new file mode 100644 index 00000000..8ab087ba --- /dev/null +++ b/pallets/zk-trie/Cargo.toml @@ -0,0 +1,47 @@ +[package] +authors.workspace = true +edition.workspace = true +homepage.workspace = true +license.workspace = true +name = "pallet-zk-trie" +repository.workspace = true +version = "0.1.0" +description = "4-ary Poseidon Merkle tree for ZK transfer proofs" + +[dependencies] +codec = { workspace = true, default-features = false, features = ["derive"] } +frame-support.workspace = true +frame-system.workspace = true +log.workspace = true +qp-poseidon-core = { workspace = true, default-features = false } +scale-info = { workspace = true, default-features = false, features = ["derive"] } +serde = { workspace = true, optional = true } +sp-api = { workspace = true, default-features = false } +sp-core.workspace = true +sp-runtime.workspace = true + +[dev-dependencies] +sp-io.workspace = true + +[features] +default = ["std"] +runtime-benchmarks = [ + "frame-support/runtime-benchmarks", + "frame-system/runtime-benchmarks", +] +std = [ + "codec/std", + "frame-support/std", + "frame-system/std", + "log/std", + "qp-poseidon-core/std", + "scale-info/std", + "serde/std", + "sp-api/std", + "sp-core/std", + "sp-runtime/std", +] +try-runtime = [ + "frame-support/try-runtime", + "frame-system/try-runtime", +] diff --git a/pallets/zk-trie/src/lib.rs b/pallets/zk-trie/src/lib.rs new file mode 100644 index 00000000..06fa65e9 --- /dev/null +++ b/pallets/zk-trie/src/lib.rs @@ -0,0 +1,271 @@ +//! # ZK Trie Pallet +//! +//! A 4-ary Poseidon Merkle tree for storing ZK transfer proofs. +//! +//! ## Overview +//! +//! This pallet provides a separate Merkle tree structure optimized for ZK circuits: +//! - 4-ary tree (4 children per node) for optimal ZK circuit efficiency +//! - Leaves hashed with injective Poseidon (4 bytes/felt) for collision resistance +//! - Internal nodes hashed with non-injective Poseidon (8 bytes/felt) for efficiency +//! - Tree root published in block digest for ZK verification +//! +//! ## Tree Structure +//! +//! ```text +//! [Root] Level 2 +//! / | \ \ +//! [N0] [N1] [N2] [N3] Level 1 +//! /|||\ ... +//! [L0-L3] ... Level 0 (leaves) +//! ``` +//! +//! Leaf data: (to_account, transfer_count, asset_id, amount) +//! Leaf hash: injective_poseidon(leaf_data) +//! Node hash: poseidon(child0 || child1 || child2 || child3) + +#![cfg_attr(not(feature = "std"), no_std)] + +extern crate alloc; + +use alloc::vec::Vec; + +pub use pallet::*; + +pub mod tree; + +#[cfg(test)] +mod tests; + +/// Maximum depth supported by ZK circuits. +/// A tree of depth 32 can hold 4^32 leaves (more than enough). +pub const MAX_TREE_DEPTH: u8 = 32; + +/// Branching factor of the tree. +pub const ARITY: usize = 4; + +/// A 32-byte hash output. +pub type Hash256 = [u8; 32]; + +/// Leaf data for the ZK tree. +#[derive( + codec::Encode, + codec::Decode, + codec::MaxEncodedLen, + Clone, + PartialEq, + Eq, + scale_info::TypeInfo, + Debug, +)] +pub struct ZkLeaf { + /// Recipient account + pub to: AccountId, + /// Transfer count (unique per recipient) + pub transfer_count: u64, + /// Asset ID (0 for native token) + pub asset_id: AssetId, + /// Transfer amount + pub amount: Balance, +} + +/// Merkle proof for a leaf in the 4-ary tree. +#[derive(codec::Encode, codec::Decode, Clone, PartialEq, Eq, scale_info::TypeInfo, Debug)] +pub struct ZkMerkleProof { + /// Index of the leaf + pub leaf_index: u64, + /// Sibling hashes at each level (3 siblings per level for 4-ary tree) + pub siblings: alloc::vec::Vec<[Hash256; 3]>, + /// Position within siblings at each level (0-3) + pub path_indices: alloc::vec::Vec, +} + +#[frame_support::pallet] +pub mod pallet { + use super::*; + use frame_support::pallet_prelude::*; + use frame_system::pallet_prelude::*; + + #[pallet::pallet] + pub struct Pallet(_); + + #[pallet::config] + pub trait Config: frame_system::Config>> { + /// Asset ID type. + type AssetId: Parameter + Member + Copy + Default + MaxEncodedLen + Into; + + /// Balance type. + type Balance: Parameter + Member + Copy + Default + MaxEncodedLen + Into; + } + + /// Account ID type alias for convenience. + pub type AccountIdOf = ::AccountId; + + /// Leaf data stored by index. + #[pallet::storage] + #[pallet::getter(fn leaf)] + pub type Leaves = + StorageMap<_, Identity, u64, ZkLeaf, T::AssetId, T::Balance>, OptionQuery>; + + /// Internal tree nodes: (level, index) -> hash. + /// Level 0 is unused (leaves are hashed on-demand). + /// Level 1+ contains internal node hashes. + #[pallet::storage] + #[pallet::getter(fn node)] + pub type Nodes = StorageMap<_, Identity, (u8, u64), Hash256, OptionQuery>; + + /// Number of leaves in the tree. + #[pallet::storage] + #[pallet::getter(fn leaf_count)] + pub type LeafCount = StorageValue<_, u64, ValueQuery>; + + /// Current depth of the tree (0 = empty, 1 = up to 4 leaves, etc.). + #[pallet::storage] + #[pallet::getter(fn depth)] + pub type Depth = StorageValue<_, u8, ValueQuery>; + + /// Current root hash of the tree. + #[pallet::storage] + #[pallet::getter(fn root)] + pub type Root = StorageValue<_, Hash256, ValueQuery>; + + #[pallet::event] + #[pallet::generate_deposit(pub(super) fn deposit_event)] + pub enum Event { + /// A new leaf was inserted into the tree. + LeafInserted { index: u64, leaf_hash: Hash256, new_root: Hash256 }, + /// Tree depth increased. + TreeGrew { new_depth: u8 }, + } + + #[pallet::error] + pub enum Error { + /// Tree has reached maximum depth. + MaxDepthReached, + /// Leaf index out of bounds. + LeafIndexOutOfBounds, + /// Leaf not found. + LeafNotFound, + } + + #[pallet::hooks] + impl Hooks> for Pallet { + fn on_finalize(_n: BlockNumberFor) { + // Add ZkRoot to digest + let root = Root::::get(); + let item = sp_runtime::generic::DigestItem::Other(root.to_vec()); + >::deposit_log(item); + } + } + + impl Pallet + where + AccountIdOf: AsRef<[u8]>, + { + /// Insert a new leaf into the tree. + /// + /// Returns the leaf index and new root hash. + pub fn insert_leaf( + to: AccountIdOf, + transfer_count: u64, + asset_id: T::AssetId, + amount: T::Balance, + ) -> Result<(u64, Hash256), Error> { + let leaf = ZkLeaf { to, transfer_count, asset_id, amount }; + let leaf_index = LeafCount::::get(); + + // Check if we need to grow the tree + let current_depth = Depth::::get(); + let capacity = tree::capacity_at_depth(current_depth); + + if leaf_index >= capacity { + // Need to grow the tree + let new_depth = current_depth.checked_add(1).ok_or(Error::::MaxDepthReached)?; + ensure!(new_depth <= MAX_TREE_DEPTH, Error::::MaxDepthReached); + + tree::grow_tree::(current_depth, new_depth)?; + Depth::::put(new_depth); + + Self::deposit_event(Event::TreeGrew { new_depth }); + } + + // Store the leaf + Leaves::::insert(leaf_index, leaf.clone()); + LeafCount::::put(leaf_index + 1); + + // Compute leaf hash and update tree + let leaf_hash = tree::hash_leaf::(&leaf); + let new_root = tree::update_path::(leaf_index, leaf_hash)?; + + Root::::put(new_root); + + Self::deposit_event(Event::LeafInserted { index: leaf_index, leaf_hash, new_root }); + + Ok((leaf_index, new_root)) + } + + /// Get a Merkle proof for a leaf at the given index. + pub fn get_merkle_proof(leaf_index: u64) -> Result> { + let leaf_count = LeafCount::::get(); + ensure!(leaf_index < leaf_count, Error::::LeafIndexOutOfBounds); + + let depth = Depth::::get(); + tree::generate_proof::(leaf_index, depth) + } + + /// Verify a Merkle proof against the current root. + pub fn verify_proof( + leaf: &ZkLeaf, T::AssetId, T::Balance>, + proof: &ZkMerkleProof, + ) -> bool { + let root = Root::::get(); + tree::verify_proof::(leaf, proof, root) + } + } +} + +// ============================================================================ +// Runtime API +// ============================================================================ + +/// RPC-friendly Merkle proof structure (no generics). +/// Uses raw bytes for the leaf data to avoid generic type issues in RPC. +#[derive(codec::Encode, codec::Decode, Clone, PartialEq, Eq, scale_info::TypeInfo, Debug)] +#[cfg_attr(feature = "std", derive(serde::Serialize, serde::Deserialize))] +pub struct ZkMerkleProofRpc { + /// Index of the leaf + pub leaf_index: u64, + /// The leaf data (encoded ZkLeaf) + pub leaf_data: Vec, + /// Leaf hash + pub leaf_hash: Hash256, + /// Sibling hashes at each level (3 siblings per level for 4-ary tree) + pub siblings: Vec<[Hash256; 3]>, + /// Position within siblings at each level (0-3) + pub path_indices: Vec, + /// Current tree root + pub root: Hash256, + /// Current tree depth + pub depth: u8, +} + +sp_api::decl_runtime_apis! { + /// Runtime API for the ZK Trie pallet. + /// + /// Provides methods to query the ZK Merkle tree state and generate proofs. + pub trait ZkTrieApi { + /// Get the current root hash of the ZK tree. + fn get_root() -> Hash256; + + /// Get the current number of leaves in the tree. + fn get_leaf_count() -> u64; + + /// Get the current depth of the tree. + fn get_depth() -> u8; + + /// Get a Merkle proof for a leaf at the given index. + /// + /// Returns `None` if the leaf index is out of bounds. + fn get_merkle_proof(leaf_index: u64) -> Option; + } +} diff --git a/pallets/zk-trie/src/tests.rs b/pallets/zk-trie/src/tests.rs new file mode 100644 index 00000000..cacf58da --- /dev/null +++ b/pallets/zk-trie/src/tests.rs @@ -0,0 +1,488 @@ +//! Tests for the ZK Trie pallet. + +use crate::{self as pallet_zk_trie, tree, *}; +use frame_support::{ + construct_runtime, parameter_types, + traits::{ConstU32, Everything, Hooks}, +}; +use sp_core::{crypto::AccountId32, H256}; +use sp_runtime::{ + traits::{BlakeTwo256, IdentityLookup}, + BuildStorage, +}; + +construct_runtime!( + pub enum Test { + System: frame_system, + ZkTrie: pallet_zk_trie, + } +); + +pub type AccountId = AccountId32; +pub type Block = frame_system::mocking::MockBlock; + +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 = (); + type OnNewAccount = (); + type OnKilledAccount = (); + type SystemWeightInfo = (); + type SS58Prefix = (); + type OnSetCode = (); + type MaxConsumers = ConstU32<16>; + type SingleBlockMigrations = (); + type MultiBlockMigrator = (); + type PreInherents = (); + type PostInherents = (); + type PostTransactions = (); + type ExtensionsWeightInfo = (); +} + +impl Config for Test { + type AssetId = u32; + type Balance = u128; +} + +fn new_test_ext() -> sp_io::TestExternalities { + let t = frame_system::GenesisConfig::::default().build_storage().unwrap(); + let mut ext = sp_io::TestExternalities::new(t); + ext.execute_with(|| System::set_block_number(1)); + ext +} + +fn make_account(seed: u8) -> AccountId { + AccountId::new([seed; 32]) +} + +#[test] +fn test_capacity_at_depth() { + assert_eq!(tree::capacity_at_depth(0), 0); + assert_eq!(tree::capacity_at_depth(1), 4); + assert_eq!(tree::capacity_at_depth(2), 16); + assert_eq!(tree::capacity_at_depth(3), 64); + assert_eq!(tree::capacity_at_depth(4), 256); +} + +#[test] +fn test_hash_node() { + let children = [[1u8; 32], [2u8; 32], [3u8; 32], [4u8; 32]]; + let hash = tree::hash_node(&children); + assert_ne!(hash, [0u8; 32]); + + // Same input should give same output + let hash2 = tree::hash_node(&children); + assert_eq!(hash, hash2); + + // Different input should give different output + let children2 = [[1u8; 32], [2u8; 32], [3u8; 32], [5u8; 32]]; + let hash3 = tree::hash_node(&children2); + assert_ne!(hash, hash3); +} + +#[test] +fn insert_first_leaf_works() { + new_test_ext().execute_with(|| { + let to = make_account(1); + let (index, root) = ZkTrie::insert_leaf(to.clone(), 0, 0u32, 100u128).unwrap(); + + assert_eq!(index, 0); + assert_ne!(root, [0u8; 32]); + assert_eq!(ZkTrie::leaf_count(), 1); + assert_eq!(ZkTrie::depth(), 1); + assert_eq!(ZkTrie::root(), root); + + // Check leaf was stored + let leaf = ZkTrie::leaf(0).unwrap(); + assert_eq!(leaf.to, to); + assert_eq!(leaf.transfer_count, 0); + assert_eq!(leaf.asset_id, 0); + assert_eq!(leaf.amount, 100); + }); +} + +#[test] +fn insert_multiple_leaves_works() { + new_test_ext().execute_with(|| { + let mut roots = Vec::new(); + + for i in 0..4 { + let to = make_account(i + 1); + let (index, root) = + ZkTrie::insert_leaf(to, i as u64, 0u32, (i + 1) as u128 * 100).unwrap(); + assert_eq!(index, i as u64); + roots.push(root); + } + + assert_eq!(ZkTrie::leaf_count(), 4); + assert_eq!(ZkTrie::depth(), 1); // 4 leaves fit in depth 1 + + // Each insert should change the root + for i in 1..roots.len() { + assert_ne!(roots[i], roots[i - 1]); + } + }); +} + +#[test] +fn tree_grows_at_capacity() { + new_test_ext().execute_with(|| { + // Fill depth 1 (4 leaves) + for i in 0..4 { + let to = make_account(i + 1); + ZkTrie::insert_leaf(to, i as u64, 0u32, 100u128).unwrap(); + } + assert_eq!(ZkTrie::depth(), 1); + + // 5th leaf should trigger growth to depth 2 + let to = make_account(5); + ZkTrie::insert_leaf(to, 4, 0u32, 100u128).unwrap(); + + assert_eq!(ZkTrie::leaf_count(), 5); + assert_eq!(ZkTrie::depth(), 2); + }); +} + +#[test] +fn tree_grows_multiple_times() { + new_test_ext().execute_with(|| { + // Insert 20 leaves (need depth 3 to fit: 4^3 = 64) + for i in 0..20 { + let to = make_account((i % 255) as u8 + 1); + ZkTrie::insert_leaf(to, i as u64, 0u32, 100u128).unwrap(); + } + + assert_eq!(ZkTrie::leaf_count(), 20); + assert_eq!(ZkTrie::depth(), 3); // 4^2 = 16 < 20 <= 64 = 4^3 + }); +} + +#[test] +fn merkle_proof_works() { + new_test_ext().execute_with(|| { + // Insert some leaves + for i in 0..5 { + let to = make_account(i + 1); + ZkTrie::insert_leaf(to, i as u64, 0u32, (i + 1) as u128 * 100).unwrap(); + } + + // Get proof for leaf 0 + let proof = ZkTrie::get_merkle_proof(0).unwrap(); + assert_eq!(proof.leaf_index, 0); + assert_eq!(proof.siblings.len(), 2); // depth 2 + assert_eq!(proof.path_indices.len(), 2); + + // Verify the proof + let leaf = ZkTrie::leaf(0).unwrap(); + assert!(ZkTrie::verify_proof(&leaf, &proof)); + }); +} + +#[test] +fn merkle_proof_all_leaves() { + new_test_ext().execute_with(|| { + // Insert leaves + for i in 0..10 { + let to = make_account(i + 1); + ZkTrie::insert_leaf(to, i as u64, i as u32, (i + 1) as u128 * 100).unwrap(); + } + + // Verify proof for each leaf + for i in 0..10 { + let proof = ZkTrie::get_merkle_proof(i).unwrap(); + let leaf = ZkTrie::leaf(i).unwrap(); + assert!(ZkTrie::verify_proof(&leaf, &proof), "Proof failed for leaf {}", i); + } + }); +} + +#[test] +fn invalid_proof_fails() { + new_test_ext().execute_with(|| { + // Insert leaves + for i in 0..5 { + let to = make_account(i + 1); + ZkTrie::insert_leaf(to, i as u64, 0u32, (i + 1) as u128 * 100).unwrap(); + } + + // Get proof for leaf 0 + let proof = ZkTrie::get_merkle_proof(0).unwrap(); + + // Try to verify with wrong leaf data + let wrong_leaf = + ZkLeaf { to: make_account(99), transfer_count: 0, asset_id: 0u32, amount: 100u128 }; + assert!(!ZkTrie::verify_proof(&wrong_leaf, &proof)); + }); +} + +#[test] +fn proof_for_nonexistent_leaf_fails() { + new_test_ext().execute_with(|| { + ZkTrie::insert_leaf(make_account(1), 0, 0u32, 100u128).unwrap(); + + // Try to get proof for leaf index 5 (doesn't exist) + let result = ZkTrie::get_merkle_proof(5); + assert!(result.is_err()); + }); +} + +#[test] +fn root_changes_on_insert() { + new_test_ext().execute_with(|| { + let (_, root1) = ZkTrie::insert_leaf(make_account(1), 0, 0u32, 100u128).unwrap(); + let (_, root2) = ZkTrie::insert_leaf(make_account(2), 1, 0u32, 200u128).unwrap(); + + assert_ne!(root1, root2); + assert_eq!(ZkTrie::root(), root2); + }); +} + +#[test] +fn different_amounts_give_different_hashes() { + new_test_ext().execute_with(|| { + let (_, root1) = ZkTrie::insert_leaf(make_account(1), 0, 0u32, 100u128).unwrap(); + + // Reset and insert with different amount + crate::Leaves::::remove(0); + crate::LeafCount::::put(0); + crate::Depth::::put(0); + crate::Root::::put([0u8; 32]); + + let (_, root2) = ZkTrie::insert_leaf(make_account(1), 0, 0u32, 200u128).unwrap(); + + assert_ne!(root1, root2); + }); +} + +#[test] +fn digest_log_contains_root() { + new_test_ext().execute_with(|| { + ZkTrie::insert_leaf(make_account(1), 0, 0u32, 100u128).unwrap(); + let expected_root = ZkTrie::root(); + + // Trigger on_finalize + ZkTrie::on_finalize(1); + + // Check digest + let digest = System::digest(); + assert!(!digest.logs.is_empty()); + + // Find the ZkRoot log + let found = digest.logs.iter().any(|item| { + if let sp_runtime::generic::DigestItem::Other(data) = item { + data.as_slice() == expected_root + } else { + false + } + }); + assert!(found, "ZkRoot not found in digest"); + }); +} + +/// Helper to extract ZkRoot from digest +fn extract_zk_root_from_digest() -> Option { + let digest = System::digest(); + for item in digest.logs.iter() { + if let sp_runtime::generic::DigestItem::Other(data) = item { + if data.len() == 32 { + let mut root = [0u8; 32]; + root.copy_from_slice(data); + return Some(root); + } + } + } + None +} + +/// Simulate a transfer by inserting a leaf into the ZK trie. +/// In production, pallet-wormhole would call this. +fn simulate_transfer( + to: AccountId, + transfer_count: u64, + asset_id: u32, + amount: u128, +) -> (u64, Hash256) { + ZkTrie::insert_leaf(to, transfer_count, asset_id, amount).expect("insert_leaf should succeed") +} + +#[test] +fn integration_many_transfers_updates_root_in_digest() { + new_test_ext().execute_with(|| { + let alice = make_account(1); + let bob = make_account(2); + let charlie = make_account(3); + + // === Insert many transfers and verify tree grows correctly === + + // First 3 transfers + let (idx0, _) = simulate_transfer(alice.clone(), 0, 0, 1000); + let (idx1, _) = simulate_transfer(bob.clone(), 0, 0, 2000); + let (idx2, _) = simulate_transfer(charlie.clone(), 0, 0, 3000); + + assert_eq!(idx0, 0); + assert_eq!(idx1, 1); + assert_eq!(idx2, 2); + assert_eq!(ZkTrie::leaf_count(), 3); + + let root_after_3 = ZkTrie::root(); + + // Verify proofs for first 3 leaves + for idx in 0..3 { + let proof = ZkTrie::get_merkle_proof(idx).expect("proof should exist"); + let leaf = ZkTrie::leaf(idx).expect("leaf should exist"); + assert!(ZkTrie::verify_proof(&leaf, &proof), "proof {} should verify", idx); + } + + // 5 more transfers - tree will grow from depth 1 (capacity 4) to depth 2 (capacity 16) + simulate_transfer(alice.clone(), 1, 0, 500); + simulate_transfer(bob.clone(), 1, 0, 600); + simulate_transfer(charlie.clone(), 1, 0, 700); + simulate_transfer(alice.clone(), 2, 1, 100); // Different asset + simulate_transfer(bob.clone(), 2, 1, 200); // Different asset + + assert_eq!(ZkTrie::leaf_count(), 8); + assert!(ZkTrie::depth() >= 2, "tree should have grown to depth 2"); + + let root_after_8 = ZkTrie::root(); + assert_ne!(root_after_3, root_after_8, "root should change after new transfers"); + + // Verify proofs for all 8 leaves + for idx in 0..8 { + let proof = ZkTrie::get_merkle_proof(idx).expect("proof should exist"); + let leaf = ZkTrie::leaf(idx).expect("leaf should exist"); + assert!(ZkTrie::verify_proof(&leaf, &proof), "proof {} should verify", idx); + } + + // Add 10 more transfers (total 18, tree needs depth 3 for capacity 64) + for i in 0..10u64 { + let recipient = make_account((i % 5) as u8 + 10); + simulate_transfer(recipient, i, 0, (i as u128 + 1) * 1000); + } + + assert_eq!(ZkTrie::leaf_count(), 18); + + let root_after_18 = ZkTrie::root(); + assert_ne!(root_after_8, root_after_18, "root should change after more transfers"); + + // Verify ALL proofs still work after tree growth + for idx in 0..18 { + let proof = ZkTrie::get_merkle_proof(idx).expect("proof should exist"); + let leaf = ZkTrie::leaf(idx).expect("leaf should exist"); + assert!( + ZkTrie::verify_proof(&leaf, &proof), + "proof {} should verify after growth", + idx + ); + } + + // === Verify specific leaf data === + let leaf_0 = ZkTrie::leaf(0).expect("leaf 0 should exist"); + assert_eq!(leaf_0.to, alice); + assert_eq!(leaf_0.transfer_count, 0); + assert_eq!(leaf_0.asset_id, 0); + assert_eq!(leaf_0.amount, 1000); + + let leaf_6 = ZkTrie::leaf(6).expect("leaf 6 should exist"); + assert_eq!(leaf_6.to, alice); + assert_eq!(leaf_6.transfer_count, 2); + assert_eq!(leaf_6.asset_id, 1); // Different asset + assert_eq!(leaf_6.amount, 100); + + // === Finally verify root appears in digest on finalize === + ZkTrie::on_finalize(1); + let digest_root = extract_zk_root_from_digest().expect("ZkRoot should be in digest"); + assert_eq!(digest_root, root_after_18, "digest should contain current root"); + }); +} + +#[test] +fn integration_empty_tree_has_zero_root_in_digest() { + new_test_ext().execute_with(|| { + // No transfers - tree is empty + assert_eq!(ZkTrie::leaf_count(), 0); + assert_eq!(ZkTrie::depth(), 0); + + let empty_root = ZkTrie::root(); + assert_eq!(empty_root, [0u8; 32], "empty tree should have zero root"); + + // Finalize and check digest + ZkTrie::on_finalize(1); + let digest_root = extract_zk_root_from_digest().expect("ZkRoot should be in digest"); + assert_eq!(digest_root, empty_root); + }); +} + +#[test] +fn integration_root_changes_only_on_insert() { + new_test_ext().execute_with(|| { + let alice = make_account(1); + + // Insert a leaf + simulate_transfer(alice.clone(), 0, 0, 1000); + let root_after_insert = ZkTrie::root(); + + // Finalize - root should not change + ZkTrie::on_finalize(1); + assert_eq!(ZkTrie::root(), root_after_insert, "finalize should not change root"); + + // Another finalize - still same root + ZkTrie::on_finalize(2); + assert_eq!(ZkTrie::root(), root_after_insert, "second finalize should not change root"); + + // Insert another leaf - NOW root should change + simulate_transfer(alice.clone(), 1, 0, 2000); + assert_ne!(ZkTrie::root(), root_after_insert, "insert should change root"); + }); +} + +#[test] +fn integration_proof_contains_correct_path_indices() { + new_test_ext().execute_with(|| { + // Insert 5 leaves to force depth 2 + for i in 0..5u64 { + let account = make_account(i as u8); + simulate_transfer(account, 0, 0, (i as u128 + 1) * 100); + } + + assert_eq!(ZkTrie::depth(), 2); + + // Check path indices for each leaf + // In a 4-ary tree at depth 2: + // Leaf 0: path [0, 0] (first child at each level) + // Leaf 1: path [1, 0] + // Leaf 2: path [2, 0] + // Leaf 3: path [3, 0] + // Leaf 4: path [0, 1] (first child of second node) + + let proof_0 = ZkTrie::get_merkle_proof(0).unwrap(); + assert_eq!(proof_0.path_indices, vec![0, 0]); + + let proof_1 = ZkTrie::get_merkle_proof(1).unwrap(); + assert_eq!(proof_1.path_indices, vec![1, 0]); + + let proof_3 = ZkTrie::get_merkle_proof(3).unwrap(); + assert_eq!(proof_3.path_indices, vec![3, 0]); + + let proof_4 = ZkTrie::get_merkle_proof(4).unwrap(); + assert_eq!(proof_4.path_indices, vec![0, 1]); + }); +} diff --git a/pallets/zk-trie/src/tree.rs b/pallets/zk-trie/src/tree.rs new file mode 100644 index 00000000..530eb067 --- /dev/null +++ b/pallets/zk-trie/src/tree.rs @@ -0,0 +1,311 @@ +//! 4-ary Poseidon Merkle tree implementation. +//! +//! This module provides the core tree operations: +//! - Leaf hashing (injective, 4 bytes/felt) +//! - Node hashing (non-injective, 8 bytes/felt) +//! - Path updates on insert +//! - Proof generation and verification +//! - Tree growth when capacity is exceeded + +use crate::{ + pallet::{AccountIdOf, Config}, + Error, Hash256, ZkLeaf, ZkMerkleProof, ARITY, +}; +use alloc::vec::Vec; + +/// Compute the capacity (max leaves) at a given depth. +/// Depth 0 = 0 leaves (empty tree) +/// Depth 1 = 4 leaves +/// Depth 2 = 16 leaves +/// etc. +pub fn capacity_at_depth(depth: u8) -> u64 { + if depth == 0 { + 0 + } else { + (ARITY as u64).saturating_pow(depth as u32) + } +} + +/// Hash a leaf using injective Poseidon (4 bytes/felt). +/// +/// This ensures collision resistance for user-controlled data. +pub fn hash_leaf(leaf: &ZkLeaf, T::AssetId, T::Balance>) -> Hash256 +where + AccountIdOf: AsRef<[u8]>, +{ + // Encode leaf data to bytes + let mut data = Vec::new(); + + // to: account bytes (should be 32 bytes) + data.extend_from_slice(leaf.to.as_ref()); + + // transfer_count: 8 bytes LE + data.extend_from_slice(&leaf.transfer_count.to_le_bytes()); + + // asset_id: as u128, 16 bytes LE + let asset_id_u128: u128 = leaf.asset_id.into(); + data.extend_from_slice(&asset_id_u128.to_le_bytes()); + + // amount: as u128, 16 bytes LE + let amount_u128: u128 = leaf.amount.into(); + data.extend_from_slice(&amount_u128.to_le_bytes()); + + // Use injective hash (4 bytes/felt) + qp_poseidon_core::hash_bytes(&data) +} + +/// Hash 4 child hashes into a parent node hash. +/// +/// Uses non-injective Poseidon (8 bytes/felt) since internal nodes +/// only contain fixed-size hash outputs, not user-controlled data. +pub fn hash_node(children: &[Hash256; ARITY]) -> Hash256 { + // Concatenate all 4 child hashes (128 bytes total) + let mut data = Vec::with_capacity(32 * ARITY); + for child in children { + data.extend_from_slice(child); + } + + // Convert to felts using compact encoding (8 bytes/felt) + // 128 bytes -> 16 felts + let felts = qp_poseidon_core::serialization::bytes_to_felts_compact(&data); + + // Hash the felts + qp_poseidon_core::hash_to_bytes(&felts) +} + +/// The default hash for an empty subtree. +pub fn empty_hash() -> Hash256 { + [0u8; 32] +} + +/// Get the hash of a leaf by index, or empty hash if not present. +fn get_leaf_hash(index: u64) -> Hash256 +where + AccountIdOf: AsRef<[u8]>, +{ + match crate::Leaves::::get(index) { + Some(leaf) => hash_leaf::(&leaf), + None => empty_hash(), + } +} + +/// Get the hash of a node at (level, index), or empty hash if not present. +fn get_node_hash(level: u8, index: u64) -> Hash256 { + crate::Nodes::::get((level, index)).unwrap_or_else(empty_hash) +} + +/// Update the path from a leaf to the root after insertion. +/// +/// Returns the new root hash. +pub fn update_path(leaf_index: u64, leaf_hash: Hash256) -> Result> +where + AccountIdOf: AsRef<[u8]>, +{ + let depth = crate::Depth::::get(); + + if depth == 0 { + // Special case: first leaf in empty tree - need to initialize + crate::Depth::::put(1); + return Ok(leaf_hash); + } + + // Start from leaf level and work up to root + let mut current_index = leaf_index; + let mut current_hash = leaf_hash; + + for level in 1..=depth { + // Find which group of 4 this node belongs to + let parent_index = current_index / (ARITY as u64); + let _position_in_parent = (current_index % (ARITY as u64)) as usize; + + // Get all 4 children for this parent + let mut children = [empty_hash(); ARITY]; + + if level == 1 { + // Children are leaves + let base_leaf_index = parent_index * (ARITY as u64); + for i in 0..ARITY { + let child_leaf_index = base_leaf_index + (i as u64); + if child_leaf_index == leaf_index { + children[i] = current_hash; + } else { + children[i] = get_leaf_hash::(child_leaf_index); + } + } + } else { + // Children are internal nodes + let base_child_index = parent_index * (ARITY as u64); + for i in 0..ARITY { + let child_index = base_child_index + (i as u64); + if child_index == current_index { + children[i] = current_hash; + } else { + children[i] = get_node_hash::(level - 1, child_index); + } + } + } + + // Compute parent hash + current_hash = hash_node(&children); + + // Store the node (except at root level, which is stored separately) + if level < depth { + crate::Nodes::::insert((level, parent_index), current_hash); + } + + current_index = parent_index; + } + + Ok(current_hash) +} + +/// Grow the tree by one level. +/// +/// The current root becomes one of the children of the new root. +pub fn grow_tree(old_depth: u8, _new_depth: u8) -> Result<(), Error> { + if old_depth == 0 { + // Tree was empty, just set depth + return Ok(()); + } + + // The old root hash becomes child[0] of the new root + let old_root = crate::Root::::get(); + + // Store the old root as a node at the old depth level, index 0 + crate::Nodes::::insert((old_depth, 0), old_root); + + // The new root will be computed when the next leaf triggers update_path + // For now, compute it with empty siblings + let mut children = [empty_hash(); ARITY]; + children[0] = old_root; + let new_root = hash_node(&children); + + crate::Root::::put(new_root); + + Ok(()) +} + +/// Generate a Merkle proof for a leaf at the given index. +pub fn generate_proof(leaf_index: u64, depth: u8) -> Result> +where + AccountIdOf: AsRef<[u8]>, +{ + if depth == 0 { + return Err(Error::::LeafNotFound); + } + + let mut siblings = Vec::with_capacity(depth as usize); + let mut path_indices = Vec::with_capacity(depth as usize); + + let mut current_index = leaf_index; + + for level in 1..=depth { + let parent_index = current_index / (ARITY as u64); + let position_in_parent = (current_index % (ARITY as u64)) as u8; + + path_indices.push(position_in_parent); + + // Get sibling hashes (the other 3 children) + let mut level_siblings = [empty_hash(); 3]; + let mut sibling_idx = 0; + + let base_index = parent_index * (ARITY as u64); + for i in 0..ARITY { + let child_index = base_index + (i as u64); + if child_index == current_index { + continue; // Skip self + } + + let hash = if level == 1 { + get_leaf_hash::(child_index) + } else { + get_node_hash::(level - 1, child_index) + }; + + level_siblings[sibling_idx] = hash; + sibling_idx += 1; + } + + siblings.push(level_siblings); + current_index = parent_index; + } + + Ok(ZkMerkleProof { leaf_index, siblings, path_indices }) +} + +/// Verify a Merkle proof against a given root. +pub fn verify_proof( + leaf: &ZkLeaf, T::AssetId, T::Balance>, + proof: &ZkMerkleProof, + expected_root: Hash256, +) -> bool +where + AccountIdOf: AsRef<[u8]>, +{ + if proof.siblings.len() != proof.path_indices.len() { + return false; + } + + let mut current_hash = hash_leaf::(leaf); + let mut _current_index = proof.leaf_index; + + for (level_siblings, &position) in proof.siblings.iter().zip(proof.path_indices.iter()) { + if position >= ARITY as u8 { + return false; + } + + // Reconstruct the 4 children from position and siblings + let mut children = [empty_hash(); ARITY]; + let mut sibling_idx = 0; + + for i in 0..ARITY { + if i == position as usize { + children[i] = current_hash; + } else { + children[i] = level_siblings[sibling_idx]; + sibling_idx += 1; + } + } + + current_hash = hash_node(&children); + _current_index /= ARITY as u64; + } + + current_hash == expected_root +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_capacity_at_depth() { + assert_eq!(capacity_at_depth(0), 0); + assert_eq!(capacity_at_depth(1), 4); + assert_eq!(capacity_at_depth(2), 16); + assert_eq!(capacity_at_depth(3), 64); + assert_eq!(capacity_at_depth(4), 256); + } + + #[test] + fn test_hash_node() { + let children = [[1u8; 32], [2u8; 32], [3u8; 32], [4u8; 32]]; + let hash = hash_node(&children); + assert_ne!(hash, [0u8; 32]); + + // Same input should give same output + let hash2 = hash_node(&children); + assert_eq!(hash, hash2); + + // Different input should give different output + let children2 = [[1u8; 32], [2u8; 32], [3u8; 32], [5u8; 32]]; + let hash3 = hash_node(&children2); + assert_ne!(hash, hash3); + } + + #[test] + fn test_empty_hash() { + let h = empty_hash(); + assert_eq!(h, [0u8; 32]); + } +} diff --git a/runtime/Cargo.toml b/runtime/Cargo.toml index 76dbccad..3240f817 100644 --- a/runtime/Cargo.toml +++ b/runtime/Cargo.toml @@ -46,6 +46,7 @@ pallet-transaction-payment-rpc-runtime-api.workspace = true pallet-treasury.workspace = true pallet-utility.workspace = true pallet-wormhole.workspace = true +pallet-zk-trie.workspace = true primitive-types.workspace = true qp-dilithium-crypto.workspace = true qp-header = { workspace = true, features = ["serde"] } @@ -115,6 +116,7 @@ std = [ "pallet-treasury/std", "pallet-utility/std", "pallet-wormhole/std", + "pallet-zk-trie/std", "primitive-types/std", "qp-dilithium-crypto/full_crypto", "qp-dilithium-crypto/std", diff --git a/runtime/src/apis.rs b/runtime/src/apis.rs index 7a0292b4..d75636b9 100644 --- a/runtime/src/apis.rs +++ b/runtime/src/apis.rs @@ -43,7 +43,7 @@ use sp_version::RuntimeVersion; // Local module imports use super::{ AccountId, Balance, Block, Executive, InherentDataExt, Nonce, Runtime, RuntimeCall, - RuntimeGenesisConfig, System, TransactionPayment, VERSION, + RuntimeGenesisConfig, System, TransactionPayment, ZkTrie, VERSION, }; #[cfg(feature = "try-runtime")] use super::{Header, UncheckedExtrinsic}; @@ -172,6 +172,43 @@ impl_runtime_apis! { } } + impl pallet_zk_trie::ZkTrieApi for Runtime { + fn get_root() -> pallet_zk_trie::Hash256 { + ZkTrie::root() + } + + fn get_leaf_count() -> u64 { + ZkTrie::leaf_count() + } + + fn get_depth() -> u8 { + ZkTrie::depth() + } + + fn get_merkle_proof(leaf_index: u64) -> Option { + use codec::Encode; + + // Get the leaf + let leaf = ZkTrie::leaf(leaf_index)?; + + // Generate the proof + let proof = ZkTrie::get_merkle_proof(leaf_index).ok()?; + + // Compute leaf hash + let leaf_hash = pallet_zk_trie::tree::hash_leaf::(&leaf); + + Some(pallet_zk_trie::ZkMerkleProofRpc { + leaf_index, + leaf_data: leaf.encode(), + leaf_hash, + siblings: proof.siblings, + path_indices: proof.path_indices, + root: ZkTrie::root(), + depth: ZkTrie::depth(), + }) + } + } + impl frame_system_rpc_runtime_api::AccountNonceApi for Runtime { fn account_nonce(account: AccountId) -> Nonce { System::account_nonce(account) diff --git a/runtime/src/configs/mod.rs b/runtime/src/configs/mod.rs index 462ce8f7..4bdc7ad1 100644 --- a/runtime/src/configs/mod.rs +++ b/runtime/src/configs/mod.rs @@ -701,3 +701,8 @@ impl pallet_wormhole::Config for Runtime { type WormholeAccountId = AccountId32; type WeightInfo = pallet_wormhole::weights::SubstrateWeight; } + +impl pallet_zk_trie::Config for Runtime { + type AssetId = AssetId; + type Balance = Balance; +} diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs index 2e8b2756..b0983e75 100644 --- a/runtime/src/lib.rs +++ b/runtime/src/lib.rs @@ -255,4 +255,7 @@ mod runtime { #[runtime::pallet_index(20)] pub type Wormhole = pallet_wormhole; + + #[runtime::pallet_index(21)] + pub type ZkTrie = pallet_zk_trie; } From 0359b926646848a57095e7451cebacdf786a0289 Mon Sep 17 00:00:00 2001 From: illuzen Date: Sat, 11 Apr 2026 21:38:29 +0800 Subject: [PATCH 02/19] integrate with wormhole pallet --- Cargo.lock | 1 + pallets/wormhole/Cargo.toml | 2 + pallets/wormhole/src/lib.rs | 82 ++++++++++++------------------ pallets/wormhole/src/mock.rs | 1 + pallets/wormhole/src/tests.rs | 95 ++++------------------------------- pallets/zk-trie/src/lib.rs | 43 ++++++++++++++++ runtime/src/configs/mod.rs | 5 +- 7 files changed, 94 insertions(+), 135 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 14e770dd..756cc5f6 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -6926,6 +6926,7 @@ dependencies = [ "log", "pallet-assets", "pallet-balances", + "pallet-zk-trie", "parity-scale-codec", "qp-dilithium-crypto", "qp-header", diff --git a/pallets/wormhole/Cargo.toml b/pallets/wormhole/Cargo.toml index d110d969..94840a2c 100644 --- a/pallets/wormhole/Cargo.toml +++ b/pallets/wormhole/Cargo.toml @@ -16,6 +16,7 @@ hex = { workspace = true, optional = true, features = ["alloc"] } lazy_static.workspace = true log.workspace = true pallet-balances.workspace = true +pallet-zk-trie.workspace = true qp-header = { workspace = true, features = ["serde"] } qp-poseidon.workspace = true qp-wormhole.workspace = true @@ -65,6 +66,7 @@ std = [ "lazy_static/spin_no_std", "log/std", "pallet-balances/std", + "pallet-zk-trie/std", "qp-header/std", "qp-poseidon/std", "qp-wormhole-verifier/std", diff --git a/pallets/wormhole/src/lib.rs b/pallets/wormhole/src/lib.rs index d44b6531..414c7994 100644 --- a/pallets/wormhole/src/lib.rs +++ b/pallets/wormhole/src/lib.rs @@ -4,7 +4,7 @@ extern crate alloc; use lazy_static::lazy_static; pub use pallet::*; -pub use qp_poseidon::{PoseidonHasher as PoseidonCore, ToFelts}; +pub use qp_poseidon::ToFelts; use qp_wormhole_verifier::WormholeVerifier; #[cfg(feature = "runtime-benchmarks")] @@ -37,7 +37,7 @@ pub const SCALE_DOWN_FACTOR: u128 = 10_000_000_000; #[frame_support::pallet] pub mod pallet { - use crate::{PoseidonCore, ToFelts, WeightInfo}; + use crate::{ToFelts, WeightInfo}; use alloc::vec::Vec; use codec::{Decode, Encode}; use frame_support::{ @@ -50,6 +50,7 @@ pub mod pallet { }, }; use frame_system::pallet_prelude::*; + use pallet_zk_trie::ZkTrieRecorder; use qp_wormhole_verifier::{ parse_aggregated_public_inputs, AggregatedPublicCircuitInputs, ProofWithPublicInputs, C, D, F, @@ -65,25 +66,6 @@ pub mod pallet { pub type BalanceOf = ::NativeBalance; pub type AssetBalanceOf = ::AssetBalance; - /// Key for TransferProof storage - uniquely identifies a transfer. - /// Uses (to, transfer_count) since transfer_count is atomic per recipient. - /// This is hashed with Blake2_256 to form the storage key suffix. - pub type TransferProofKey = (::WormholeAccountId, ::TransferCount); - - /// Full transfer data including amount - used to compute the leaf_inputs_hash via Poseidon2. - /// This is what the ZK circuit verifies. - pub type TransferProofData = ( - ::AssetId, - ::TransferCount, - ::WormholeAccountId, - ::WormholeAccountId, - BalanceOf, - ); - - /// The leaf_inputs_hash stored as the value in TransferProof storage. - /// This is the Poseidon2 hash of TransferProofData, verified by the ZK circuit. - pub type LeafInputsHash = [u8; 32]; - #[pallet::pallet] pub struct Pallet(_); @@ -216,6 +198,14 @@ pub mod pallet { + ToFelts + Into<::AccountId> + From<::AccountId>; + + /// ZK Trie recorder for inserting transfer leaves into the Merkle tree. + /// Set to `()` to disable ZK trie recording. + type ZkTrie: pallet_zk_trie::ZkTrieRecorder< + ::AccountId, + Self::AssetId, + Self::NativeBalance, + >; } #[pallet::storage] @@ -223,21 +213,7 @@ pub mod pallet { pub(super) type UsedNullifiers = StorageMap<_, Blake2_128Concat, [u8; 32], bool, ValueQuery>; - /// Transfer proofs for wormhole transfers (both native and assets). - /// - /// Storage key: Twox128("Wormhole") || Twox128("TransferProof") || Blake2_256(to, - /// transfer_count) Storage value: leaf_inputs_hash (Poseidon2 hash of full transfer data) - /// - /// The key uses only (to, transfer_count) since transfer_count is atomic per recipient. - /// The ZK circuit verifies that the leaf_inputs_hash in the value section matches - /// the Poseidon2 hash of all transfer details (asset_id, count, from, to, amount), - /// providing full 256-bit security. - #[pallet::storage] - #[pallet::getter(fn transfer_proof)] - pub type TransferProof = - StorageMap<_, Blake2_256, TransferProofKey, LeafInputsHash, OptionQuery>; - - /// Transfer count for all wormhole transfers + /// Transfer count per recipient - used to generate unique leaf indices in the ZK trie. #[pallet::storage] #[pallet::getter(fn transfer_count)] pub type TransferCount = @@ -608,6 +584,10 @@ pub mod pallet { Ok((proof, inputs)) } + /// Record a transfer in the ZK trie and emit events. + /// + /// This inserts the transfer data into the 4-ary Poseidon Merkle tree + /// managed by pallet-zk-trie, which provides Merkle proofs for ZK circuits. pub fn record_transfer( asset_id: T::AssetId, from: &::WormholeAccountId, @@ -616,21 +596,25 @@ pub mod pallet { ) { let current_count = TransferCount::::get(to); - // Storage key uses Blake2_256 hash of (to, transfer_count) - // This is unique since transfer_count is atomic per recipient - let key: TransferProofKey = (to.clone(), current_count); - - // Storage value is the Poseidon2 hash of the full transfer data (leaf_inputs_hash) - // This matches what the ZK circuit computes and verifies - let full_data: TransferProofData = - (asset_id.clone(), current_count, from.clone(), to.clone(), amount); - let encoded_data = full_data.encode(); - let leaf_inputs_hash = - PoseidonCore::hash_storage::>(&encoded_data); - - TransferProof::::insert(key, leaf_inputs_hash); + // Increment transfer count for this recipient TransferCount::::insert(to, current_count.saturating_add(T::TransferCount::one())); + // Insert into ZK trie for Merkle proof generation + // Convert transfer_count to u64 for the trie + let transfer_count_u64: u64 = { + let encoded = current_count.encode(); + let mut bytes = [0u8; 8]; + let len = encoded.len().min(8); + bytes[..len].copy_from_slice(&encoded[..len]); + u64::from_le_bytes(bytes) + }; + T::ZkTrie::record_transfer( + to.clone().into(), + transfer_count_u64, + asset_id.clone(), + amount, + ); + if asset_id == T::AssetId::default() { Self::deposit_event(Event::::NativeTransferred { from: from.clone().into(), diff --git a/pallets/wormhole/src/mock.rs b/pallets/wormhole/src/mock.rs index 7a30ef9f..c45a5939 100644 --- a/pallets/wormhole/src/mock.rs +++ b/pallets/wormhole/src/mock.rs @@ -139,6 +139,7 @@ impl pallet_wormhole::Config for Test { type VolumeFeesBurnRate = VolumeFeesBurnRate; type WormholeAccountId = AccountId; type WeightInfo = crate::weights::SubstrateWeight; + type ZkTrie = (); // Disabled in tests - use () no-op implementation } // Helper function to build a genesis configuration diff --git a/pallets/wormhole/src/tests.rs b/pallets/wormhole/src/tests.rs index 2db853b3..12f03e4f 100644 --- a/pallets/wormhole/src/tests.rs +++ b/pallets/wormhole/src/tests.rs @@ -1,7 +1,6 @@ #[cfg(test)] mod wormhole_tests { use crate::mock::*; - use codec::Encode; use frame_support::{ assert_ok, traits::{ @@ -9,7 +8,6 @@ mod wormhole_tests { Currency, }, }; - use qp_poseidon::PoseidonHasher; use sp_core::crypto::AccountId32; /// Well-known test secret for genesis endowment (matches runtime preset). @@ -33,24 +31,8 @@ mod wormhole_tests { AccountId32::new(TEST_ADDRESS) } - /// Compute the expected leaf_inputs_hash for a transfer. - /// This must match the computation in record_transfer. - fn compute_leaf_inputs_hash( - asset_id: u32, - transfer_count: u64, - from: &AccountId, - to: &AccountId, - amount: Balance, - ) -> [u8; 32] { - let full_data: (u32, u64, AccountId, AccountId, Balance) = - (asset_id, transfer_count, from.clone(), to.clone(), amount); - PoseidonHasher::hash_storage::<(u32, u64, AccountId, AccountId, Balance)>( - &full_data.encode(), - ) - } - #[test] - fn record_transfer_creates_proof_and_increments_count() { + fn record_transfer_increments_count() { new_test_ext().execute_with(|| { let alice = account_id(1); let bob = account_id(2); @@ -61,15 +43,6 @@ mod wormhole_tests { assert_eq!(Wormhole::transfer_count(&bob), count_before + 1); - // Verify the stored hash matches the expected leaf_inputs_hash - let expected_hash = compute_leaf_inputs_hash(0u32, count_before, &alice, &bob, amount); - let stored_hash = Wormhole::transfer_proof((bob.clone(), count_before)) - .expect("transfer proof should exist"); - assert_eq!( - stored_hash, expected_hash, - "stored hash should match expected leaf_inputs_hash" - ); - // Second transfer increments count again Wormhole::record_transfer(0u32, &alice, &bob, amount); assert_eq!(Wormhole::transfer_count(&bob), count_before + 2); @@ -117,22 +90,13 @@ mod wormhole_tests { frame_support::traits::tokens::Preservation::Expendable, )); - // 2. Record the transfer proof + // 2. Record the transfer (now goes to ZK trie, but disabled in mock) let count_before = Wormhole::transfer_count(&bob); Wormhole::record_transfer(0u32, &alice, &bob, amount); assert_eq!(Balances::balance(&alice), amount); assert_eq!(Balances::balance(&bob), amount); assert_eq!(Wormhole::transfer_count(&bob), count_before + 1); - - // Verify the stored hash matches the expected leaf_inputs_hash - let expected_hash = compute_leaf_inputs_hash(0u32, count_before, &alice, &bob, amount); - let stored_hash = - Wormhole::transfer_proof((bob, count_before)).expect("transfer proof should exist"); - assert_eq!( - stored_hash, expected_hash, - "stored hash should match expected leaf_inputs_hash" - ); }); } @@ -190,9 +154,9 @@ mod wormhole_tests { } #[test] - fn genesis_endowments_have_transfer_proofs() { - // Test that addresses endowed at genesis have TransferProof recorded, - // enabling them to spend via ZK proofs. + fn genesis_endowments_are_recorded() { + // Test that addresses endowed at genesis have their transfers recorded, + // enabling them to spend via ZK proofs (proofs stored in ZK trie). use frame_support::traits::Hooks; let address = test_account(); @@ -207,48 +171,24 @@ mod wormhole_tests { "Address should have endowed balance" ); - // Before block 1: TransferProof should NOT exist yet + // Before block 1: transfer count should be 0 assert_eq!( Wormhole::transfer_count(&address), 0, "Transfer count should be 0 before on_initialize" ); - assert!( - Wormhole::transfer_proof((address.clone(), 0)).is_none(), - "TransferProof should not exist before on_initialize" - ); // Trigger on_initialize at block 1 to process genesis endowments System::set_block_number(1); Wormhole::on_initialize(1); - // After block 1: TransferProof should exist + // After block 1: transfer count should be incremented assert_eq!( Wormhole::transfer_count(&address), 1, "Transfer count should be 1 after on_initialize" ); - let transfer_proof = Wormhole::transfer_proof((address.clone(), 0)); - assert!( - transfer_proof.is_some(), - "TransferProof should exist for genesis-endowed address" - ); - - // Verify the stored hash matches expected computation - let expected_hash = compute_leaf_inputs_hash( - 0u32, // asset_id (native) - 0, // transfer_count - &MINTING_ACCOUNT, // from (genesis uses minting account) - &address, // to - endowment_amount, // amount - ); - assert_eq!( - transfer_proof.unwrap(), - expected_hash, - "TransferProof hash should match expected value" - ); - // Verify event was emitted System::assert_last_event( crate::Event::::NativeTransferred { @@ -264,10 +204,10 @@ mod wormhole_tests { } #[test] - fn genesis_multiple_endowments_all_have_transfer_proofs() { - // Test multiple addresses endowed at genesis all get TransferProofs. + fn genesis_multiple_endowments_all_recorded() { + // Test multiple addresses endowed at genesis all get their transfers recorded. // The chain doesn't distinguish "wormhole addresses" from regular addresses - - // any address can have transfer proofs and spend via ZK proofs. + // any address can have transfers recorded and spend via ZK proofs. use frame_support::traits::Hooks; let addr1 = account_id(100); @@ -289,7 +229,7 @@ mod wormhole_tests { assert_eq!(Balances::balance(&addr2), amount2); assert_eq!(Balances::balance(&addr3), amount3); - // Before block 1: No transfer proofs yet + // Before block 1: No transfers recorded yet assert_eq!(Wormhole::transfer_count(&addr1), 0); assert_eq!(Wormhole::transfer_count(&addr2), 0); assert_eq!(Wormhole::transfer_count(&addr3), 0); @@ -302,19 +242,6 @@ mod wormhole_tests { assert_eq!(Wormhole::transfer_count(&addr1), 1); assert_eq!(Wormhole::transfer_count(&addr2), 1); assert_eq!(Wormhole::transfer_count(&addr3), 1); - - // All addresses should have TransferProof at index 0 - assert!(Wormhole::transfer_proof((addr1.clone(), 0)).is_some()); - assert!(Wormhole::transfer_proof((addr2.clone(), 0)).is_some()); - assert!(Wormhole::transfer_proof((addr3.clone(), 0)).is_some()); - - // Verify each proof has correct hash - for (addr, amount) in [(addr1, amount1), (addr2, amount2), (addr3, amount3)] { - let expected_hash = - compute_leaf_inputs_hash(0u32, 0, &MINTING_ACCOUNT, &addr, amount); - let stored_hash = Wormhole::transfer_proof((addr, 0)).unwrap(); - assert_eq!(stored_hash, expected_hash); - } }); } diff --git a/pallets/zk-trie/src/lib.rs b/pallets/zk-trie/src/lib.rs index 06fa65e9..c50d1bf8 100644 --- a/pallets/zk-trie/src/lib.rs +++ b/pallets/zk-trie/src/lib.rs @@ -224,6 +224,49 @@ pub mod pallet { } } +// ============================================================================ +// Trait for external pallets +// ============================================================================ + +/// Trait for inserting leaves into the ZK trie. +/// Used by pallet-wormhole to record transfer proofs. +pub trait ZkTrieRecorder { + /// Insert a transfer into the ZK trie. + /// Returns the leaf index and new root hash. + fn record_transfer( + to: AccountId, + transfer_count: u64, + asset_id: AssetId, + amount: Balance, + ) -> Option<(u64, Hash256)>; +} + +/// No-op implementation for when ZK trie is not configured. +impl ZkTrieRecorder for () { + fn record_transfer( + _to: AccountId, + _transfer_count: u64, + _asset_id: AssetId, + _amount: Balance, + ) -> Option<(u64, Hash256)> { + None + } +} + +impl ZkTrieRecorder for Pallet +where + T::AccountId: AsRef<[u8]>, +{ + fn record_transfer( + to: T::AccountId, + transfer_count: u64, + asset_id: T::AssetId, + amount: T::Balance, + ) -> Option<(u64, Hash256)> { + Self::insert_leaf(to, transfer_count, asset_id, amount).ok() + } +} + // ============================================================================ // Runtime API // ============================================================================ diff --git a/runtime/src/configs/mod.rs b/runtime/src/configs/mod.rs index 4bdc7ad1..93e00f81 100644 --- a/runtime/src/configs/mod.rs +++ b/runtime/src/configs/mod.rs @@ -63,8 +63,8 @@ use sp_version::RuntimeVersion; use super::{ AccountId, Assets, Balance, Balances, Block, BlockNumber, Hash, Nonce, OriginCaller, PalletInfo, Preimage, Referenda, Runtime, RuntimeCall, RuntimeEvent, RuntimeFreezeReason, - RuntimeHoldReason, RuntimeOrigin, RuntimeTask, Scheduler, System, Timestamp, Wormhole, DAYS, - EXISTENTIAL_DEPOSIT, MICRO_UNIT, TARGET_BLOCK_TIME_MS, UNIT, VERSION, + RuntimeHoldReason, RuntimeOrigin, RuntimeTask, Scheduler, System, Timestamp, Wormhole, ZkTrie, + DAYS, EXISTENTIAL_DEPOSIT, MICRO_UNIT, TARGET_BLOCK_TIME_MS, UNIT, VERSION, }; use sp_core::U512; @@ -700,6 +700,7 @@ impl pallet_wormhole::Config for Runtime { type VolumeFeesBurnRate = VolumeFeesBurnRate; type WormholeAccountId = AccountId32; type WeightInfo = pallet_wormhole::weights::SubstrateWeight; + type ZkTrie = ZkTrie; } impl pallet_zk_trie::Config for Runtime { From 259a39b91695a2426a30e3eac42540b8692f4103 Mon Sep 17 00:00:00 2001 From: illuzen Date: Sun, 12 Apr 2026 11:21:44 +0800 Subject: [PATCH 03/19] fix runtime tests, make insertion infallible, document why no from in proof --- pallets/wormhole/src/lib.rs | 13 ++---- pallets/zk-trie/src/lib.rs | 66 ++++++++++++++++----------- pallets/zk-trie/src/tests.rs | 31 ++++++------- pallets/zk-trie/src/tree.rs | 44 +++--------------- runtime/src/transaction_extensions.rs | 32 +++---------- 5 files changed, 72 insertions(+), 114 deletions(-) diff --git a/pallets/wormhole/src/lib.rs b/pallets/wormhole/src/lib.rs index 414c7994..72f19616 100644 --- a/pallets/wormhole/src/lib.rs +++ b/pallets/wormhole/src/lib.rs @@ -39,7 +39,7 @@ pub const SCALE_DOWN_FACTOR: u128 = 10_000_000_000; pub mod pallet { use crate::{ToFelts, WeightInfo}; use alloc::vec::Vec; - use codec::{Decode, Encode}; + use codec::Decode; use frame_support::{ dispatch::{DispatchErrorWithPostInfo, DispatchResultWithPostInfo, PostDispatchInfo}, pallet_prelude::*, @@ -163,6 +163,7 @@ pub mod pallet { + Saturating + Copy + sp_runtime::traits::One + + Into + ToFelts; /// Account ID used as the "from" account when creating transfer proofs for minted tokens @@ -600,17 +601,9 @@ pub mod pallet { TransferCount::::insert(to, current_count.saturating_add(T::TransferCount::one())); // Insert into ZK trie for Merkle proof generation - // Convert transfer_count to u64 for the trie - let transfer_count_u64: u64 = { - let encoded = current_count.encode(); - let mut bytes = [0u8; 8]; - let len = encoded.len().min(8); - bytes[..len].copy_from_slice(&encoded[..len]); - u64::from_le_bytes(bytes) - }; T::ZkTrie::record_transfer( to.clone().into(), - transfer_count_u64, + current_count.into(), asset_id.clone(), amount, ); diff --git a/pallets/zk-trie/src/lib.rs b/pallets/zk-trie/src/lib.rs index c50d1bf8..3c779bf5 100644 --- a/pallets/zk-trie/src/lib.rs +++ b/pallets/zk-trie/src/lib.rs @@ -48,6 +48,20 @@ pub const ARITY: usize = 4; pub type Hash256 = [u8; 32]; /// Leaf data for the ZK tree. +/// +/// # Why `from` is not included +/// +/// The ZK circuit needs to verify two things about a transfer: +/// 1. The transfer amount (to compute balances) +/// 2. The transfer is unique (to prevent double-spending) +/// +/// Uniqueness is guaranteed by `(to, transfer_count)` - each recipient has a +/// monotonically increasing counter, so every transfer to that recipient gets +/// a unique index. The `from` address is irrelevant for proving ownership of +/// received funds; what matters is that the transfer happened exactly once. +/// +/// Omitting `from` reduces the leaf size and simplifies the ZK circuit without +/// sacrificing security properties. #[derive( codec::Encode, codec::Decode, @@ -61,7 +75,7 @@ pub type Hash256 = [u8; 32]; pub struct ZkLeaf { /// Recipient account pub to: AccountId, - /// Transfer count (unique per recipient) + /// Transfer count for this recipient (ensures uniqueness via `(to, transfer_count)`) pub transfer_count: u64, /// Asset ID (0 for native token) pub asset_id: AssetId, @@ -140,8 +154,6 @@ pub mod pallet { #[pallet::error] pub enum Error { - /// Tree has reached maximum depth. - MaxDepthReached, /// Leaf index out of bounds. LeafIndexOutOfBounds, /// Leaf not found. @@ -165,12 +177,18 @@ pub mod pallet { /// Insert a new leaf into the tree. /// /// Returns the leaf index and new root hash. + /// + /// # Infallibility + /// + /// This function is infallible because the only theoretical failure mode + /// (exceeding MAX_TREE_DEPTH of 32) would require 4^32 leaves, which is + /// astronomically larger than any practical blockchain state. pub fn insert_leaf( to: AccountIdOf, transfer_count: u64, asset_id: T::AssetId, amount: T::Balance, - ) -> Result<(u64, Hash256), Error> { + ) -> (u64, Hash256) { let leaf = ZkLeaf { to, transfer_count, asset_id, amount }; let leaf_index = LeafCount::::get(); @@ -180,10 +198,15 @@ pub mod pallet { if leaf_index >= capacity { // Need to grow the tree - let new_depth = current_depth.checked_add(1).ok_or(Error::::MaxDepthReached)?; - ensure!(new_depth <= MAX_TREE_DEPTH, Error::::MaxDepthReached); - - tree::grow_tree::(current_depth, new_depth)?; + // saturating_add ensures we never overflow; MAX_TREE_DEPTH=32 means 4^32 leaves + // which is ~18 quintillion - far beyond any practical blockchain state + let new_depth = current_depth.saturating_add(1); + debug_assert!( + new_depth <= MAX_TREE_DEPTH, + "ZK trie exceeded max depth - this should never happen in practice" + ); + + tree::grow_tree::(current_depth, new_depth); Depth::::put(new_depth); Self::deposit_event(Event::TreeGrew { new_depth }); @@ -195,13 +218,13 @@ pub mod pallet { // Compute leaf hash and update tree let leaf_hash = tree::hash_leaf::(&leaf); - let new_root = tree::update_path::(leaf_index, leaf_hash)?; + let new_root = tree::update_path::(leaf_index, leaf_hash); Root::::put(new_root); Self::deposit_event(Event::LeafInserted { index: leaf_index, leaf_hash, new_root }); - Ok((leaf_index, new_root)) + (leaf_index, new_root) } /// Get a Merkle proof for a leaf at the given index. @@ -232,24 +255,15 @@ pub mod pallet { /// Used by pallet-wormhole to record transfer proofs. pub trait ZkTrieRecorder { /// Insert a transfer into the ZK trie. - /// Returns the leaf index and new root hash. - fn record_transfer( - to: AccountId, - transfer_count: u64, - asset_id: AssetId, - amount: Balance, - ) -> Option<(u64, Hash256)>; + /// + /// This operation is infallible. Implementations must always succeed. + fn record_transfer(to: AccountId, transfer_count: u64, asset_id: AssetId, amount: Balance); } /// No-op implementation for when ZK trie is not configured. impl ZkTrieRecorder for () { - fn record_transfer( - _to: AccountId, - _transfer_count: u64, - _asset_id: AssetId, - _amount: Balance, - ) -> Option<(u64, Hash256)> { - None + fn record_transfer(_to: AccountId, _transfer_count: u64, _asset_id: AssetId, _amount: Balance) { + // No-op } } @@ -262,8 +276,8 @@ where transfer_count: u64, asset_id: T::AssetId, amount: T::Balance, - ) -> Option<(u64, Hash256)> { - Self::insert_leaf(to, transfer_count, asset_id, amount).ok() + ) { + Self::insert_leaf(to, transfer_count, asset_id, amount); } } diff --git a/pallets/zk-trie/src/tests.rs b/pallets/zk-trie/src/tests.rs index cacf58da..03e0e292 100644 --- a/pallets/zk-trie/src/tests.rs +++ b/pallets/zk-trie/src/tests.rs @@ -103,7 +103,7 @@ fn test_hash_node() { fn insert_first_leaf_works() { new_test_ext().execute_with(|| { let to = make_account(1); - let (index, root) = ZkTrie::insert_leaf(to.clone(), 0, 0u32, 100u128).unwrap(); + let (index, root) = ZkTrie::insert_leaf(to.clone(), 0, 0u32, 100u128); assert_eq!(index, 0); assert_ne!(root, [0u8; 32]); @@ -127,8 +127,7 @@ fn insert_multiple_leaves_works() { for i in 0..4 { let to = make_account(i + 1); - let (index, root) = - ZkTrie::insert_leaf(to, i as u64, 0u32, (i + 1) as u128 * 100).unwrap(); + let (index, root) = ZkTrie::insert_leaf(to, i as u64, 0u32, (i + 1) as u128 * 100); assert_eq!(index, i as u64); roots.push(root); } @@ -149,13 +148,13 @@ fn tree_grows_at_capacity() { // Fill depth 1 (4 leaves) for i in 0..4 { let to = make_account(i + 1); - ZkTrie::insert_leaf(to, i as u64, 0u32, 100u128).unwrap(); + ZkTrie::insert_leaf(to, i as u64, 0u32, 100u128); } assert_eq!(ZkTrie::depth(), 1); // 5th leaf should trigger growth to depth 2 let to = make_account(5); - ZkTrie::insert_leaf(to, 4, 0u32, 100u128).unwrap(); + ZkTrie::insert_leaf(to, 4, 0u32, 100u128); assert_eq!(ZkTrie::leaf_count(), 5); assert_eq!(ZkTrie::depth(), 2); @@ -168,7 +167,7 @@ fn tree_grows_multiple_times() { // Insert 20 leaves (need depth 3 to fit: 4^3 = 64) for i in 0..20 { let to = make_account((i % 255) as u8 + 1); - ZkTrie::insert_leaf(to, i as u64, 0u32, 100u128).unwrap(); + ZkTrie::insert_leaf(to, i as u64, 0u32, 100u128); } assert_eq!(ZkTrie::leaf_count(), 20); @@ -182,7 +181,7 @@ fn merkle_proof_works() { // Insert some leaves for i in 0..5 { let to = make_account(i + 1); - ZkTrie::insert_leaf(to, i as u64, 0u32, (i + 1) as u128 * 100).unwrap(); + ZkTrie::insert_leaf(to, i as u64, 0u32, (i + 1) as u128 * 100); } // Get proof for leaf 0 @@ -203,7 +202,7 @@ fn merkle_proof_all_leaves() { // Insert leaves for i in 0..10 { let to = make_account(i + 1); - ZkTrie::insert_leaf(to, i as u64, i as u32, (i + 1) as u128 * 100).unwrap(); + ZkTrie::insert_leaf(to, i as u64, i as u32, (i + 1) as u128 * 100); } // Verify proof for each leaf @@ -221,7 +220,7 @@ fn invalid_proof_fails() { // Insert leaves for i in 0..5 { let to = make_account(i + 1); - ZkTrie::insert_leaf(to, i as u64, 0u32, (i + 1) as u128 * 100).unwrap(); + ZkTrie::insert_leaf(to, i as u64, 0u32, (i + 1) as u128 * 100); } // Get proof for leaf 0 @@ -237,7 +236,7 @@ fn invalid_proof_fails() { #[test] fn proof_for_nonexistent_leaf_fails() { new_test_ext().execute_with(|| { - ZkTrie::insert_leaf(make_account(1), 0, 0u32, 100u128).unwrap(); + ZkTrie::insert_leaf(make_account(1), 0, 0u32, 100u128); // Try to get proof for leaf index 5 (doesn't exist) let result = ZkTrie::get_merkle_proof(5); @@ -248,8 +247,8 @@ fn proof_for_nonexistent_leaf_fails() { #[test] fn root_changes_on_insert() { new_test_ext().execute_with(|| { - let (_, root1) = ZkTrie::insert_leaf(make_account(1), 0, 0u32, 100u128).unwrap(); - let (_, root2) = ZkTrie::insert_leaf(make_account(2), 1, 0u32, 200u128).unwrap(); + let (_, root1) = ZkTrie::insert_leaf(make_account(1), 0, 0u32, 100u128); + let (_, root2) = ZkTrie::insert_leaf(make_account(2), 1, 0u32, 200u128); assert_ne!(root1, root2); assert_eq!(ZkTrie::root(), root2); @@ -259,7 +258,7 @@ fn root_changes_on_insert() { #[test] fn different_amounts_give_different_hashes() { new_test_ext().execute_with(|| { - let (_, root1) = ZkTrie::insert_leaf(make_account(1), 0, 0u32, 100u128).unwrap(); + let (_, root1) = ZkTrie::insert_leaf(make_account(1), 0, 0u32, 100u128); // Reset and insert with different amount crate::Leaves::::remove(0); @@ -267,7 +266,7 @@ fn different_amounts_give_different_hashes() { crate::Depth::::put(0); crate::Root::::put([0u8; 32]); - let (_, root2) = ZkTrie::insert_leaf(make_account(1), 0, 0u32, 200u128).unwrap(); + let (_, root2) = ZkTrie::insert_leaf(make_account(1), 0, 0u32, 200u128); assert_ne!(root1, root2); }); @@ -276,7 +275,7 @@ fn different_amounts_give_different_hashes() { #[test] fn digest_log_contains_root() { new_test_ext().execute_with(|| { - ZkTrie::insert_leaf(make_account(1), 0, 0u32, 100u128).unwrap(); + ZkTrie::insert_leaf(make_account(1), 0, 0u32, 100u128); let expected_root = ZkTrie::root(); // Trigger on_finalize @@ -321,7 +320,7 @@ fn simulate_transfer( asset_id: u32, amount: u128, ) -> (u64, Hash256) { - ZkTrie::insert_leaf(to, transfer_count, asset_id, amount).expect("insert_leaf should succeed") + ZkTrie::insert_leaf(to, transfer_count, asset_id, amount) } #[test] diff --git a/pallets/zk-trie/src/tree.rs b/pallets/zk-trie/src/tree.rs index 530eb067..c35e965f 100644 --- a/pallets/zk-trie/src/tree.rs +++ b/pallets/zk-trie/src/tree.rs @@ -8,8 +8,8 @@ //! - Tree growth when capacity is exceeded use crate::{ - pallet::{AccountIdOf, Config}, - Error, Hash256, ZkLeaf, ZkMerkleProof, ARITY, + pallet::{AccountIdOf, Config, Error}, + Hash256, ZkLeaf, ZkMerkleProof, ARITY, }; use alloc::vec::Vec; @@ -97,7 +97,7 @@ fn get_node_hash(level: u8, index: u64) -> Hash256 { /// Update the path from a leaf to the root after insertion. /// /// Returns the new root hash. -pub fn update_path(leaf_index: u64, leaf_hash: Hash256) -> Result> +pub fn update_path(leaf_index: u64, leaf_hash: Hash256) -> Hash256 where AccountIdOf: AsRef<[u8]>, { @@ -106,7 +106,7 @@ where if depth == 0 { // Special case: first leaf in empty tree - need to initialize crate::Depth::::put(1); - return Ok(leaf_hash); + return leaf_hash; } // Start from leaf level and work up to root @@ -116,7 +116,6 @@ where for level in 1..=depth { // Find which group of 4 this node belongs to let parent_index = current_index / (ARITY as u64); - let _position_in_parent = (current_index % (ARITY as u64)) as usize; // Get all 4 children for this parent let mut children = [empty_hash(); ARITY]; @@ -156,16 +155,16 @@ where current_index = parent_index; } - Ok(current_hash) + current_hash } /// Grow the tree by one level. /// /// The current root becomes one of the children of the new root. -pub fn grow_tree(old_depth: u8, _new_depth: u8) -> Result<(), Error> { +pub fn grow_tree(old_depth: u8, _new_depth: u8) { if old_depth == 0 { // Tree was empty, just set depth - return Ok(()); + return; } // The old root hash becomes child[0] of the new root @@ -181,8 +180,6 @@ pub fn grow_tree(old_depth: u8, _new_depth: u8) -> Result<(), Error::put(new_root); - - Ok(()) } /// Generate a Merkle proof for a leaf at the given index. @@ -247,7 +244,6 @@ where } let mut current_hash = hash_leaf::(leaf); - let mut _current_index = proof.leaf_index; for (level_siblings, &position) in proof.siblings.iter().zip(proof.path_indices.iter()) { if position >= ARITY as u8 { @@ -268,7 +264,6 @@ where } current_hash = hash_node(&children); - _current_index /= ARITY as u64; } current_hash == expected_root @@ -278,31 +273,6 @@ where mod tests { use super::*; - #[test] - fn test_capacity_at_depth() { - assert_eq!(capacity_at_depth(0), 0); - assert_eq!(capacity_at_depth(1), 4); - assert_eq!(capacity_at_depth(2), 16); - assert_eq!(capacity_at_depth(3), 64); - assert_eq!(capacity_at_depth(4), 256); - } - - #[test] - fn test_hash_node() { - let children = [[1u8; 32], [2u8; 32], [3u8; 32], [4u8; 32]]; - let hash = hash_node(&children); - assert_ne!(hash, [0u8; 32]); - - // Same input should give same output - let hash2 = hash_node(&children); - assert_eq!(hash, hash2); - - // Different input should give different output - let children2 = [[1u8; 32], [2u8; 32], [3u8; 32], [5u8; 32]]; - let hash3 = hash_node(&children2); - assert_ne!(hash, hash3); - } - #[test] fn test_empty_hash() { let h = empty_hash(); diff --git a/runtime/src/transaction_extensions.rs b/runtime/src/transaction_extensions.rs index 5f6e40ed..2860509c 100644 --- a/runtime/src/transaction_extensions.rs +++ b/runtime/src/transaction_extensions.rs @@ -623,15 +623,9 @@ mod tests { // Use 0 as the before count for tests (all events are "new"). WormholeProofRecorderExtension::::record_proofs_from_events_since(0); - // Verify proof was recorded + // Verify transfer was recorded (proof is now in ZK trie) let count_after = Wormhole::transfer_count(&bob_account); assert_eq!(count_after, count_before + 1, "Transfer count should increment"); - - // Verify the proof exists - assert!( - Wormhole::transfer_proof((bob_account, count_before)).is_some(), - "Transfer proof should exist" - ); }); } @@ -656,9 +650,8 @@ mod tests { // Use 0 as the before count for tests (all events are "new"). WormholeProofRecorderExtension::::record_proofs_from_events_since(0); - // Verify proof was recorded + // Verify transfer was recorded (proof is now in ZK trie) assert_eq!(Wormhole::transfer_count(&bob_account), count_before + 1); - assert!(Wormhole::transfer_proof((bob_account, count_before)).is_some()); }); } @@ -681,9 +674,8 @@ mod tests { // Use 0 as the before count for tests (all events are "new"). WormholeProofRecorderExtension::::record_proofs_from_events_since(0); - // Verify proof was recorded with actual amount (not Balance::MAX) + // Verify transfer was recorded (proof is now in ZK trie) assert_eq!(Wormhole::transfer_count(&bob_account), count_before + 1); - assert!(Wormhole::transfer_proof((bob_account, count_before)).is_some()); }); } @@ -717,11 +709,9 @@ mod tests { // Use 0 as the before count for tests (all events are "new"). WormholeProofRecorderExtension::::record_proofs_from_events_since(0); - // Verify both proofs were recorded + // Verify both transfers were recorded (proofs are now in ZK trie) assert_eq!(Wormhole::transfer_count(&bob_account), bob_count_before + 1); assert_eq!(Wormhole::transfer_count(&charlie_account), charlie_count_before + 1); - assert!(Wormhole::transfer_proof((bob_account, bob_count_before)).is_some()); - assert!(Wormhole::transfer_proof((charlie_account, charlie_count_before)).is_some()); }); } @@ -777,10 +767,8 @@ mod tests { // Check if count increased (depends on whether Minted event is emitted) // force_set_balance may emit BalanceSet instead of Minted - // This test documents the expected behavior - if count_after > count_before { - assert!(Wormhole::transfer_proof((recipient, count_before)).is_some()); - } + // This test documents the expected behavior - proofs are now in ZK trie + assert!(count_after >= count_before, "Transfer count should not decrease"); }); } @@ -942,7 +930,7 @@ mod tests { // Use 0 as the before count for tests (all events are "new"). WormholeProofRecorderExtension::::record_proofs_from_events_since(0); - // Verify proof was recorded for the transfer TO charlie + // Verify transfer was recorded (proof is now in ZK trie) // The transfer is FROM the multisig address let count_after = Wormhole::transfer_count(&charlie_account); assert_eq!( @@ -950,12 +938,6 @@ mod tests { count_before + 1, "Transfer count should increment for multisig transfer" ); - - // Verify the proof exists - assert!( - Wormhole::transfer_proof((charlie_account, count_before)).is_some(), - "Transfer proof should exist for multisig transfer" - ); }); } } From 76d78a3da2af0c0432ddc2e0c24c926576c827d1 Mon Sep 17 00:00:00 2001 From: illuzen Date: Sun, 12 Apr 2026 11:32:00 +0800 Subject: [PATCH 04/19] remove indices in proof --- pallets/zk-trie/src/lib.rs | 17 ++++++++----- pallets/zk-trie/src/tests.rs | 33 +++++++++++------------- pallets/zk-trie/src/tree.rs | 49 ++++++++++++++++-------------------- runtime/src/apis.rs | 1 - 4 files changed, 46 insertions(+), 54 deletions(-) diff --git a/pallets/zk-trie/src/lib.rs b/pallets/zk-trie/src/lib.rs index 3c779bf5..eac94510 100644 --- a/pallets/zk-trie/src/lib.rs +++ b/pallets/zk-trie/src/lib.rs @@ -84,14 +84,18 @@ pub struct ZkLeaf { } /// Merkle proof for a leaf in the 4-ary tree. +/// +/// # Index-free verification +/// +/// Because internal nodes sort their children before hashing, proofs don't need +/// path indices. The verifier simply combines the current hash with the 3 siblings, +/// sorts all 4, and hashes to get the parent. This simplifies ZK circuit verification. #[derive(codec::Encode, codec::Decode, Clone, PartialEq, Eq, scale_info::TypeInfo, Debug)] pub struct ZkMerkleProof { - /// Index of the leaf + /// Index of the leaf (for reference, not needed for verification) pub leaf_index: u64, /// Sibling hashes at each level (3 siblings per level for 4-ary tree) pub siblings: alloc::vec::Vec<[Hash256; 3]>, - /// Position within siblings at each level (0-3) - pub path_indices: alloc::vec::Vec, } #[frame_support::pallet] @@ -286,11 +290,14 @@ where // ============================================================================ /// RPC-friendly Merkle proof structure (no generics). +/// /// Uses raw bytes for the leaf data to avoid generic type issues in RPC. +/// No path indices needed - children are sorted before hashing, so verification +/// just requires combining current hash with siblings, sorting, and hashing. #[derive(codec::Encode, codec::Decode, Clone, PartialEq, Eq, scale_info::TypeInfo, Debug)] #[cfg_attr(feature = "std", derive(serde::Serialize, serde::Deserialize))] pub struct ZkMerkleProofRpc { - /// Index of the leaf + /// Index of the leaf (for reference, not needed for verification) pub leaf_index: u64, /// The leaf data (encoded ZkLeaf) pub leaf_data: Vec, @@ -298,8 +305,6 @@ pub struct ZkMerkleProofRpc { pub leaf_hash: Hash256, /// Sibling hashes at each level (3 siblings per level for 4-ary tree) pub siblings: Vec<[Hash256; 3]>, - /// Position within siblings at each level (0-3) - pub path_indices: Vec, /// Current tree root pub root: Hash256, /// Current tree depth diff --git a/pallets/zk-trie/src/tests.rs b/pallets/zk-trie/src/tests.rs index 03e0e292..2e943452 100644 --- a/pallets/zk-trie/src/tests.rs +++ b/pallets/zk-trie/src/tests.rs @@ -188,7 +188,6 @@ fn merkle_proof_works() { let proof = ZkTrie::get_merkle_proof(0).unwrap(); assert_eq!(proof.leaf_index, 0); assert_eq!(proof.siblings.len(), 2); // depth 2 - assert_eq!(proof.path_indices.len(), 2); // Verify the proof let leaf = ZkTrie::leaf(0).unwrap(); @@ -454,7 +453,7 @@ fn integration_root_changes_only_on_insert() { } #[test] -fn integration_proof_contains_correct_path_indices() { +fn integration_proof_siblings_at_correct_depth() { new_test_ext().execute_with(|| { // Insert 5 leaves to force depth 2 for i in 0..5u64 { @@ -464,24 +463,20 @@ fn integration_proof_contains_correct_path_indices() { assert_eq!(ZkTrie::depth(), 2); - // Check path indices for each leaf - // In a 4-ary tree at depth 2: - // Leaf 0: path [0, 0] (first child at each level) - // Leaf 1: path [1, 0] - // Leaf 2: path [2, 0] - // Leaf 3: path [3, 0] - // Leaf 4: path [0, 1] (first child of second node) - - let proof_0 = ZkTrie::get_merkle_proof(0).unwrap(); - assert_eq!(proof_0.path_indices, vec![0, 0]); - - let proof_1 = ZkTrie::get_merkle_proof(1).unwrap(); - assert_eq!(proof_1.path_indices, vec![1, 0]); + // Verify proofs have correct number of sibling levels + // No path indices needed - children are sorted before hashing + for i in 0..5u64 { + let proof = ZkTrie::get_merkle_proof(i).unwrap(); + assert_eq!(proof.siblings.len(), 2, "depth 2 tree should have 2 levels of siblings"); - let proof_3 = ZkTrie::get_merkle_proof(3).unwrap(); - assert_eq!(proof_3.path_indices, vec![3, 0]); + // Each level should have 3 siblings (4-ary tree) + for level_siblings in &proof.siblings { + assert_eq!(level_siblings.len(), 3); + } - let proof_4 = ZkTrie::get_merkle_proof(4).unwrap(); - assert_eq!(proof_4.path_indices, vec![0, 1]); + // Verify the proof works + let leaf = ZkTrie::leaf(i).unwrap(); + assert!(ZkTrie::verify_proof(&leaf, &proof), "proof for leaf {} should verify", i); + } }); } diff --git a/pallets/zk-trie/src/tree.rs b/pallets/zk-trie/src/tree.rs index c35e965f..7b6974a3 100644 --- a/pallets/zk-trie/src/tree.rs +++ b/pallets/zk-trie/src/tree.rs @@ -56,12 +56,20 @@ where /// Hash 4 child hashes into a parent node hash. /// +/// Children are sorted before hashing to eliminate the need for path indices +/// in Merkle proofs. This makes verification simpler in ZK circuits - the +/// verifier just needs the siblings, sorts all 4 children, and hashes. +/// /// Uses non-injective Poseidon (8 bytes/felt) since internal nodes /// only contain fixed-size hash outputs, not user-controlled data. pub fn hash_node(children: &[Hash256; ARITY]) -> Hash256 { + // Sort children to make hash order-independent + let mut sorted = *children; + sorted.sort(); + // Concatenate all 4 child hashes (128 bytes total) let mut data = Vec::with_capacity(32 * ARITY); - for child in children { + for child in &sorted { data.extend_from_slice(child); } @@ -183,6 +191,9 @@ pub fn grow_tree(old_depth: u8, _new_depth: u8) { } /// Generate a Merkle proof for a leaf at the given index. +/// +/// Returns siblings at each level. No path indices needed because children +/// are sorted before hashing - the verifier can reconstruct by sorting. pub fn generate_proof(leaf_index: u64, depth: u8) -> Result> where AccountIdOf: AsRef<[u8]>, @@ -192,15 +203,10 @@ where } let mut siblings = Vec::with_capacity(depth as usize); - let mut path_indices = Vec::with_capacity(depth as usize); - let mut current_index = leaf_index; for level in 1..=depth { let parent_index = current_index / (ARITY as u64); - let position_in_parent = (current_index % (ARITY as u64)) as u8; - - path_indices.push(position_in_parent); // Get sibling hashes (the other 3 children) let mut level_siblings = [empty_hash(); 3]; @@ -227,10 +233,13 @@ where current_index = parent_index; } - Ok(ZkMerkleProof { leaf_index, siblings, path_indices }) + Ok(ZkMerkleProof { leaf_index, siblings }) } /// Verify a Merkle proof against a given root. +/// +/// No path indices needed - we combine current hash with siblings, sort all 4, +/// and hash. This works because `hash_node` sorts children before hashing. pub fn verify_proof( leaf: &ZkLeaf, T::AssetId, T::Balance>, proof: &ZkMerkleProof, @@ -239,30 +248,14 @@ pub fn verify_proof( where AccountIdOf: AsRef<[u8]>, { - if proof.siblings.len() != proof.path_indices.len() { - return false; - } - let mut current_hash = hash_leaf::(leaf); - for (level_siblings, &position) in proof.siblings.iter().zip(proof.path_indices.iter()) { - if position >= ARITY as u8 { - return false; - } - - // Reconstruct the 4 children from position and siblings - let mut children = [empty_hash(); ARITY]; - let mut sibling_idx = 0; - - for i in 0..ARITY { - if i == position as usize { - children[i] = current_hash; - } else { - children[i] = level_siblings[sibling_idx]; - sibling_idx += 1; - } - } + for level_siblings in &proof.siblings { + // Combine current hash with 3 siblings to get all 4 children + let children: [Hash256; ARITY] = + [current_hash, level_siblings[0], level_siblings[1], level_siblings[2]]; + // hash_node sorts internally, so order doesn't matter current_hash = hash_node(&children); } diff --git a/runtime/src/apis.rs b/runtime/src/apis.rs index d75636b9..48c74018 100644 --- a/runtime/src/apis.rs +++ b/runtime/src/apis.rs @@ -202,7 +202,6 @@ impl_runtime_apis! { leaf_data: leaf.encode(), leaf_hash, siblings: proof.siblings, - path_indices: proof.path_indices, root: ZkTrie::root(), depth: ZkTrie::depth(), }) From 941292d13e158b53823ec0346366bdd68c1018e8 Mon Sep 17 00:00:00 2001 From: illuzen Date: Sun, 12 Apr 2026 12:10:24 +0800 Subject: [PATCH 05/19] put leaf index in NativeTransferred and AssetTransferred events --- pallets/wormhole/src/lib.rs | 20 +++++++++++++++++++- pallets/wormhole/src/tests.rs | 2 ++ pallets/zk-trie/src/lib.rs | 22 +++++++++++++++++----- 3 files changed, 38 insertions(+), 6 deletions(-) diff --git a/pallets/wormhole/src/lib.rs b/pallets/wormhole/src/lib.rs index 72f19616..515e2fa1 100644 --- a/pallets/wormhole/src/lib.rs +++ b/pallets/wormhole/src/lib.rs @@ -234,18 +234,30 @@ pub mod pallet { #[pallet::event] #[pallet::generate_deposit(pub(super) fn deposit_event)] pub enum Event { + /// A native token transfer was recorded. + /// + /// The `leaf_index` can be used to fetch Merkle proofs via the + /// `zkTrie_getMerkleProof` RPC for ZK circuit verification. NativeTransferred { from: ::AccountId, to: ::AccountId, amount: BalanceOf, transfer_count: T::TransferCount, + /// Index of this transfer in the ZK trie (for Merkle proof lookup) + leaf_index: u64, }, + /// A non-native asset transfer was recorded. + /// + /// The `leaf_index` can be used to fetch Merkle proofs via the + /// `zkTrie_getMerkleProof` RPC for ZK circuit verification. AssetTransferred { asset_id: T::AssetId, from: ::AccountId, to: ::AccountId, amount: AssetBalanceOf, transfer_count: T::TransferCount, + /// Index of this transfer in the ZK trie (for Merkle proof lookup) + leaf_index: u64, }, ProofVerified { exit_amount: BalanceOf, @@ -589,6 +601,9 @@ pub mod pallet { /// /// This inserts the transfer data into the 4-ary Poseidon Merkle tree /// managed by pallet-zk-trie, which provides Merkle proofs for ZK circuits. + /// + /// The emitted event includes `leaf_index` which clients can use to fetch + /// Merkle proofs via `zkTrie_getMerkleProof(leaf_index)` RPC. pub fn record_transfer( asset_id: T::AssetId, from: &::WormholeAccountId, @@ -601,7 +616,8 @@ pub mod pallet { TransferCount::::insert(to, current_count.saturating_add(T::TransferCount::one())); // Insert into ZK trie for Merkle proof generation - T::ZkTrie::record_transfer( + // Returns the leaf index for clients to use when fetching proofs + let leaf_index = T::ZkTrie::record_transfer( to.clone().into(), current_count.into(), asset_id.clone(), @@ -614,6 +630,7 @@ pub mod pallet { to: to.clone().into(), amount, transfer_count: current_count, + leaf_index, }); } else { Self::deposit_event(Event::::AssetTransferred { @@ -622,6 +639,7 @@ pub mod pallet { asset_id, amount: amount.into(), transfer_count: current_count, + leaf_index, }); } } diff --git a/pallets/wormhole/src/tests.rs b/pallets/wormhole/src/tests.rs index 12f03e4f..1ea8c487 100644 --- a/pallets/wormhole/src/tests.rs +++ b/pallets/wormhole/src/tests.rs @@ -65,6 +65,7 @@ mod wormhole_tests { to: bob, amount, transfer_count: 0, + leaf_index: 0, // First leaf inserted } .into(), ); @@ -196,6 +197,7 @@ mod wormhole_tests { to: address, amount: endowment_amount, transfer_count: 0, + leaf_index: 0, // First leaf inserted } .into(), ); diff --git a/pallets/zk-trie/src/lib.rs b/pallets/zk-trie/src/lib.rs index eac94510..58ecb1d0 100644 --- a/pallets/zk-trie/src/lib.rs +++ b/pallets/zk-trie/src/lib.rs @@ -260,14 +260,25 @@ pub mod pallet { pub trait ZkTrieRecorder { /// Insert a transfer into the ZK trie. /// + /// Returns the leaf index, which can be used to fetch Merkle proofs via RPC. /// This operation is infallible. Implementations must always succeed. - fn record_transfer(to: AccountId, transfer_count: u64, asset_id: AssetId, amount: Balance); + fn record_transfer( + to: AccountId, + transfer_count: u64, + asset_id: AssetId, + amount: Balance, + ) -> u64; } /// No-op implementation for when ZK trie is not configured. impl ZkTrieRecorder for () { - fn record_transfer(_to: AccountId, _transfer_count: u64, _asset_id: AssetId, _amount: Balance) { - // No-op + fn record_transfer( + _to: AccountId, + _transfer_count: u64, + _asset_id: AssetId, + _amount: Balance, + ) -> u64 { + 0 // No-op returns 0 } } @@ -280,8 +291,9 @@ where transfer_count: u64, asset_id: T::AssetId, amount: T::Balance, - ) { - Self::insert_leaf(to, transfer_count, asset_id, amount); + ) -> u64 { + let (leaf_index, _root) = Self::insert_leaf(to, transfer_count, asset_id, amount); + leaf_index } } From 66cc6ac6f9b583b2b2e1fe13e95b5e233ab720d2 Mon Sep 17 00:00:00 2001 From: Nikolaus Heger Date: Sun, 12 Apr 2026 15:09:45 +0800 Subject: [PATCH 06/19] zk trie documentation added --- docs/zk-trie-architecture.md | 374 +++++++++++++++++++++++++++++++++++ 1 file changed, 374 insertions(+) create mode 100644 docs/zk-trie-architecture.md diff --git a/docs/zk-trie-architecture.md b/docs/zk-trie-architecture.md new file mode 100644 index 00000000..6048f6ae --- /dev/null +++ b/docs/zk-trie-architecture.md @@ -0,0 +1,374 @@ +# ZK Trie: Poseidon Merkle Tree for Zero-Knowledge Transfer Proofs + +A 4-ary Poseidon Merkle tree that provides ZK-friendly commitment to all transfers on the Quantus chain. + +## Why a Separate Tree? + +Substrate's storage trie uses Blake2b hashing. Blake2b is fast for native execution but extremely expensive inside ZK circuits (~100x more constraints than Poseidon). A user wanting to prove "I received 500 QTU" would need to verify Blake2b Merkle paths inside a SNARK -- this would make proofs impractically slow and large. + +The ZK trie solves this by maintaining a **parallel commitment structure** using Poseidon hashing, which is native to arithmetic circuits. The key insight: **the ZK trie's storage (leaves, nodes, root) lives inside the normal Substrate state trie**. It is pallet storage, not a separate database. This means it inherits all of Substrate's state management guarantees (atomicity, rollback, finality) for free. + +``` +┌─────────────────────────────────────────────────────────────┐ +│ Block Header │ +│ │ +│ parent_hash ─── state_root ─── extrinsics_root ─── digest │ +│ │ │ │ +│ ▼ ┌────┘ │ +│ ┌───────────────┐ │ │ +│ │ Substrate │ DigestItem::Other │ +│ │ State Trie │ ┌──────────────┐ │ +│ │ (Blake2b) │ │ ZK Trie │ │ +│ │ │ │ Root Hash │ │ +│ │ ┌───────────┐ │ │ (32 bytes) │ │ +│ │ │ Balances │ │ └──────────────┘ │ +│ │ │ Wormhole │ │ │ +│ │ │ QPoW │ │ │ +│ │ │ ... │ │ │ +│ │ │ │ │ │ +│ │ │ ┌───────┐ │ │ │ +│ │ │ │ZkTrie │◄├─┼──── Pallet storage holding │ +│ │ │ │Leaves │ │ │ the Poseidon tree data │ +│ │ │ │Nodes │ │ │ │ +│ │ │ │Root │ │ │ │ +│ │ │ │Depth │ │ │ │ +│ │ │ └───────┘ │ │ │ +│ │ └───────────┘ │ │ +│ └───────────────┘ │ +└─────────────────────────────────────────────────────────────┘ +``` + +The ZK trie root is additionally published in the **block digest** on every `on_finalize`, giving light clients and external verifiers a direct commitment without needing to parse storage proofs. + +## Tree Structure + +A 4-ary (quaternary) Merkle tree where each internal node has 4 children. + +``` +Depth 3 (capacity: 64 leaves) + + [Root] Level 3 + / | \ \ + [N0] [N1] [N2] [N3] Level 2 + / | \ \ / | \ \ + [N00] ... [N10] ... Level 1 + / | \ \ + [L0][L1][L2][L3] Level 0 (leaves) +``` + +| Depth | Capacity (4^d) | Notes | +|-------|---------------|--------------------------| +| 0 | 0 | Empty tree | +| 1 | 4 | First 4 transfers | +| 2 | 16 | Grows automatically | +| 3 | 64 | | +| ... | ... | | +| 32 | ~1.8 × 10^19 | Maximum supported depth | + +The tree grows dynamically -- when the 5th leaf arrives, depth increases from 1 to 2. The old root becomes child[0] of a new root node. + +### Hashing Strategy + +Two different Poseidon modes are used, optimized for their context: + +| Layer | Mode | Bytes/Felt | Why | +|-----------------|-------------------------|------------|--------------------------------------------------------| +| **Leaves** | Injective Poseidon | 4 | Collision resistance for user-controlled data | +| **Internal nodes** | Non-injective Poseidon | 8 | Efficiency -- inputs are fixed-size hashes, not user data | + +**Leaf data** (72 bytes): +``` +┌──────────────────┬──────────────────┬──────────────┬──────────────┐ +│ to (32 bytes) │ transfer_count │ asset_id │ amount │ +│ AccountId32 │ (8 bytes LE) │ (16 bytes LE)│ (16 bytes LE)│ +└──────────────────┴──────────────────┴──────────────┴──────────────┘ + │ + injective_poseidon() + │ + ▼ + leaf_hash (32 bytes) +``` + +> **Why no `from` address?** The ZK circuit proves ownership of received funds. Uniqueness is guaranteed by `(to, transfer_count)` -- each recipient has a monotonically increasing counter. The sender's identity is irrelevant for proving "I received this transfer." + +**Node hash** (128 bytes input): +``` +sort(child[0..3]) → concatenate → bytes_to_felts_compact → poseidon → node_hash + 4 × 32 B 128 B 16 felts 32 B +``` + +Children are sorted before hashing, making the hash order-independent. This eliminates path indices from Merkle proofs -- the verifier just combines current hash with 3 siblings, sorts all 4, and hashes. + +## Data Flow: From Transfer to ZK Proof + +### 1. Transfer Recording + +Every balance transfer on the chain is automatically captured and recorded into the ZK trie via a transaction extension. + +``` + User submits tx (e.g., transfer 500 QTU to Bob) + │ + ▼ + ┌──────────────────────────────────────────────┐ + │ Transaction Execution │ + │ │ + │ pallet_balances::transfer() │ + │ │ │ + │ ├── moves funds │ + │ └── emits Event::Transfer {from, to, amount} + │ │ + └───────────────────────┬───────────────────────┘ + │ + ▼ + ┌──────────────────────────────────────────────┐ + │ WormholeProofRecorderExtension::post_dispatch │ + │ (runs after EVERY transaction automatically) │ + │ │ + │ 1. Scans new events since tx start │ + │ 2. Finds Transfer/Minted/Issued events │ + │ 3. Calls Wormhole::record_transfer() each │ + └───────────────────────┬───────────────────────┘ + │ + ▼ + ┌──────────────────────────────────────────────┐ + │ Wormhole::record_transfer() │ + │ │ + │ 1. Reads TransferCount[bob] → current_count │ + │ 2. Increments TransferCount[bob] │ + │ 3. Calls T::ZkTrie::record_transfer( │ + │ bob, current_count, asset_id, amount) │ + └───────────────────────┬───────────────────────┘ + │ + ▼ + ┌──────────────────────────────────────────────┐ + │ ZkTrie::insert_leaf() │ + │ │ + │ 1. Store leaf data at next index │ + │ 2. Compute leaf_hash = poseidon(leaf_data) │ + │ 3. Update path from leaf to root │ + │ 4. Store new root │ + │ 5. Emit LeafInserted event │ + └──────────────────────────────────────────────┘ +``` + +### 2. Generating a ZK Proof + +To prove "I (Bob) received transfer #3 of 500 QTU," a user (or wallet software) follows this flow: + +``` + ┌──────────────────────────────────────────────┐ + │ Step 1: Query the Merkle proof via RPC │ + │ │ + │ POST zkTrie_getMerkleProof(leaf_index: 42) │ + │ │ + │ Response: │ + │ { │ + │ leaf_index: 42, │ + │ leaf_data: , │ + │ leaf_hash: [u8; 32], │ + │ siblings: [[sibling; 3]; depth], │ + │ root: [u8; 32], │ + │ depth: 3 │ + │ } │ + └───────────────────────┬───────────────────────┘ + │ + ▼ + ┌──────────────────────────────────────────────┐ + │ Step 2: Build the ZK circuit witness │ + │ │ + │ Private inputs (known only to prover): │ + │ - leaf_data (to, transfer_count, │ + │ asset_id, amount) │ + │ - siblings at each tree level │ + │ │ + │ Public inputs (visible to verifier): │ + │ - zk_trie_root (from block digest) │ + │ - claimed amount (or other public claims) │ + └───────────────────────┬───────────────────────┘ + │ + ▼ + ┌──────────────────────────────────────────────┐ + │ Step 3: ZK circuit logic │ + │ │ + │ 1. Recompute leaf_hash from leaf_data │ + │ using Poseidon (efficient in circuit) │ + │ │ + │ 2. Walk up the tree using siblings: │ + │ for each level: │ + │ combine current_hash with 3 siblings │ + │ sort all 4 │ + │ current_hash = poseidon(sorted) │ + │ │ + │ 3. Assert computed_root == public_root │ + │ │ + │ This proves: "a transfer with these exact │ + │ properties exists in the committed tree" │ + │ without revealing the full tree contents. │ + └───────────────────────┬───────────────────────┘ + │ + ▼ + ┌──────────────────────────────────────────────┐ + │ Step 4: Submit proof on-chain │ + │ │ + │ The SNARK proof can be verified by anyone │ + │ against the zk_trie_root in the block digest │ + │ (or in ZkTrie pallet storage). │ + └──────────────────────────────────────────────┘ +``` + +**Why this works even though the ZK trie is "outside" the normal trie:** + +The ZK trie is not outside the state trie -- its storage *lives inside* the state trie as normal pallet storage items (`Leaves`, `Nodes`, `Root`, `Depth`, `LeafCount`). What's "separate" is the **hashing scheme**: the Poseidon Merkle tree structure is an overlay that uses ZK-friendly hashes, while the underlying storage still uses Substrate's Blake2b trie for persistence. + +The RPC node reads ZK trie data from pallet storage (via the Substrate state) and returns the Poseidon Merkle proof. The user never needs to interact with Blake2b storage proofs at all -- the entire proof path uses Poseidon. + +``` + What the RPC returns (all Poseidon) + ────────────────────────────────── + + Block Digest ──── zk_trie_root (Poseidon) + │ + ┌─────────────┼─────────────┐ + │ │ │ + [Poseidon] [Poseidon] [Poseidon] ← siblings (level 2) + │ + ┌─────┼─────┬─────┐ + │ │ │ │ + [Pos] [Pos] [Pos] [Pos] ← siblings (level 1) + │ + leaf_hash = injective_poseidon(to, count, asset_id, amount) + + The ZK circuit only ever sees Poseidon hashes. + Blake2b is invisible to the prover/verifier. +``` + +## Handling Block Reorgs + +### The Problem + +If block N is reverted due to a chain reorganization, any ZK trie leaves inserted during block N must also be reverted. Since the ZK trie is a cumulative data structure (append-only, with each insert changing the root), a naive approach could leave the tree in an inconsistent state. + +### The Solution: Substrate State Management + +Because the ZK trie is **pallet storage**, reorgs are handled automatically by Substrate's state management. There is no extra work needed. + +``` + Block 99 (finalized) + state_root_99 ─── ZkTrie { root: R99, leaf_count: 1000, ... } + │ + ▼ + Block 100 (canonical) + state_root_100 ─── ZkTrie { root: R100, leaf_count: 1005, ... } + │ + ├──── Block 101a (fork A - canonical) + │ state_root_101a ─── ZkTrie { root: R101a, leaf_count: 1012, ... } + │ + └──── Block 101b (fork B - uncle) + state_root_101b ─── ZkTrie { root: R101b, leaf_count: 1010, ... } +``` + +**What happens on reorg (fork B wins):** + +``` + 1. Substrate detects fork B has more cumulative work + 2. Substrate reverts block 101a's state changes + 3. Substrate applies block 101b's state changes + 4. ALL pallet storage (including ZkTrie) atomically reverts to block 100's state + 5. Block 101b's transactions are re-executed against block 100's state + 6. ZkTrie insertions from 101b produce a new root R101b + + Result: ZkTrie is consistent, as if 101a never happened. +``` + +This works because: +- Each block's state is a complete snapshot of all storage (including ZK trie data) +- Substrate's state DB maintains state for non-finalized blocks on all forks +- Reverting a block means switching to the parent state, not "undoing" operations +- The ZK trie root is deterministic: same inputs in same order = same root + +### Finality Considerations + +Quantus uses QPoW consensus with a `MaxReorgDepth` of **180 blocks**. Blocks older than 180 blocks behind the tip are finalized and cannot be reverted. + +``` + ◄────── 180 blocks ──────► + ┌──────────┬────────────────────────────────┬─────────┐ + │ Finalized│ Can be reorged │ Tip │ + │ │ │ │ + │ ZK proofs│ ZK proofs here are valid but │ Latest │ + │ here are │ could change if reorg occurs │ state │ + │ permanent│ │ │ + └──────────┴────────────────────────────────┴─────────┘ +``` + +**Recommendation for ZK proof consumers:** + +| Use Case | Wait for | Why | +|----------|----------|-----| +| Low-value transfers | Best block | Root is very likely final | +| High-value transfers | Finalized block | Root is guaranteed permanent | +| Cross-chain bridges | Finalized block | Must be irreversible | + +The RPC queries (`zkTrie_getState`, `zkTrie_getMerkleProof`) operate against the **best block** by default. For finality-sensitive applications, query at a specific finalized block hash instead. + +### What About Leaf Indices? + +Since the ZK trie is append-only (leaves are never removed), leaf indices are stable within a given fork. However, a reorg can cause the same leaf index to map to different transfer data on different forks. + +After finalization, a leaf index is permanently bound to its data. Before finalization, treat leaf indices as tentative. + +## Storage Layout + +All ZK trie data is stored as standard Substrate pallet storage: + +| Storage Item | Key | Value | Description | +|-------------|-----|-------|-------------| +| `Leaves` | `u64` (leaf index) | `ZkLeaf` | Raw leaf data | +| `Nodes` | `(u8, u64)` (level, index) | `Hash256` | Internal node hashes | +| `LeafCount` | -- | `u64` | Total leaves inserted | +| `Depth` | -- | `u8` | Current tree depth | +| `Root` | -- | `Hash256` | Current Poseidon root | + +Storage keys use `Identity` hasher since leaf indices are sequential (no adversarial key selection). + +## RPC API + +| Method | Parameters | Returns | Description | +|--------|-----------|---------|-------------| +| `zkTrie_getState` | -- | `{root, leaf_count, depth}` | Current tree state | +| `zkTrie_getMerkleProof` | `leaf_index: u64` | `ZkMerkleProofRpc \| null` | Full Merkle proof for a leaf | + +### Example: Query a Merkle Proof + +```json +// Request +{ + "jsonrpc": "2.0", + "method": "zkTrie_getMerkleProof", + "params": [42], + "id": 1 +} + +// Response +{ + "jsonrpc": "2.0", + "result": { + "leaf_index": 42, + "leaf_data": "0x...", + "leaf_hash": "0x...", + "siblings": [ + ["0x...", "0x...", "0x..."], + ["0x...", "0x...", "0x..."] + ], + "root": "0x...", + "depth": 2 + }, + "id": 1 +} +``` + +The `leaf_data` field is SCALE-encoded `ZkLeaf`: +- Bytes 0-31: `to` (AccountId32) +- Bytes 32-39: `transfer_count` (u64 LE) +- Bytes 40-43: `asset_id` (u32, compact-encoded) +- Bytes 44+: `amount` (u128, compact-encoded) From 0b06c6a23a410027d038be7755a4464f80245b22 Mon Sep 17 00:00:00 2001 From: illuzen Date: Sun, 12 Apr 2026 22:01:03 +0800 Subject: [PATCH 07/19] fix header and leaf hash calculation --- Cargo.lock | 14 --------- Cargo.toml | 8 +++++ pallets/zk-trie/src/tree.rs | 60 +++++++++++++++++++++++++++--------- primitives/header/src/lib.rs | 13 ++++++-- 4 files changed, 65 insertions(+), 30 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 756cc5f6..e07460d8 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -8397,8 +8397,6 @@ dependencies = [ [[package]] name = "qp-wormhole-aggregator" version = "1.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c98df8c8a59dca57f896904abd1cd5cd5cb4387b4831e077cfc17aa8f448fffa" dependencies = [ "anyhow", "hex", @@ -8415,8 +8413,6 @@ dependencies = [ [[package]] name = "qp-wormhole-circuit" version = "1.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "62c4c1671504baeefc3bd44ce62c69055b99595b2442eb5968b152ebccd33153" dependencies = [ "anyhow", "hex", @@ -8428,8 +8424,6 @@ dependencies = [ [[package]] name = "qp-wormhole-circuit-builder" version = "1.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2602cb861a190728337d28e660384ad3bb707768260c4e48db50fb60d8717908" dependencies = [ "anyhow", "clap", @@ -8442,8 +8436,6 @@ dependencies = [ [[package]] name = "qp-wormhole-inputs" version = "1.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "aed8a9809079a89ea2a69cd5e3459d88e9a36b0a771d8821cacc50f7c66ef19d" dependencies = [ "anyhow", ] @@ -8451,8 +8443,6 @@ dependencies = [ [[package]] name = "qp-wormhole-prover" version = "1.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fa4a78a88d3d851c6a828e2031c4422f0a44b17c53f8446656fd45dea146a5fd" dependencies = [ "anyhow", "qp-plonky2", @@ -8464,8 +8454,6 @@ dependencies = [ [[package]] name = "qp-wormhole-verifier" version = "1.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cf5d21d7c8c07cfa7bfea14240c63d09fad5c1396b111ab72063dbe07aeae121" dependencies = [ "anyhow", "qp-plonky2-verifier", @@ -8475,8 +8463,6 @@ dependencies = [ [[package]] name = "qp-zk-circuits-common" version = "1.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0756b4c23179e5e4a53cc9ac9ed2e0134124ec40e21f72ec12fe793bc6f6f278" dependencies = [ "anyhow", "hex", diff --git a/Cargo.toml b/Cargo.toml index eb11bc1e..8dfe6f9b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -244,6 +244,14 @@ sc-network-sync = { path = "client/network-sync" } sp-state-machine = { path = "./primitives/state-machine" } sp-trie = { path = "./primitives/trie" } trie-db = { path = "./primitives/trie-db" } +# Use local development versions of qp-zk-circuits crates +qp-zk-circuits-common = { path = "../qp-zk-circuits/common" } +qp-wormhole-circuit = { path = "../qp-zk-circuits/wormhole/circuit" } +qp-wormhole-circuit-builder = { path = "../qp-zk-circuits/wormhole/circuit-builder" } +qp-wormhole-prover = { path = "../qp-zk-circuits/wormhole/prover" } +qp-wormhole-verifier = { path = "../qp-zk-circuits/wormhole/verifier" } +qp-wormhole-inputs = { path = "../qp-zk-circuits/wormhole/inputs" } +qp-wormhole-aggregator = { path = "../qp-zk-circuits/wormhole/aggregator" } [profile.release] opt-level = 3 diff --git a/pallets/zk-trie/src/tree.rs b/pallets/zk-trie/src/tree.rs index 7b6974a3..8669a14b 100644 --- a/pallets/zk-trie/src/tree.rs +++ b/pallets/zk-trie/src/tree.rs @@ -26,32 +26,56 @@ pub fn capacity_at_depth(depth: u8) -> u64 { } } -/// Hash a leaf using injective Poseidon (4 bytes/felt). +/// Quantization factor for amounts in ZK leaves. +/// Amounts are divided by this factor before storing in the leaf hash. +/// This matches the circuit's expectation of 2 decimal places of precision. +/// 10^10 means 1 DEV (10^12 planck) becomes 100 in the leaf. +pub const AMOUNT_SCALE_DOWN_FACTOR: u128 = 10_000_000_000; + +/// Hash a leaf using Poseidon with field element encoding. +/// +/// The encoding matches the ZK circuit's leaf hash computation: +/// - to_account: 4 felts (32 bytes using 8 bytes/felt compact encoding) +/// - transfer_count: 2 felts (u64 split into two 32-bit limbs, high then low) +/// - asset_id: 1 felt (u32 as u64, then to felt via 8 bytes compact) +/// - amount: 1 felt (u32 quantized, as u64, then to felt via 8 bytes compact) +/// Total: 8 felts /// -/// This ensures collision resistance for user-controlled data. +/// This encoding must exactly match `ZkLeafTargets::collect_for_hash()` in the circuit. pub fn hash_leaf(leaf: &ZkLeaf, T::AssetId, T::Balance>) -> Hash256 where AccountIdOf: AsRef<[u8]>, { - // Encode leaf data to bytes - let mut data = Vec::new(); + use qp_poseidon_core::serialization::{bytes_to_felts_compact, u64_to_felts}; + + let mut felts = Vec::with_capacity(8); - // to: account bytes (should be 32 bytes) - data.extend_from_slice(leaf.to.as_ref()); + // to_account: 4 felts (32 bytes -> 4 felts at 8 bytes/felt) + let to_bytes = leaf.to.as_ref(); + debug_assert_eq!(to_bytes.len(), 32, "Account must be 32 bytes"); + felts.extend(bytes_to_felts_compact(to_bytes)); - // transfer_count: 8 bytes LE - data.extend_from_slice(&leaf.transfer_count.to_le_bytes()); + // transfer_count: 2 felts (u64 as two 32-bit limbs, high then low) + felts.extend(u64_to_felts(leaf.transfer_count)); - // asset_id: as u128, 16 bytes LE + // asset_id: 1 felt (u32 -> u64 -> 8 bytes LE -> 1 felt via compact encoding) + // Convert via u128 then truncate to u32 (asset IDs should always fit in u32) let asset_id_u128: u128 = leaf.asset_id.into(); - data.extend_from_slice(&asset_id_u128.to_le_bytes()); + let asset_id_u32 = asset_id_u128 as u32; + debug_assert_eq!(asset_id_u128, asset_id_u32 as u128, "Asset ID must fit in u32"); + felts.extend(bytes_to_felts_compact(&(asset_id_u32 as u64).to_le_bytes())); - // amount: as u128, 16 bytes LE + // amount: 1 felt (u32 quantized -> u64 -> 8 bytes LE -> 1 felt via compact encoding) + // Quantize by dividing by AMOUNT_SCALE_DOWN_FACTOR (10^10) + // This gives 2 decimal places of precision (1 DEV = 100 quantized units) let amount_u128: u128 = leaf.amount.into(); - data.extend_from_slice(&amount_u128.to_le_bytes()); + let amount_quantized = (amount_u128 / AMOUNT_SCALE_DOWN_FACTOR) as u32; + felts.extend(bytes_to_felts_compact(&(amount_quantized as u64).to_le_bytes())); - // Use injective hash (4 bytes/felt) - qp_poseidon_core::hash_bytes(&data) + debug_assert_eq!(felts.len(), 8, "Leaf preimage must be exactly 8 felts"); + + // Hash the felts + qp_poseidon_core::hash_to_bytes(&felts) } /// Hash 4 child hashes into a parent node hash. @@ -202,8 +226,11 @@ where return Err(Error::::LeafNotFound); } + let leaf_hash = get_leaf_hash::(leaf_index); + let mut siblings = Vec::with_capacity(depth as usize); let mut current_index = leaf_index; + let mut current_hash = leaf_hash; for level in 1..=depth { let parent_index = current_index / (ARITY as u64); @@ -229,6 +256,11 @@ where sibling_idx += 1; } + // Compute parent hash for next iteration + let children: [Hash256; ARITY] = + [current_hash, level_siblings[0], level_siblings[1], level_siblings[2]]; + current_hash = hash_node(&children); + siblings.push(level_siblings); current_index = parent_index; } diff --git a/primitives/header/src/lib.rs b/primitives/header/src/lib.rs index e9077c6a..fec53b24 100644 --- a/primitives/header/src/lib.rs +++ b/primitives/header/src/lib.rs @@ -146,6 +146,9 @@ where /// Convenience helper for computing the hash of the header without having /// to import the trait. pub fn hash(&self) -> Hash::Output { + /// Fixed size for digest encoding - must match circuit expectation + const DIGEST_LOGS_SIZE: usize = 110; + let max_encoded_felts = 4 * 3 + 1 + 28; // 3 hash fields (4 felts each) + 1 u32 + 28 felts for injective digest encoding let mut felts = Vec::with_capacity(max_encoded_felts); @@ -169,8 +172,14 @@ where self.extrinsics_root.as_ref().try_into().expect("hash is 32 bytes"), )); - // digest – injective encoding (4 bytes/felt + terminator) - felts.extend(bytes_to_felts(&self.digest.encode())); + // digest – SCALE encode then pad to fixed 110 bytes to match circuit expectation + let digest_encoded = self.digest.encode(); + let mut digest_padded = [0u8; DIGEST_LOGS_SIZE]; + let copy_len = digest_encoded.len().min(DIGEST_LOGS_SIZE); + digest_padded[..copy_len].copy_from_slice(&digest_encoded[..copy_len]); + + // injective encoding (4 bytes/felt + terminator) + felts.extend(bytes_to_felts(&digest_padded)); let poseidon_hash: [u8; 32] = hash_to_bytes(&felts); poseidon_hash.into() From 4a3a770ed33ab76416295eb7fc31efcc1e1a2ea0 Mon Sep 17 00:00:00 2001 From: illuzen Date: Sun, 12 Apr 2026 22:11:35 +0800 Subject: [PATCH 08/19] update comments and arch doc --- docs/zk-trie-architecture.md | 50 ++++++++++++++++++++++-------------- pallets/zk-trie/src/lib.rs | 8 +++--- pallets/zk-trie/src/tree.rs | 7 +++-- 3 files changed, 38 insertions(+), 27 deletions(-) diff --git a/docs/zk-trie-architecture.md b/docs/zk-trie-architecture.md index 6048f6ae..980c9ace 100644 --- a/docs/zk-trie-architecture.md +++ b/docs/zk-trie-architecture.md @@ -69,26 +69,36 @@ The tree grows dynamically -- when the 5th leaf arrives, depth increases from 1 ### Hashing Strategy -Two different Poseidon modes are used, optimized for their context: +| Layer | Encoding | Felts | Injective? | +|--------------------|---------------------------|-------|------------| +| **Leaves** | Structured (see below) | 8 | Yes (all values ≤ 32 bits except account) | +| **Internal nodes** | 8 bytes/felt compact | 16 | No (hash outputs may exceed field modulus) | -| Layer | Mode | Bytes/Felt | Why | -|-----------------|-------------------------|------------|--------------------------------------------------------| -| **Leaves** | Injective Poseidon | 4 | Collision resistance for user-controlled data | -| **Internal nodes** | Non-injective Poseidon | 8 | Efficiency -- inputs are fixed-size hashes, not user data | - -**Leaf data** (72 bytes): +**Leaf encoding** (8 field elements): ``` -┌──────────────────┬──────────────────┬──────────────┬──────────────┐ -│ to (32 bytes) │ transfer_count │ asset_id │ amount │ -│ AccountId32 │ (8 bytes LE) │ (16 bytes LE)│ (16 bytes LE)│ -└──────────────────┴──────────────────┴──────────────┴──────────────┘ - │ - injective_poseidon() - │ - ▼ - leaf_hash (32 bytes) +┌─────────────────────┬──────────────────┬───────────┬─────────────────┐ +│ to_account │ transfer_count │ asset_id │ amount │ +│ (4 felts) │ (2 felts) │ (1 felt) │ (1 felt) │ +│ 32 bytes → │ u64 as high/low │ u32 │ u32 quantized │ +│ 8 bytes/felt │ 32-bit limbs │ │ (raw / 10^10) │ +└─────────────────────┴──────────────────┴───────────┴─────────────────┘ + │ + poseidon(8 felts) + │ + ▼ + leaf_hash (32 bytes) ``` +The leaf encoding is effectively injective because: +- `transfer_count`, `asset_id`, `amount` are all ≤ 32 bits, well under the Goldilocks field modulus (~2^64) +- `to_account` uses 8 bytes/felt which could theoretically wrap, but AccountId32 values in practice don't collide + +**SCALE-encoded leaf data** (60 bytes on-chain storage): +- `to`: 32 bytes (AccountId32) +- `transfer_count`: 8 bytes (u64 LE) +- `asset_id`: 4 bytes (u32 LE) +- `amount`: 16 bytes (u128 LE, **raw planck value** - full precision stored) + > **Why no `from` address?** The ZK circuit proves ownership of received funds. Uniqueness is guaranteed by `(to, transfer_count)` -- each recipient has a monotonically increasing counter. The sender's identity is irrelevant for proving "I received this transfer." **Node hash** (128 bytes input): @@ -367,8 +377,10 @@ Storage keys use `Identity` hasher since leaf indices are sequential (no adversa } ``` -The `leaf_data` field is SCALE-encoded `ZkLeaf`: +The `leaf_data` field is SCALE-encoded `ZkLeaf` (60 bytes total): - Bytes 0-31: `to` (AccountId32) - Bytes 32-39: `transfer_count` (u64 LE) -- Bytes 40-43: `asset_id` (u32, compact-encoded) -- Bytes 44+: `amount` (u128, compact-encoded) +- Bytes 40-43: `asset_id` (u32 LE) +- Bytes 44-59: `amount` (u128 LE, raw planck value) + +Note: The amount stored on-chain is the raw planck value. When hashing for the ZK circuit, amounts are **quantized** by dividing by 10^10 to fit in a single field element with 2 decimal places of precision. diff --git a/pallets/zk-trie/src/lib.rs b/pallets/zk-trie/src/lib.rs index 58ecb1d0..d9e72f5b 100644 --- a/pallets/zk-trie/src/lib.rs +++ b/pallets/zk-trie/src/lib.rs @@ -6,8 +6,8 @@ //! //! This pallet provides a separate Merkle tree structure optimized for ZK circuits: //! - 4-ary tree (4 children per node) for optimal ZK circuit efficiency -//! - Leaves hashed with injective Poseidon (4 bytes/felt) for collision resistance -//! - Internal nodes hashed with non-injective Poseidon (8 bytes/felt) for efficiency +//! - Leaves hashed as 8 field elements (injective: values are ≤32 bits) +//! - Internal nodes hashed as 16 field elements (8 bytes/felt compact encoding) //! - Tree root published in block digest for ZK verification //! //! ## Tree Structure @@ -21,8 +21,8 @@ //! ``` //! //! Leaf data: (to_account, transfer_count, asset_id, amount) -//! Leaf hash: injective_poseidon(leaf_data) -//! Node hash: poseidon(child0 || child1 || child2 || child3) +//! Leaf hash: poseidon(8 felts from leaf encoding) +//! Node hash: poseidon(sorted children concatenated → 16 felts) #![cfg_attr(not(feature = "std"), no_std)] diff --git a/pallets/zk-trie/src/tree.rs b/pallets/zk-trie/src/tree.rs index 8669a14b..085bf5e8 100644 --- a/pallets/zk-trie/src/tree.rs +++ b/pallets/zk-trie/src/tree.rs @@ -1,8 +1,8 @@ //! 4-ary Poseidon Merkle tree implementation. //! //! This module provides the core tree operations: -//! - Leaf hashing (injective, 4 bytes/felt) -//! - Node hashing (non-injective, 8 bytes/felt) +//! - Leaf hashing (8 felts, injective for ≤32-bit values) +//! - Node hashing (16 felts, 8 bytes/felt compact encoding) //! - Path updates on insert //! - Proof generation and verification //! - Tree growth when capacity is exceeded @@ -84,8 +84,7 @@ where /// in Merkle proofs. This makes verification simpler in ZK circuits - the /// verifier just needs the siblings, sorts all 4 children, and hashes. /// -/// Uses non-injective Poseidon (8 bytes/felt) since internal nodes -/// only contain fixed-size hash outputs, not user-controlled data. +/// Uses compact Poseidon encoding (8 bytes/felt) - 128 bytes → 16 felts. pub fn hash_node(children: &[Hash256; ARITY]) -> Hash256 { // Sort children to make hash order-independent let mut sorted = *children; From 1c04ff72a6ab320bae6b53452989f358f469e559 Mon Sep 17 00:00:00 2001 From: illuzen Date: Mon, 13 Apr 2026 10:57:38 +0800 Subject: [PATCH 09/19] use blake2 for storage_root and extrinsics_root --- Cargo.toml | 6 ++-- pallets/zk-trie/Cargo.toml | 2 +- primitives/header/src/lib.rs | 67 +++++++++++++++++++++++++++--------- runtime/src/configs/mod.rs | 4 +-- runtime/src/lib.rs | 15 ++++---- 5 files changed, 65 insertions(+), 29 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 8dfe6f9b..0bcce315 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -245,13 +245,13 @@ sp-state-machine = { path = "./primitives/state-machine" } sp-trie = { path = "./primitives/trie" } trie-db = { path = "./primitives/trie-db" } # Use local development versions of qp-zk-circuits crates -qp-zk-circuits-common = { path = "../qp-zk-circuits/common" } +qp-wormhole-aggregator = { path = "../qp-zk-circuits/wormhole/aggregator" } qp-wormhole-circuit = { path = "../qp-zk-circuits/wormhole/circuit" } qp-wormhole-circuit-builder = { path = "../qp-zk-circuits/wormhole/circuit-builder" } +qp-wormhole-inputs = { path = "../qp-zk-circuits/wormhole/inputs" } qp-wormhole-prover = { path = "../qp-zk-circuits/wormhole/prover" } qp-wormhole-verifier = { path = "../qp-zk-circuits/wormhole/verifier" } -qp-wormhole-inputs = { path = "../qp-zk-circuits/wormhole/inputs" } -qp-wormhole-aggregator = { path = "../qp-zk-circuits/wormhole/aggregator" } +qp-zk-circuits-common = { path = "../qp-zk-circuits/common" } [profile.release] opt-level = 3 diff --git a/pallets/zk-trie/Cargo.toml b/pallets/zk-trie/Cargo.toml index 8ab087ba..249e4182 100644 --- a/pallets/zk-trie/Cargo.toml +++ b/pallets/zk-trie/Cargo.toml @@ -1,12 +1,12 @@ [package] authors.workspace = true +description = "4-ary Poseidon Merkle tree for ZK transfer proofs" edition.workspace = true homepage.workspace = true license.workspace = true name = "pallet-zk-trie" repository.workspace = true version = "0.1.0" -description = "4-ary Poseidon Merkle tree for ZK transfer proofs" [dependencies] codec = { workspace = true, default-features = false, features = ["derive"] } diff --git a/primitives/header/src/lib.rs b/primitives/header/src/lib.rs index fec53b24..23864886 100644 --- a/primitives/header/src/lib.rs +++ b/primitives/header/src/lib.rs @@ -1,5 +1,14 @@ //! Fork of sp-runtime's generic implementation of a block header. -//! We override the hashing function to ensure a felt aligned pre-image for the block hash. +//! +//! Key differences from the standard Substrate header: +//! - **Block hash**: Computed with Poseidon (via the `Hash` type parameter) for ZK circuit +//! compatibility +//! - **State trie**: Uses Blake2 (hardcoded as `Hashing` type) for efficient native execution +//! +//! This means `HashingFor` returns `BlakeTwo256`, which is used for: +//! - State trie merkle root computation +//! - Extrinsics root computation +//! - Storage proof verification #![cfg_attr(not(feature = "std"), no_std)] @@ -24,13 +33,16 @@ use alloc::vec::Vec; #[cfg(feature = "serde")] use serde::{Deserialize, Serialize}; -/// Custom block header that hashes itself with Poseidon over Goldilocks field elements. +/// Custom block header with separate hashers for block hash and state trie. +/// +/// - `Hash`: Used for block hash computation (Poseidon for ZK compatibility) +/// - `StateHash`: Used for state trie / extrinsics root via `Header::Hashing` trait #[derive(Encode, Decode, PartialEq, Eq, Clone, RuntimeDebug, TypeInfo, DecodeWithMemTracking)] -#[scale_info(skip_type_params(Hash))] +#[scale_info(skip_type_params(Hash, StateHash))] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))] #[cfg_attr(feature = "serde", serde(deny_unknown_fields))] -pub struct Header +pub struct Header where Number: Copy + Into + TryFrom, { @@ -43,6 +55,9 @@ where pub state_root: Hash::Output, pub extrinsics_root: Hash::Output, pub digest: Digest, + #[codec(skip)] + #[cfg_attr(feature = "serde", serde(skip))] + _marker: core::marker::PhantomData, } #[cfg(feature = "serde")] @@ -66,15 +81,16 @@ where TryFrom::try_from(u256).map_err(|_| serde::de::Error::custom("Try from failed")) } -impl sp_runtime::traits::Header for Header +impl sp_runtime::traits::Header for Header where Number: BlockNumber, - Hash: HashT, - Hash::Output: From<[u8; 32]>, + Hash: HashT, + StateHash: HashT, { type Number = Number; - type Hash = ::Output; - type Hashing = Hash; + type Hash = sp_core::H256; + /// State trie hasher - configurable, defaults to BlakeTwo256. + type Hashing = StateHash; fn new( number: Self::Number, @@ -83,7 +99,14 @@ where parent_hash: Self::Hash, digest: Digest, ) -> Self { - Self { number, extrinsics_root, state_root, parent_hash, digest } + Self { + number, + extrinsics_root, + state_root, + parent_hash, + digest, + _marker: core::marker::PhantomData, + } } fn number(&self) -> &Self::Number { &self.number @@ -130,7 +153,7 @@ where } } -impl Header +impl Header where Number: Member + core::hash::Hash @@ -142,6 +165,7 @@ where + TryFrom, Hash: HashT, Hash::Output: From<[u8; 32]>, + StateHash: HashT, { /// Convenience helper for computing the hash of the header without having /// to import the trait. @@ -225,12 +249,13 @@ mod tests { #[test] fn ensure_format_is_unchanged() { - let header = Header:: { + let header = Header:: { parent_hash: BlakeTwo256::hash(b"1"), number: 2, state_root: BlakeTwo256::hash(b"3"), extrinsics_root: BlakeTwo256::hash(b"4"), digest: Digest { logs: vec![sp_runtime::generic::DigestItem::Other(b"6".to_vec())] }, + _marker: core::marker::PhantomData, }; let header_encoded = header.encode(); @@ -245,14 +270,18 @@ mod tests { 12, 73, 104, 49, 200, 204, 31, 143, 13, 4, 0, 4, 54 ], ); - assert_eq!(Header::::decode(&mut &header_encoded[..]).unwrap(), header); + assert_eq!( + Header::::decode(&mut &header_encoded[..]).unwrap(), + header + ); - let header = Header:: { + let header = Header:: { parent_hash: BlakeTwo256::hash(b"1000"), number: 2000, state_root: BlakeTwo256::hash(b"3000"), extrinsics_root: BlakeTwo256::hash(b"4000"), digest: Digest { logs: vec![sp_runtime::generic::DigestItem::Other(b"5000".to_vec())] }, + _marker: core::marker::PhantomData, }; let header_encoded = header.encode(); @@ -267,12 +296,15 @@ mod tests { 44, 111, 126, 54, 34, 155, 220, 253, 124, 4, 0, 16, 53, 48, 48, 48 ], ); - assert_eq!(Header::::decode(&mut &header_encoded[..]).unwrap(), header); + assert_eq!( + Header::::decode(&mut &header_encoded[..]).unwrap(), + header + ); } fn hash_header(x: &[u8]) -> [u8; 32] { let mut y = x; - if let Ok(header) = Header::::decode(&mut y) { + if let Ok(header) = Header::::decode(&mut y) { // Only treat this as a header if we consumed the entire input. if y.is_empty() { let max_encoded_felts = 4 * 3 + 1 + 28; // 3 hash fields (4 felts each) + 1 u32 + 28 felts @@ -333,7 +365,7 @@ mod tests { ), ], }; - let header = Header:: { + let header = Header:: { parent_hash: H256::from_slice( hex::decode(parent_hash).expect("valid hex parent hash").as_slice(), ), @@ -345,6 +377,7 @@ mod tests { hex::decode(extrinsics_root).expect("valid hex extrinsics root").as_slice(), ), digest, + _marker: core::marker::PhantomData, }; let encoded = header.encode(); diff --git a/runtime/src/configs/mod.rs b/runtime/src/configs/mod.rs index 93e00f81..cc069771 100644 --- a/runtime/src/configs/mod.rs +++ b/runtime/src/configs/mod.rs @@ -104,8 +104,8 @@ impl frame_system::Config for Runtime { type Nonce = Nonce; /// The type for hashing blocks and tries. type Hash = Hash; - /// The hashing algorithm for application-level operations (preimages, tx IDs, etc). - /// Storage trie and extrinsics root use the header's hasher (PoseidonHasher) instead. + /// The hashing algorithm used for state trie and extrinsics root. + /// This matches the `StateHash` parameter in qp_header::Header. type Hashing = BlakeTwo256; /// Maximum number of block number to block hash mappings to keep (oldest pruned first). type BlockHashCount = BlockHashCount; diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs index b0983e75..2292ec80 100644 --- a/runtime/src/lib.rs +++ b/runtime/src/lib.rs @@ -19,6 +19,7 @@ use sp_runtime::{ MultiAddress, }; use sp_version::RuntimeVersion; +use sp_runtime::traits::BlakeTwo256; pub use frame_system::Call as SystemCall; pub use pallet_balances::Call as BalancesCall; @@ -45,11 +46,11 @@ pub mod opaque { // For whatever reason, changing this causes the block hash and // the storage root to be computed with poseidon, but not the extrinsics root. - // For the wormhole proofs, we only need the storage root to be calculated with poseidon. - // However, some internal checks in dev build expect extrinsics_root to be computed with same - // Hash function, so we change the configs/mod.rs Hashing type as well - // Opaque block header type. - pub type Header = qp_header::Header; + // Block header with separate hashers: + // - PoseidonHasher: for block hash (ZK circuit compatible) + // - BlakeTwo256: for state trie / extrinsics root (efficient native execution) + pub type Header = + qp_header::Header; // Opaque block type. pub type Block = generic::Block; @@ -131,7 +132,9 @@ pub type BlockNumber = u32; pub type Address = MultiAddress; /// Block header type as expected by this runtime. -pub type Header = qp_header::Header; +/// - PoseidonHasher: for block hash (ZK circuit compatible) +/// - BlakeTwo256: for state trie / extrinsics root (efficient native execution) +pub type Header = qp_header::Header; /// Block type as expected by this runtime. pub type Block = generic::Block; From 95c8fdfed384ad83ada32f1c31b254c63b28e024 Mon Sep 17 00:00:00 2001 From: illuzen Date: Mon, 13 Apr 2026 11:35:06 +0800 Subject: [PATCH 10/19] give zk_trie dedicated slot in header --- Cargo.lock | 1 + pallets/frame-system/Cargo.toml | 2 + .../src/extensions/check_weight.rs | 16 ++-- pallets/frame-system/src/lib.rs | 47 ++++++++-- pallets/zk-trie/src/lib.rs | 7 +- primitives/header/src/lib.rs | 93 ++++++++++++++++++- 6 files changed, 147 insertions(+), 19 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index e07460d8..106099c9 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3367,6 +3367,7 @@ dependencies = [ "frame-support", "log", "parity-scale-codec", + "qp-header", "scale-info", "serde", "sp-core", diff --git a/pallets/frame-system/Cargo.toml b/pallets/frame-system/Cargo.toml index deee20f3..3ac490ee 100644 --- a/pallets/frame-system/Cargo.toml +++ b/pallets/frame-system/Cargo.toml @@ -27,6 +27,7 @@ codec = { workspace = true, default-features = false, features = ["derive"] } docify = { workspace = true } frame-support = { version = "45.0.0", default-features = false } log = { workspace = true, default-features = false } +qp-header = { path = "../../primitives/header", default-features = false, features = ["serde"] } scale-info = { version = "2.11.6", default-features = false, features = ["derive", "serde"] } serde = { workspace = true, default-features = false, features = ["alloc", "derive"] } sp-core = { workspace = true, default-features = false, features = ["serde"] } @@ -51,6 +52,7 @@ std = [ "codec/std", "frame-support/std", "log/std", + "qp-header/std", "scale-info/std", "serde/std", "sp-core/std", diff --git a/pallets/frame-system/src/extensions/check_weight.rs b/pallets/frame-system/src/extensions/check_weight.rs index 16522611..5f2eda74 100644 --- a/pallets/frame-system/src/extensions/check_weight.rs +++ b/pallets/frame-system/src/extensions/check_weight.rs @@ -366,8 +366,8 @@ mod tests { fn normal_extrinsic_limited_by_maximum_extrinsic_weight() { new_test_ext().execute_with(|| { let max = DispatchInfo { - call_weight: block_weights().get(DispatchClass::Normal).max_extrinsic.unwrap() + - Weight::from_parts(1, 0), + call_weight: block_weights().get(DispatchClass::Normal).max_extrinsic.unwrap() + + Weight::from_parts(1, 0), class: DispatchClass::Normal, ..Default::default() }; @@ -710,9 +710,9 @@ mod tests { .0; assert_eq!( BlockWeight::::get().total(), - info.total_weight() + - Weight::from_parts(128, 0) + - block_weights().get(DispatchClass::Normal).base_extrinsic, + info.total_weight() + + Weight::from_parts(128, 0) + + block_weights().get(DispatchClass::Normal).base_extrinsic, ); assert_ok!(CheckWeight::::post_dispatch_details( @@ -724,9 +724,9 @@ mod tests { )); assert_eq!( BlockWeight::::get().total(), - info.total_weight() + - Weight::from_parts(128, 0) + - block_weights().get(DispatchClass::Normal).base_extrinsic, + info.total_weight() + + Weight::from_parts(128, 0) + + block_weights().get(DispatchClass::Normal).base_extrinsic, ); }) } diff --git a/pallets/frame-system/src/lib.rs b/pallets/frame-system/src/lib.rs index fc87aa87..22a01898 100644 --- a/pallets/frame-system/src/lib.rs +++ b/pallets/frame-system/src/lib.rs @@ -102,6 +102,7 @@ extern crate alloc; use alloc::{borrow::Cow, boxed::Box, vec, vec::Vec}; use core::{fmt::Debug, marker::PhantomData}; use pallet_prelude::{BlockNumberFor, HeaderFor}; +use qp_header::ZkTrieRootProvider; #[cfg(feature = "std")] use serde::Serialize; use sp_io::hashing::blake2_256; @@ -574,6 +575,7 @@ pub mod pallet { + core::hash::Hash + AsRef<[u8]> + AsMut<[u8]> + + From<[u8; 32]> + MaxEncodedLen; /// The hashing system (algorithm) being used in the runtime (e.g. Blake2). @@ -598,8 +600,16 @@ pub mod pallet { /// The Block type used by the runtime. This is used by `construct_runtime` to retrieve the /// extrinsics or other block specific data as needed. + /// + /// The header must implement `ZkTrieRootProvider` to support setting the ZK trie root + /// during block finalization. #[pallet::no_default] - type Block: Parameter + Member + traits::Block; + type Block: Parameter + + Member + + traits::Block< + Hash = Self::Hash, + Header: qp_header::ZkTrieRootProvider, + >; /// Maximum number of block number to block hash mappings to keep (oldest pruned first). #[pallet::constant] @@ -887,8 +897,9 @@ pub mod pallet { match Self::can_set_code(&code, res.check_version) { CanSetCodeResult::Ok => {}, - CanSetCodeResult::MultiBlockMigrationsOngoing => - return Err(Error::::MultiBlockMigrationsOngoing.into()), + CanSetCodeResult::MultiBlockMigrationsOngoing => { + return Err(Error::::MultiBlockMigrationsOngoing.into()) + }, CanSetCodeResult::InvalidVersion(error) => { // The upgrade is invalid and there is no benefit in trying to apply this again. Self::deposit_event(Event::RejectedInvalidAuthorizedUpgrade { @@ -1041,6 +1052,16 @@ pub mod pallet { #[pallet::getter(fn digest)] pub(super) type Digest = StorageValue<_, generic::Digest, ValueQuery>; + /// ZK trie root for the current block. + /// + /// Set by pallet-zk-trie during block finalization. This is included in the + /// block header as a dedicated field (not in digest) to ensure a fixed offset + /// for ZK circuit verification. + #[pallet::storage] + #[pallet::whitelist_storage] + #[pallet::getter(fn zk_trie_root)] + pub(super) type ZkTrieRoot = StorageValue<_, T::Hash, ValueQuery>; + /// Events deposited for the current block. /// /// NOTE: The item is unbound and should therefore never be read on chain. @@ -1549,8 +1570,9 @@ impl CanSetCodeResult { pub fn into_result(self) -> Result<(), DispatchError> { match self { Self::Ok => Ok(()), - Self::MultiBlockMigrationsOngoing => - Err(Error::::MultiBlockMigrationsOngoing.into()), + Self::MultiBlockMigrationsOngoing => { + Err(Error::::MultiBlockMigrationsOngoing.into()) + }, Self::InvalidVersion(err) => Err(err.into()), } } @@ -2049,7 +2071,12 @@ impl Pallet { let storage_root = T::Hash::decode(&mut &sp_io::storage::root(version)[..]) .expect("Node is configured to use the same hash; qed"); - HeaderFor::::new(number, extrinsics_root, storage_root, parent_hash, digest) + let zk_trie_root = >::get(); + + let mut header = + HeaderFor::::new(number, extrinsics_root, storage_root, parent_hash, digest); + header.set_zk_trie_root(zk_trie_root); + header } /// Deposits a log and ensures it matches the block's log data. @@ -2057,6 +2084,14 @@ impl Pallet { >::append(item); } + /// Set the ZK trie root for the current block. + /// + /// Called by pallet-zk-trie during `on_finalize`. The root is included in + /// the block header as a dedicated field for ZK circuit verification. + pub fn set_zk_trie_root(root: T::Hash) { + >::put(root); + } + /// Get the basic externalities for this pallet, useful for tests. #[cfg(any(feature = "std", test))] pub fn externalities() -> TestExternalities { diff --git a/pallets/zk-trie/src/lib.rs b/pallets/zk-trie/src/lib.rs index d9e72f5b..96e59b3a 100644 --- a/pallets/zk-trie/src/lib.rs +++ b/pallets/zk-trie/src/lib.rs @@ -167,10 +167,9 @@ pub mod pallet { #[pallet::hooks] impl Hooks> for Pallet { fn on_finalize(_n: BlockNumberFor) { - // Add ZkRoot to digest - let root = Root::::get(); - let item = sp_runtime::generic::DigestItem::Other(root.to_vec()); - >::deposit_log(item); + // Set ZK Merkle root in frame_system for inclusion in block header + let root: Hash256 = Root::::get(); + >::set_zk_trie_root(root.into()); } } diff --git a/primitives/header/src/lib.rs b/primitives/header/src/lib.rs index 23864886..a880d71f 100644 --- a/primitives/header/src/lib.rs +++ b/primitives/header/src/lib.rs @@ -33,15 +33,40 @@ use alloc::vec::Vec; #[cfg(feature = "serde")] use serde::{Deserialize, Serialize}; +/// Extension trait for headers that support ZK trie root. +/// +/// This trait allows frame_system to set the ZK trie root on headers +/// without knowing the concrete header type. +pub trait ZkTrieRootProvider { + /// The hash type used for the ZK trie root. + type Hash; + + /// Set the ZK trie root. + fn set_zk_trie_root(&mut self, root: Self::Hash); + + /// Get the ZK trie root. + fn zk_trie_root(&self) -> &Self::Hash; +} + /// Custom block header with separate hashers for block hash and state trie. /// /// - `Hash`: Used for block hash computation (Poseidon for ZK compatibility) /// - `StateHash`: Used for state trie / extrinsics root via `Header::Hashing` trait +/// +/// ## Field Ordering +/// +/// The `zk_trie_root` field is intentionally placed **before** `digest` to ensure +/// a fixed offset in the header preimage. This prevents miners from manipulating +/// the digest to shift the ZK root's position in the felt encoding. #[derive(Encode, Decode, PartialEq, Eq, Clone, RuntimeDebug, TypeInfo, DecodeWithMemTracking)] #[scale_info(skip_type_params(Hash, StateHash))] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))] #[cfg_attr(feature = "serde", serde(deny_unknown_fields))] +#[cfg_attr( + feature = "serde", + serde(bound = "Hash::Output: Serialize + serde::de::DeserializeOwned") +)] pub struct Header where Number: Copy + Into + TryFrom, @@ -54,6 +79,11 @@ where pub number: Number, pub state_root: Hash::Output, pub extrinsics_root: Hash::Output, + /// Root of the ZK Merkle trie (4-ary Poseidon tree). + /// + /// This is placed before `digest` to ensure a fixed offset in the header + /// preimage for ZK circuit verification. + pub zk_trie_root: Hash::Output, pub digest: Digest, #[codec(skip)] #[cfg_attr(feature = "serde", serde(skip))] @@ -104,6 +134,8 @@ where extrinsics_root, state_root, parent_hash, + // Initialize with zero; pallet-zk-trie will set the actual root + zk_trie_root: sp_core::H256::zero(), digest, _marker: core::marker::PhantomData, } @@ -173,7 +205,8 @@ where /// Fixed size for digest encoding - must match circuit expectation const DIGEST_LOGS_SIZE: usize = 110; - let max_encoded_felts = 4 * 3 + 1 + 28; // 3 hash fields (4 felts each) + 1 u32 + 28 felts for injective digest encoding + // 4 hash fields (4 felts each) + 1 u32 + 28 felts for injective digest encoding + let max_encoded_felts = 4 * 4 + 1 + 28; let mut felts = Vec::with_capacity(max_encoded_felts); // parent_hash : 32 bytes → 4 felts (8 bytes/felt for hash outputs) @@ -196,6 +229,12 @@ where self.extrinsics_root.as_ref().try_into().expect("hash is 32 bytes"), )); + // zk_trie_root : 32 bytes → 4 felts (8 bytes/felt for hash outputs) + // Placed before digest to ensure fixed offset regardless of digest content + felts.extend(bytes_to_digest::( + self.zk_trie_root.as_ref().try_into().expect("hash is 32 bytes"), + )); + // digest – SCALE encode then pad to fixed 110 bytes to match circuit expectation let digest_encoded = self.digest.encode(); let mut digest_padded = [0u8; DIGEST_LOGS_SIZE]; @@ -208,6 +247,58 @@ where let poseidon_hash: [u8; 32] = hash_to_bytes(&felts); poseidon_hash.into() } + + /// Create a new header with all fields including zk_trie_root. + /// + /// This is the preferred constructor when you have the ZK trie root available. + /// Use this instead of `Header::new` + `set_zk_trie_root`. + pub fn new_with_zk_root( + number: Number, + extrinsics_root: Hash::Output, + state_root: Hash::Output, + parent_hash: Hash::Output, + zk_trie_root: Hash::Output, + digest: Digest, + ) -> Self { + Self { + parent_hash, + number, + state_root, + extrinsics_root, + zk_trie_root, + digest, + _marker: core::marker::PhantomData, + } + } + + /// Get the ZK trie root. + pub fn zk_trie_root(&self) -> &Hash::Output { + &self.zk_trie_root + } + + /// Set the ZK trie root. + /// + /// Called by pallet-zk-trie during block finalization. + pub fn set_zk_trie_root(&mut self, root: Hash::Output) { + self.zk_trie_root = root; + } +} + +impl ZkTrieRootProvider for Header +where + Number: Copy + Into + TryFrom, + Hash: HashT, + StateHash: HashT, +{ + type Hash = Hash::Output; + + fn set_zk_trie_root(&mut self, root: Self::Hash) { + self.zk_trie_root = root; + } + + fn zk_trie_root(&self) -> &Self::Hash { + &self.zk_trie_root + } } #[cfg(test)] From 1bb13f604ab164fe86f6c9489a138703446b290c Mon Sep 17 00:00:00 2001 From: illuzen Date: Mon, 13 Apr 2026 12:06:36 +0800 Subject: [PATCH 11/19] trie -> tree --- Cargo.lock | 8 +- Cargo.toml | 4 +- node/Cargo.toml | 4 +- node/src/main.rs | 2 +- node/src/rpc.rs | 6 +- node/src/{zktrie_rpc.rs => zktree_rpc.rs} | 42 ++--- .../src/extensions/check_weight.rs | 16 +- pallets/frame-system/src/lib.rs | 36 ++--- pallets/wormhole/Cargo.toml | 4 +- pallets/wormhole/src/lib.rs | 18 +-- pallets/wormhole/src/mock.rs | 2 +- pallets/{zk-trie => zk-tree}/Cargo.toml | 2 +- pallets/{zk-trie => zk-tree}/src/lib.rs | 26 +-- pallets/{zk-trie => zk-tree}/src/tests.rs | 148 +++++++++--------- pallets/{zk-trie => zk-tree}/src/tree.rs | 0 primitives/header/src/lib.rs | 64 ++++---- runtime/Cargo.toml | 4 +- runtime/src/apis.rs | 26 +-- runtime/src/configs/mod.rs | 6 +- runtime/src/lib.rs | 8 +- 20 files changed, 211 insertions(+), 215 deletions(-) rename node/src/{zktrie_rpc.rs => zktree_rpc.rs} (69%) rename pallets/{zk-trie => zk-tree}/Cargo.toml (97%) rename pallets/{zk-trie => zk-tree}/src/lib.rs (93%) rename pallets/{zk-trie => zk-tree}/src/tests.rs (74%) rename pallets/{zk-trie => zk-tree}/src/tree.rs (100%) diff --git a/Cargo.lock b/Cargo.lock index 106099c9..3dbe0640 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -6927,7 +6927,7 @@ dependencies = [ "log", "pallet-assets", "pallet-balances", - "pallet-zk-trie", + "pallet-zk-tree", "parity-scale-codec", "qp-dilithium-crypto", "qp-header", @@ -6950,7 +6950,7 @@ dependencies = [ ] [[package]] -name = "pallet-zk-trie" +name = "pallet-zk-tree" version = "0.1.0" dependencies = [ "frame-support", @@ -8527,7 +8527,7 @@ dependencies = [ "pallet-transaction-payment", "pallet-transaction-payment-rpc", "pallet-utility", - "pallet-zk-trie", + "pallet-zk-tree", "parity-scale-codec", "prometheus", "qp-dilithium-crypto", @@ -8608,7 +8608,7 @@ dependencies = [ "pallet-treasury", "pallet-utility", "pallet-wormhole", - "pallet-zk-trie", + "pallet-zk-tree", "parity-scale-codec", "primitive-types 0.13.1", "qp-dilithium-crypto", diff --git a/Cargo.toml b/Cargo.toml index 0bcce315..421023d9 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -21,7 +21,7 @@ members = [ "pallets/scheduler", "pallets/treasury", "pallets/wormhole", - "pallets/zk-trie", + "pallets/zk-tree", "primitives/consensus/qpow", "primitives/dilithium-crypto", "primitives/header", @@ -140,7 +140,7 @@ pallet-qpow = { path = "./pallets/qpow", default-features = false } pallet-reversible-transfers = { path = "./pallets/reversible-transfers", default-features = false } pallet-scheduler = { path = "./pallets/scheduler", default-features = false } pallet-wormhole = { path = "./pallets/wormhole", default-features = false } -pallet-zk-trie = { path = "./pallets/zk-trie", default-features = false } +pallet-zk-tree = { path = "./pallets/zk-tree", default-features = false } qp-dilithium-crypto = { path = "./primitives/dilithium-crypto", version = "0.3.1", default-features = false } qp-header = { path = "./primitives/header", default-features = false } qp-scheduler = { path = "./primitives/scheduler", default-features = false } diff --git a/node/Cargo.toml b/node/Cargo.toml index 33106fed..20a5f87a 100644 --- a/node/Cargo.toml +++ b/node/Cargo.toml @@ -36,8 +36,8 @@ pallet-transaction-payment-rpc.default-features = true pallet-transaction-payment-rpc.workspace = true pallet-utility.default-features = true pallet-utility.workspace = true -pallet-zk-trie.default-features = true -pallet-zk-trie.workspace = true +pallet-zk-tree.default-features = true +pallet-zk-tree.workspace = true prometheus.workspace = true qp-dilithium-crypto = { workspace = true } qp-poseidon.workspace = true diff --git a/node/src/main.rs b/node/src/main.rs index 5b70bdaa..6e6c6395 100644 --- a/node/src/main.rs +++ b/node/src/main.rs @@ -13,7 +13,7 @@ mod service; #[cfg(test)] mod tests; mod txwatch; -mod zktrie_rpc; +mod zktree_rpc; #[allow(clippy::result_large_err)] fn main() -> sc_cli::Result<()> { diff --git a/node/src/rpc.rs b/node/src/rpc.rs index 29ebaea1..5669b9aa 100644 --- a/node/src/rpc.rs +++ b/node/src/rpc.rs @@ -111,13 +111,13 @@ where C::Api: substrate_frame_rpc_system::AccountNonceApi, C::Api: pallet_transaction_payment_rpc::TransactionPaymentRuntimeApi, C::Api: sp_consensus_qpow::QPoWApi, - C::Api: pallet_zk_trie::ZkTrieApi, + C::Api: pallet_zk_tree::ZkTreeApi, C::Api: BlockBuilder, P: TransactionPool + 'static, { use crate::{ txwatch::{TxWatch, TxWatchApiServer}, - zktrie_rpc::{ZkTrie, ZkTrieApiServer}, + zktree_rpc::{ZkTree, ZkTreeApiServer}, }; use pallet_transaction_payment_rpc::{TransactionPayment, TransactionPaymentApiServer}; use substrate_frame_rpc_system::{System, SystemApiServer}; @@ -129,7 +129,7 @@ where module.merge(TransactionPayment::new(client.clone()).into_rpc())?; module.merge(Peer::new(network).into_rpc())?; module.merge(TxWatch::new(pool).into_rpc())?; - module.merge(ZkTrie::new(client).into_rpc())?; + module.merge(ZkTree::new(client).into_rpc())?; Ok(module) } diff --git a/node/src/zktrie_rpc.rs b/node/src/zktree_rpc.rs similarity index 69% rename from node/src/zktrie_rpc.rs rename to node/src/zktree_rpc.rs index f541368a..7983ad88 100644 --- a/node/src/zktrie_rpc.rs +++ b/node/src/zktree_rpc.rs @@ -1,19 +1,19 @@ -//! ZK Trie RPC API implementation. +//! ZK Tree RPC API implementation. //! //! Provides RPC methods for querying the ZK Merkle tree state and generating proofs. use std::sync::Arc; use jsonrpsee::{core::RpcResult, proc_macros::rpc}; -use pallet_zk_trie::{Hash256, ZkMerkleProofRpc, ZkTrieApi as ZkTrieRuntimeApi}; +use pallet_zk_tree::{Hash256, ZkMerkleProofRpc, ZkTreeApi as ZkTreeRuntimeApi}; use quantus_runtime::opaque::Block; use serde::{Deserialize, Serialize}; use sp_api::ProvideRuntimeApi; use sp_blockchain::HeaderBackend; -/// ZK Trie state information returned by the RPC. +/// ZK Tree state information returned by the RPC. #[derive(Debug, Clone, Serialize, Deserialize)] -pub struct ZkTrieState { +pub struct ZkTreeState { /// Current root hash of the ZK tree. pub root: Hash256, /// Number of leaves in the tree. @@ -22,47 +22,47 @@ pub struct ZkTrieState { pub depth: u8, } -/// ZK Trie RPC API trait. +/// ZK Tree RPC API trait. #[rpc(client, server)] -pub trait ZkTrieApi { - /// Get the current state of the ZK trie. +pub trait ZkTreeApi { + /// Get the current state of the ZK tree. /// /// Returns the current root hash, leaf count, and tree depth. - #[method(name = "zkTrie_getState")] - fn get_state(&self) -> RpcResult; + #[method(name = "zkTree_getState")] + fn get_state(&self) -> RpcResult; /// Get a Merkle proof for a leaf at the given index. /// /// Returns `null` if the leaf index is out of bounds. - #[method(name = "zkTrie_getMerkleProof")] + #[method(name = "zkTree_getMerkleProof")] fn get_merkle_proof(&self, leaf_index: u64) -> RpcResult>; } -/// ZK Trie RPC handler. -pub struct ZkTrie { +/// ZK Tree RPC handler. +pub struct ZkTree { client: Arc, } -impl ZkTrie { - /// Create a new ZkTrie RPC handler. +impl ZkTree { + /// Create a new ZkTree RPC handler. pub fn new(client: Arc) -> Self { Self { client } } } -impl ZkTrieApiServer for ZkTrie +impl ZkTreeApiServer for ZkTree where C: ProvideRuntimeApi, C: HeaderBackend + Send + Sync + 'static, - C::Api: ZkTrieRuntimeApi, + C::Api: ZkTreeRuntimeApi, { - fn get_state(&self) -> RpcResult { + fn get_state(&self) -> RpcResult { let best_hash = self.client.info().best_hash; let root = self.client.runtime_api().get_root(best_hash).map_err(|e| { jsonrpsee::types::error::ErrorObject::owned( 9000, - format!("Failed to get ZK trie root: {:?}", e), + format!("Failed to get ZK tree root: {:?}", e), None::<()>, ) })?; @@ -70,7 +70,7 @@ where let leaf_count = self.client.runtime_api().get_leaf_count(best_hash).map_err(|e| { jsonrpsee::types::error::ErrorObject::owned( 9001, - format!("Failed to get ZK trie leaf count: {:?}", e), + format!("Failed to get ZK tree leaf count: {:?}", e), None::<()>, ) })?; @@ -78,12 +78,12 @@ where let depth = self.client.runtime_api().get_depth(best_hash).map_err(|e| { jsonrpsee::types::error::ErrorObject::owned( 9002, - format!("Failed to get ZK trie depth: {:?}", e), + format!("Failed to get ZK tree depth: {:?}", e), None::<()>, ) })?; - Ok(ZkTrieState { root, leaf_count, depth }) + Ok(ZkTreeState { root, leaf_count, depth }) } fn get_merkle_proof(&self, leaf_index: u64) -> RpcResult> { diff --git a/pallets/frame-system/src/extensions/check_weight.rs b/pallets/frame-system/src/extensions/check_weight.rs index 5f2eda74..16522611 100644 --- a/pallets/frame-system/src/extensions/check_weight.rs +++ b/pallets/frame-system/src/extensions/check_weight.rs @@ -366,8 +366,8 @@ mod tests { fn normal_extrinsic_limited_by_maximum_extrinsic_weight() { new_test_ext().execute_with(|| { let max = DispatchInfo { - call_weight: block_weights().get(DispatchClass::Normal).max_extrinsic.unwrap() - + Weight::from_parts(1, 0), + call_weight: block_weights().get(DispatchClass::Normal).max_extrinsic.unwrap() + + Weight::from_parts(1, 0), class: DispatchClass::Normal, ..Default::default() }; @@ -710,9 +710,9 @@ mod tests { .0; assert_eq!( BlockWeight::::get().total(), - info.total_weight() - + Weight::from_parts(128, 0) - + block_weights().get(DispatchClass::Normal).base_extrinsic, + info.total_weight() + + Weight::from_parts(128, 0) + + block_weights().get(DispatchClass::Normal).base_extrinsic, ); assert_ok!(CheckWeight::::post_dispatch_details( @@ -724,9 +724,9 @@ mod tests { )); assert_eq!( BlockWeight::::get().total(), - info.total_weight() - + Weight::from_parts(128, 0) - + block_weights().get(DispatchClass::Normal).base_extrinsic, + info.total_weight() + + Weight::from_parts(128, 0) + + block_weights().get(DispatchClass::Normal).base_extrinsic, ); }) } diff --git a/pallets/frame-system/src/lib.rs b/pallets/frame-system/src/lib.rs index 22a01898..3dec9e3f 100644 --- a/pallets/frame-system/src/lib.rs +++ b/pallets/frame-system/src/lib.rs @@ -102,7 +102,7 @@ extern crate alloc; use alloc::{borrow::Cow, boxed::Box, vec, vec::Vec}; use core::{fmt::Debug, marker::PhantomData}; use pallet_prelude::{BlockNumberFor, HeaderFor}; -use qp_header::ZkTrieRootProvider; +use qp_header::ZkTreeRootProvider; #[cfg(feature = "std")] use serde::Serialize; use sp_io::hashing::blake2_256; @@ -601,14 +601,14 @@ pub mod pallet { /// The Block type used by the runtime. This is used by `construct_runtime` to retrieve the /// extrinsics or other block specific data as needed. /// - /// The header must implement `ZkTrieRootProvider` to support setting the ZK trie root + /// The header must implement `ZkTreeRootProvider` to support setting the ZK tree root /// during block finalization. #[pallet::no_default] type Block: Parameter + Member + traits::Block< Hash = Self::Hash, - Header: qp_header::ZkTrieRootProvider, + Header: qp_header::ZkTreeRootProvider, >; /// Maximum number of block number to block hash mappings to keep (oldest pruned first). @@ -897,9 +897,8 @@ pub mod pallet { match Self::can_set_code(&code, res.check_version) { CanSetCodeResult::Ok => {}, - CanSetCodeResult::MultiBlockMigrationsOngoing => { - return Err(Error::::MultiBlockMigrationsOngoing.into()) - }, + CanSetCodeResult::MultiBlockMigrationsOngoing => + return Err(Error::::MultiBlockMigrationsOngoing.into()), CanSetCodeResult::InvalidVersion(error) => { // The upgrade is invalid and there is no benefit in trying to apply this again. Self::deposit_event(Event::RejectedInvalidAuthorizedUpgrade { @@ -1052,15 +1051,15 @@ pub mod pallet { #[pallet::getter(fn digest)] pub(super) type Digest = StorageValue<_, generic::Digest, ValueQuery>; - /// ZK trie root for the current block. + /// ZK tree root for the current block. /// - /// Set by pallet-zk-trie during block finalization. This is included in the + /// Set by pallet-zk-tree during block finalization. This is included in the /// block header as a dedicated field (not in digest) to ensure a fixed offset /// for ZK circuit verification. #[pallet::storage] #[pallet::whitelist_storage] - #[pallet::getter(fn zk_trie_root)] - pub(super) type ZkTrieRoot = StorageValue<_, T::Hash, ValueQuery>; + #[pallet::getter(fn zk_tree_root)] + pub(super) type ZkTreeRoot = StorageValue<_, T::Hash, ValueQuery>; /// Events deposited for the current block. /// @@ -1570,9 +1569,8 @@ impl CanSetCodeResult { pub fn into_result(self) -> Result<(), DispatchError> { match self { Self::Ok => Ok(()), - Self::MultiBlockMigrationsOngoing => { - Err(Error::::MultiBlockMigrationsOngoing.into()) - }, + Self::MultiBlockMigrationsOngoing => + Err(Error::::MultiBlockMigrationsOngoing.into()), Self::InvalidVersion(err) => Err(err.into()), } } @@ -2071,11 +2069,11 @@ impl Pallet { let storage_root = T::Hash::decode(&mut &sp_io::storage::root(version)[..]) .expect("Node is configured to use the same hash; qed"); - let zk_trie_root = >::get(); + let zk_tree_root = >::get(); let mut header = HeaderFor::::new(number, extrinsics_root, storage_root, parent_hash, digest); - header.set_zk_trie_root(zk_trie_root); + header.set_zk_tree_root(zk_tree_root); header } @@ -2084,12 +2082,12 @@ impl Pallet { >::append(item); } - /// Set the ZK trie root for the current block. + /// Set the ZK tree root for the current block. /// - /// Called by pallet-zk-trie during `on_finalize`. The root is included in + /// Called by pallet-zk-tree during `on_finalize`. The root is included in /// the block header as a dedicated field for ZK circuit verification. - pub fn set_zk_trie_root(root: T::Hash) { - >::put(root); + pub fn set_zk_tree_root(root: T::Hash) { + >::put(root); } /// Get the basic externalities for this pallet, useful for tests. diff --git a/pallets/wormhole/Cargo.toml b/pallets/wormhole/Cargo.toml index 94840a2c..b664c965 100644 --- a/pallets/wormhole/Cargo.toml +++ b/pallets/wormhole/Cargo.toml @@ -16,7 +16,7 @@ hex = { workspace = true, optional = true, features = ["alloc"] } lazy_static.workspace = true log.workspace = true pallet-balances.workspace = true -pallet-zk-trie.workspace = true +pallet-zk-tree.workspace = true qp-header = { workspace = true, features = ["serde"] } qp-poseidon.workspace = true qp-wormhole.workspace = true @@ -66,7 +66,7 @@ std = [ "lazy_static/spin_no_std", "log/std", "pallet-balances/std", - "pallet-zk-trie/std", + "pallet-zk-tree/std", "qp-header/std", "qp-poseidon/std", "qp-wormhole-verifier/std", diff --git a/pallets/wormhole/src/lib.rs b/pallets/wormhole/src/lib.rs index 515e2fa1..9b4ff8fe 100644 --- a/pallets/wormhole/src/lib.rs +++ b/pallets/wormhole/src/lib.rs @@ -50,7 +50,7 @@ pub mod pallet { }, }; use frame_system::pallet_prelude::*; - use pallet_zk_trie::ZkTrieRecorder; + use pallet_zk_tree::ZkTreeRecorder; use qp_wormhole_verifier::{ parse_aggregated_public_inputs, AggregatedPublicCircuitInputs, ProofWithPublicInputs, C, D, F, @@ -200,9 +200,9 @@ pub mod pallet { + Into<::AccountId> + From<::AccountId>; - /// ZK Trie recorder for inserting transfer leaves into the Merkle tree. - /// Set to `()` to disable ZK trie recording. - type ZkTrie: pallet_zk_trie::ZkTrieRecorder< + /// ZK Tree recorder for inserting transfer leaves into the Merkle tree. + /// Set to `()` to disable ZK tree recording. + type ZkTree: pallet_zk_tree::ZkTreeRecorder< ::AccountId, Self::AssetId, Self::NativeBalance, @@ -597,13 +597,13 @@ pub mod pallet { Ok((proof, inputs)) } - /// Record a transfer in the ZK trie and emit events. + /// Record a transfer in the ZK tree and emit events. /// /// This inserts the transfer data into the 4-ary Poseidon Merkle tree - /// managed by pallet-zk-trie, which provides Merkle proofs for ZK circuits. + /// managed by pallet-zk-tree, which provides Merkle proofs for ZK circuits. /// /// The emitted event includes `leaf_index` which clients can use to fetch - /// Merkle proofs via `zkTrie_getMerkleProof(leaf_index)` RPC. + /// Merkle proofs via `zkTree_getMerkleProof(leaf_index)` RPC. pub fn record_transfer( asset_id: T::AssetId, from: &::WormholeAccountId, @@ -615,9 +615,9 @@ pub mod pallet { // Increment transfer count for this recipient TransferCount::::insert(to, current_count.saturating_add(T::TransferCount::one())); - // Insert into ZK trie for Merkle proof generation + // Insert into ZK tree for Merkle proof generation // Returns the leaf index for clients to use when fetching proofs - let leaf_index = T::ZkTrie::record_transfer( + let leaf_index = T::ZkTree::record_transfer( to.clone().into(), current_count.into(), asset_id.clone(), diff --git a/pallets/wormhole/src/mock.rs b/pallets/wormhole/src/mock.rs index c45a5939..c7724304 100644 --- a/pallets/wormhole/src/mock.rs +++ b/pallets/wormhole/src/mock.rs @@ -139,7 +139,7 @@ impl pallet_wormhole::Config for Test { type VolumeFeesBurnRate = VolumeFeesBurnRate; type WormholeAccountId = AccountId; type WeightInfo = crate::weights::SubstrateWeight; - type ZkTrie = (); // Disabled in tests - use () no-op implementation + type ZkTree = (); // Disabled in tests - use () no-op implementation } // Helper function to build a genesis configuration diff --git a/pallets/zk-trie/Cargo.toml b/pallets/zk-tree/Cargo.toml similarity index 97% rename from pallets/zk-trie/Cargo.toml rename to pallets/zk-tree/Cargo.toml index 249e4182..8fef0f97 100644 --- a/pallets/zk-trie/Cargo.toml +++ b/pallets/zk-tree/Cargo.toml @@ -4,7 +4,7 @@ description = "4-ary Poseidon Merkle tree for ZK transfer proofs" edition.workspace = true homepage.workspace = true license.workspace = true -name = "pallet-zk-trie" +name = "pallet-zk-tree" repository.workspace = true version = "0.1.0" diff --git a/pallets/zk-trie/src/lib.rs b/pallets/zk-tree/src/lib.rs similarity index 93% rename from pallets/zk-trie/src/lib.rs rename to pallets/zk-tree/src/lib.rs index 96e59b3a..02ad5290 100644 --- a/pallets/zk-trie/src/lib.rs +++ b/pallets/zk-tree/src/lib.rs @@ -1,4 +1,4 @@ -//! # ZK Trie Pallet +//! # ZK Tree Pallet //! //! A 4-ary Poseidon Merkle tree for storing ZK transfer proofs. //! @@ -8,7 +8,7 @@ //! - 4-ary tree (4 children per node) for optimal ZK circuit efficiency //! - Leaves hashed as 8 field elements (injective: values are ≤32 bits) //! - Internal nodes hashed as 16 field elements (8 bytes/felt compact encoding) -//! - Tree root published in block digest for ZK verification +//! - Tree root published in block header for ZK verification //! //! ## Tree Structure //! @@ -167,9 +167,9 @@ pub mod pallet { #[pallet::hooks] impl Hooks> for Pallet { fn on_finalize(_n: BlockNumberFor) { - // Set ZK Merkle root in frame_system for inclusion in block header + // Set ZK Merkle tree root in frame_system for inclusion in block header let root: Hash256 = Root::::get(); - >::set_zk_trie_root(root.into()); + >::set_zk_tree_root(root.into()); } } @@ -206,7 +206,7 @@ pub mod pallet { let new_depth = current_depth.saturating_add(1); debug_assert!( new_depth <= MAX_TREE_DEPTH, - "ZK trie exceeded max depth - this should never happen in practice" + "ZK tree exceeded max depth - this should never happen in practice" ); tree::grow_tree::(current_depth, new_depth); @@ -254,10 +254,10 @@ pub mod pallet { // Trait for external pallets // ============================================================================ -/// Trait for inserting leaves into the ZK trie. +/// Trait for inserting leaves into the ZK tree. /// Used by pallet-wormhole to record transfer proofs. -pub trait ZkTrieRecorder { - /// Insert a transfer into the ZK trie. +pub trait ZkTreeRecorder { + /// Insert a transfer into the ZK tree. /// /// Returns the leaf index, which can be used to fetch Merkle proofs via RPC. /// This operation is infallible. Implementations must always succeed. @@ -269,8 +269,8 @@ pub trait ZkTrieRecorder { ) -> u64; } -/// No-op implementation for when ZK trie is not configured. -impl ZkTrieRecorder for () { +/// No-op implementation for when ZK tree is not configured. +impl ZkTreeRecorder for () { fn record_transfer( _to: AccountId, _transfer_count: u64, @@ -281,7 +281,7 @@ impl ZkTrieRecorder fo } } -impl ZkTrieRecorder for Pallet +impl ZkTreeRecorder for Pallet where T::AccountId: AsRef<[u8]>, { @@ -323,10 +323,10 @@ pub struct ZkMerkleProofRpc { } sp_api::decl_runtime_apis! { - /// Runtime API for the ZK Trie pallet. + /// Runtime API for the ZK Tree pallet. /// /// Provides methods to query the ZK Merkle tree state and generate proofs. - pub trait ZkTrieApi { + pub trait ZkTreeApi { /// Get the current root hash of the ZK tree. fn get_root() -> Hash256; diff --git a/pallets/zk-trie/src/tests.rs b/pallets/zk-tree/src/tests.rs similarity index 74% rename from pallets/zk-trie/src/tests.rs rename to pallets/zk-tree/src/tests.rs index 2e943452..8b35f5f4 100644 --- a/pallets/zk-trie/src/tests.rs +++ b/pallets/zk-tree/src/tests.rs @@ -1,6 +1,6 @@ -//! Tests for the ZK Trie pallet. +//! Tests for the ZK Tree pallet. -use crate::{self as pallet_zk_trie, tree, *}; +use crate::{self as pallet_zk_tree, tree, *}; use frame_support::{ construct_runtime, parameter_types, traits::{ConstU32, Everything, Hooks}, @@ -14,7 +14,7 @@ use sp_runtime::{ construct_runtime!( pub enum Test { System: frame_system, - ZkTrie: pallet_zk_trie, + ZkTree: pallet_zk_tree, } ); @@ -103,16 +103,16 @@ fn test_hash_node() { fn insert_first_leaf_works() { new_test_ext().execute_with(|| { let to = make_account(1); - let (index, root) = ZkTrie::insert_leaf(to.clone(), 0, 0u32, 100u128); + let (index, root) = ZkTree::insert_leaf(to.clone(), 0, 0u32, 100u128); assert_eq!(index, 0); assert_ne!(root, [0u8; 32]); - assert_eq!(ZkTrie::leaf_count(), 1); - assert_eq!(ZkTrie::depth(), 1); - assert_eq!(ZkTrie::root(), root); + assert_eq!(ZkTree::leaf_count(), 1); + assert_eq!(ZkTree::depth(), 1); + assert_eq!(ZkTree::root(), root); // Check leaf was stored - let leaf = ZkTrie::leaf(0).unwrap(); + let leaf = ZkTree::leaf(0).unwrap(); assert_eq!(leaf.to, to); assert_eq!(leaf.transfer_count, 0); assert_eq!(leaf.asset_id, 0); @@ -127,13 +127,13 @@ fn insert_multiple_leaves_works() { for i in 0..4 { let to = make_account(i + 1); - let (index, root) = ZkTrie::insert_leaf(to, i as u64, 0u32, (i + 1) as u128 * 100); + let (index, root) = ZkTree::insert_leaf(to, i as u64, 0u32, (i + 1) as u128 * 100); assert_eq!(index, i as u64); roots.push(root); } - assert_eq!(ZkTrie::leaf_count(), 4); - assert_eq!(ZkTrie::depth(), 1); // 4 leaves fit in depth 1 + assert_eq!(ZkTree::leaf_count(), 4); + assert_eq!(ZkTree::depth(), 1); // 4 leaves fit in depth 1 // Each insert should change the root for i in 1..roots.len() { @@ -148,16 +148,16 @@ fn tree_grows_at_capacity() { // Fill depth 1 (4 leaves) for i in 0..4 { let to = make_account(i + 1); - ZkTrie::insert_leaf(to, i as u64, 0u32, 100u128); + ZkTree::insert_leaf(to, i as u64, 0u32, 100u128); } - assert_eq!(ZkTrie::depth(), 1); + assert_eq!(ZkTree::depth(), 1); // 5th leaf should trigger growth to depth 2 let to = make_account(5); - ZkTrie::insert_leaf(to, 4, 0u32, 100u128); + ZkTree::insert_leaf(to, 4, 0u32, 100u128); - assert_eq!(ZkTrie::leaf_count(), 5); - assert_eq!(ZkTrie::depth(), 2); + assert_eq!(ZkTree::leaf_count(), 5); + assert_eq!(ZkTree::depth(), 2); }); } @@ -167,11 +167,11 @@ fn tree_grows_multiple_times() { // Insert 20 leaves (need depth 3 to fit: 4^3 = 64) for i in 0..20 { let to = make_account((i % 255) as u8 + 1); - ZkTrie::insert_leaf(to, i as u64, 0u32, 100u128); + ZkTree::insert_leaf(to, i as u64, 0u32, 100u128); } - assert_eq!(ZkTrie::leaf_count(), 20); - assert_eq!(ZkTrie::depth(), 3); // 4^2 = 16 < 20 <= 64 = 4^3 + assert_eq!(ZkTree::leaf_count(), 20); + assert_eq!(ZkTree::depth(), 3); // 4^2 = 16 < 20 <= 64 = 4^3 }); } @@ -181,17 +181,17 @@ fn merkle_proof_works() { // Insert some leaves for i in 0..5 { let to = make_account(i + 1); - ZkTrie::insert_leaf(to, i as u64, 0u32, (i + 1) as u128 * 100); + ZkTree::insert_leaf(to, i as u64, 0u32, (i + 1) as u128 * 100); } // Get proof for leaf 0 - let proof = ZkTrie::get_merkle_proof(0).unwrap(); + let proof = ZkTree::get_merkle_proof(0).unwrap(); assert_eq!(proof.leaf_index, 0); assert_eq!(proof.siblings.len(), 2); // depth 2 // Verify the proof - let leaf = ZkTrie::leaf(0).unwrap(); - assert!(ZkTrie::verify_proof(&leaf, &proof)); + let leaf = ZkTree::leaf(0).unwrap(); + assert!(ZkTree::verify_proof(&leaf, &proof)); }); } @@ -201,14 +201,14 @@ fn merkle_proof_all_leaves() { // Insert leaves for i in 0..10 { let to = make_account(i + 1); - ZkTrie::insert_leaf(to, i as u64, i as u32, (i + 1) as u128 * 100); + ZkTree::insert_leaf(to, i as u64, i as u32, (i + 1) as u128 * 100); } // Verify proof for each leaf for i in 0..10 { - let proof = ZkTrie::get_merkle_proof(i).unwrap(); - let leaf = ZkTrie::leaf(i).unwrap(); - assert!(ZkTrie::verify_proof(&leaf, &proof), "Proof failed for leaf {}", i); + let proof = ZkTree::get_merkle_proof(i).unwrap(); + let leaf = ZkTree::leaf(i).unwrap(); + assert!(ZkTree::verify_proof(&leaf, &proof), "Proof failed for leaf {}", i); } }); } @@ -219,26 +219,26 @@ fn invalid_proof_fails() { // Insert leaves for i in 0..5 { let to = make_account(i + 1); - ZkTrie::insert_leaf(to, i as u64, 0u32, (i + 1) as u128 * 100); + ZkTree::insert_leaf(to, i as u64, 0u32, (i + 1) as u128 * 100); } // Get proof for leaf 0 - let proof = ZkTrie::get_merkle_proof(0).unwrap(); + let proof = ZkTree::get_merkle_proof(0).unwrap(); // Try to verify with wrong leaf data let wrong_leaf = ZkLeaf { to: make_account(99), transfer_count: 0, asset_id: 0u32, amount: 100u128 }; - assert!(!ZkTrie::verify_proof(&wrong_leaf, &proof)); + assert!(!ZkTree::verify_proof(&wrong_leaf, &proof)); }); } #[test] fn proof_for_nonexistent_leaf_fails() { new_test_ext().execute_with(|| { - ZkTrie::insert_leaf(make_account(1), 0, 0u32, 100u128); + ZkTree::insert_leaf(make_account(1), 0, 0u32, 100u128); // Try to get proof for leaf index 5 (doesn't exist) - let result = ZkTrie::get_merkle_proof(5); + let result = ZkTree::get_merkle_proof(5); assert!(result.is_err()); }); } @@ -246,18 +246,18 @@ fn proof_for_nonexistent_leaf_fails() { #[test] fn root_changes_on_insert() { new_test_ext().execute_with(|| { - let (_, root1) = ZkTrie::insert_leaf(make_account(1), 0, 0u32, 100u128); - let (_, root2) = ZkTrie::insert_leaf(make_account(2), 1, 0u32, 200u128); + let (_, root1) = ZkTree::insert_leaf(make_account(1), 0, 0u32, 100u128); + let (_, root2) = ZkTree::insert_leaf(make_account(2), 1, 0u32, 200u128); assert_ne!(root1, root2); - assert_eq!(ZkTrie::root(), root2); + assert_eq!(ZkTree::root(), root2); }); } #[test] fn different_amounts_give_different_hashes() { new_test_ext().execute_with(|| { - let (_, root1) = ZkTrie::insert_leaf(make_account(1), 0, 0u32, 100u128); + let (_, root1) = ZkTree::insert_leaf(make_account(1), 0, 0u32, 100u128); // Reset and insert with different amount crate::Leaves::::remove(0); @@ -265,7 +265,7 @@ fn different_amounts_give_different_hashes() { crate::Depth::::put(0); crate::Root::::put([0u8; 32]); - let (_, root2) = ZkTrie::insert_leaf(make_account(1), 0, 0u32, 200u128); + let (_, root2) = ZkTree::insert_leaf(make_account(1), 0, 0u32, 200u128); assert_ne!(root1, root2); }); @@ -274,11 +274,11 @@ fn different_amounts_give_different_hashes() { #[test] fn digest_log_contains_root() { new_test_ext().execute_with(|| { - ZkTrie::insert_leaf(make_account(1), 0, 0u32, 100u128); - let expected_root = ZkTrie::root(); + ZkTree::insert_leaf(make_account(1), 0, 0u32, 100u128); + let expected_root = ZkTree::root(); // Trigger on_finalize - ZkTrie::on_finalize(1); + ZkTree::on_finalize(1); // Check digest let digest = System::digest(); @@ -319,7 +319,7 @@ fn simulate_transfer( asset_id: u32, amount: u128, ) -> (u64, Hash256) { - ZkTrie::insert_leaf(to, transfer_count, asset_id, amount) + ZkTree::insert_leaf(to, transfer_count, asset_id, amount) } #[test] @@ -339,15 +339,15 @@ fn integration_many_transfers_updates_root_in_digest() { assert_eq!(idx0, 0); assert_eq!(idx1, 1); assert_eq!(idx2, 2); - assert_eq!(ZkTrie::leaf_count(), 3); + assert_eq!(ZkTree::leaf_count(), 3); - let root_after_3 = ZkTrie::root(); + let root_after_3 = ZkTree::root(); // Verify proofs for first 3 leaves for idx in 0..3 { - let proof = ZkTrie::get_merkle_proof(idx).expect("proof should exist"); - let leaf = ZkTrie::leaf(idx).expect("leaf should exist"); - assert!(ZkTrie::verify_proof(&leaf, &proof), "proof {} should verify", idx); + let proof = ZkTree::get_merkle_proof(idx).expect("proof should exist"); + let leaf = ZkTree::leaf(idx).expect("leaf should exist"); + assert!(ZkTree::verify_proof(&leaf, &proof), "proof {} should verify", idx); } // 5 more transfers - tree will grow from depth 1 (capacity 4) to depth 2 (capacity 16) @@ -357,17 +357,17 @@ fn integration_many_transfers_updates_root_in_digest() { simulate_transfer(alice.clone(), 2, 1, 100); // Different asset simulate_transfer(bob.clone(), 2, 1, 200); // Different asset - assert_eq!(ZkTrie::leaf_count(), 8); - assert!(ZkTrie::depth() >= 2, "tree should have grown to depth 2"); + assert_eq!(ZkTree::leaf_count(), 8); + assert!(ZkTree::depth() >= 2, "tree should have grown to depth 2"); - let root_after_8 = ZkTrie::root(); + let root_after_8 = ZkTree::root(); assert_ne!(root_after_3, root_after_8, "root should change after new transfers"); // Verify proofs for all 8 leaves for idx in 0..8 { - let proof = ZkTrie::get_merkle_proof(idx).expect("proof should exist"); - let leaf = ZkTrie::leaf(idx).expect("leaf should exist"); - assert!(ZkTrie::verify_proof(&leaf, &proof), "proof {} should verify", idx); + let proof = ZkTree::get_merkle_proof(idx).expect("proof should exist"); + let leaf = ZkTree::leaf(idx).expect("leaf should exist"); + assert!(ZkTree::verify_proof(&leaf, &proof), "proof {} should verify", idx); } // Add 10 more transfers (total 18, tree needs depth 3 for capacity 64) @@ -376,37 +376,37 @@ fn integration_many_transfers_updates_root_in_digest() { simulate_transfer(recipient, i, 0, (i as u128 + 1) * 1000); } - assert_eq!(ZkTrie::leaf_count(), 18); + assert_eq!(ZkTree::leaf_count(), 18); - let root_after_18 = ZkTrie::root(); + let root_after_18 = ZkTree::root(); assert_ne!(root_after_8, root_after_18, "root should change after more transfers"); // Verify ALL proofs still work after tree growth for idx in 0..18 { - let proof = ZkTrie::get_merkle_proof(idx).expect("proof should exist"); - let leaf = ZkTrie::leaf(idx).expect("leaf should exist"); + let proof = ZkTree::get_merkle_proof(idx).expect("proof should exist"); + let leaf = ZkTree::leaf(idx).expect("leaf should exist"); assert!( - ZkTrie::verify_proof(&leaf, &proof), + ZkTree::verify_proof(&leaf, &proof), "proof {} should verify after growth", idx ); } // === Verify specific leaf data === - let leaf_0 = ZkTrie::leaf(0).expect("leaf 0 should exist"); + let leaf_0 = ZkTree::leaf(0).expect("leaf 0 should exist"); assert_eq!(leaf_0.to, alice); assert_eq!(leaf_0.transfer_count, 0); assert_eq!(leaf_0.asset_id, 0); assert_eq!(leaf_0.amount, 1000); - let leaf_6 = ZkTrie::leaf(6).expect("leaf 6 should exist"); + let leaf_6 = ZkTree::leaf(6).expect("leaf 6 should exist"); assert_eq!(leaf_6.to, alice); assert_eq!(leaf_6.transfer_count, 2); assert_eq!(leaf_6.asset_id, 1); // Different asset assert_eq!(leaf_6.amount, 100); // === Finally verify root appears in digest on finalize === - ZkTrie::on_finalize(1); + ZkTree::on_finalize(1); let digest_root = extract_zk_root_from_digest().expect("ZkRoot should be in digest"); assert_eq!(digest_root, root_after_18, "digest should contain current root"); }); @@ -416,14 +416,14 @@ fn integration_many_transfers_updates_root_in_digest() { fn integration_empty_tree_has_zero_root_in_digest() { new_test_ext().execute_with(|| { // No transfers - tree is empty - assert_eq!(ZkTrie::leaf_count(), 0); - assert_eq!(ZkTrie::depth(), 0); + assert_eq!(ZkTree::leaf_count(), 0); + assert_eq!(ZkTree::depth(), 0); - let empty_root = ZkTrie::root(); + let empty_root = ZkTree::root(); assert_eq!(empty_root, [0u8; 32], "empty tree should have zero root"); // Finalize and check digest - ZkTrie::on_finalize(1); + ZkTree::on_finalize(1); let digest_root = extract_zk_root_from_digest().expect("ZkRoot should be in digest"); assert_eq!(digest_root, empty_root); }); @@ -436,19 +436,19 @@ fn integration_root_changes_only_on_insert() { // Insert a leaf simulate_transfer(alice.clone(), 0, 0, 1000); - let root_after_insert = ZkTrie::root(); + let root_after_insert = ZkTree::root(); // Finalize - root should not change - ZkTrie::on_finalize(1); - assert_eq!(ZkTrie::root(), root_after_insert, "finalize should not change root"); + ZkTree::on_finalize(1); + assert_eq!(ZkTree::root(), root_after_insert, "finalize should not change root"); // Another finalize - still same root - ZkTrie::on_finalize(2); - assert_eq!(ZkTrie::root(), root_after_insert, "second finalize should not change root"); + ZkTree::on_finalize(2); + assert_eq!(ZkTree::root(), root_after_insert, "second finalize should not change root"); // Insert another leaf - NOW root should change simulate_transfer(alice.clone(), 1, 0, 2000); - assert_ne!(ZkTrie::root(), root_after_insert, "insert should change root"); + assert_ne!(ZkTree::root(), root_after_insert, "insert should change root"); }); } @@ -461,12 +461,12 @@ fn integration_proof_siblings_at_correct_depth() { simulate_transfer(account, 0, 0, (i as u128 + 1) * 100); } - assert_eq!(ZkTrie::depth(), 2); + assert_eq!(ZkTree::depth(), 2); // Verify proofs have correct number of sibling levels // No path indices needed - children are sorted before hashing for i in 0..5u64 { - let proof = ZkTrie::get_merkle_proof(i).unwrap(); + let proof = ZkTree::get_merkle_proof(i).unwrap(); assert_eq!(proof.siblings.len(), 2, "depth 2 tree should have 2 levels of siblings"); // Each level should have 3 siblings (4-ary tree) @@ -475,8 +475,8 @@ fn integration_proof_siblings_at_correct_depth() { } // Verify the proof works - let leaf = ZkTrie::leaf(i).unwrap(); - assert!(ZkTrie::verify_proof(&leaf, &proof), "proof for leaf {} should verify", i); + let leaf = ZkTree::leaf(i).unwrap(); + assert!(ZkTree::verify_proof(&leaf, &proof), "proof for leaf {} should verify", i); } }); } diff --git a/pallets/zk-trie/src/tree.rs b/pallets/zk-tree/src/tree.rs similarity index 100% rename from pallets/zk-trie/src/tree.rs rename to pallets/zk-tree/src/tree.rs diff --git a/primitives/header/src/lib.rs b/primitives/header/src/lib.rs index a880d71f..5af4cb60 100644 --- a/primitives/header/src/lib.rs +++ b/primitives/header/src/lib.rs @@ -33,19 +33,19 @@ use alloc::vec::Vec; #[cfg(feature = "serde")] use serde::{Deserialize, Serialize}; -/// Extension trait for headers that support ZK trie root. +/// Extension trait for headers that support ZK tree root. /// -/// This trait allows frame_system to set the ZK trie root on headers +/// This trait allows frame_system to set the ZK Merkle tree root on headers /// without knowing the concrete header type. -pub trait ZkTrieRootProvider { - /// The hash type used for the ZK trie root. +pub trait ZkTreeRootProvider { + /// The hash type used for the ZK tree root. type Hash; - /// Set the ZK trie root. - fn set_zk_trie_root(&mut self, root: Self::Hash); + /// Set the ZK tree root. + fn set_zk_tree_root(&mut self, root: Self::Hash); - /// Get the ZK trie root. - fn zk_trie_root(&self) -> &Self::Hash; + /// Get the ZK tree root. + fn zk_tree_root(&self) -> &Self::Hash; } /// Custom block header with separate hashers for block hash and state trie. @@ -55,7 +55,7 @@ pub trait ZkTrieRootProvider { /// /// ## Field Ordering /// -/// The `zk_trie_root` field is intentionally placed **before** `digest` to ensure +/// The `zk_tree_root` field is intentionally placed **before** `digest` to ensure /// a fixed offset in the header preimage. This prevents miners from manipulating /// the digest to shift the ZK root's position in the felt encoding. #[derive(Encode, Decode, PartialEq, Eq, Clone, RuntimeDebug, TypeInfo, DecodeWithMemTracking)] @@ -79,11 +79,11 @@ where pub number: Number, pub state_root: Hash::Output, pub extrinsics_root: Hash::Output, - /// Root of the ZK Merkle trie (4-ary Poseidon tree). + /// Root of the ZK Merkle tree (4-ary Poseidon tree). /// /// This is placed before `digest` to ensure a fixed offset in the header /// preimage for ZK circuit verification. - pub zk_trie_root: Hash::Output, + pub zk_tree_root: Hash::Output, pub digest: Digest, #[codec(skip)] #[cfg_attr(feature = "serde", serde(skip))] @@ -134,8 +134,8 @@ where extrinsics_root, state_root, parent_hash, - // Initialize with zero; pallet-zk-trie will set the actual root - zk_trie_root: sp_core::H256::zero(), + // Initialize with zero; pallet-zk-tree will set the actual root + zk_tree_root: sp_core::H256::zero(), digest, _marker: core::marker::PhantomData, } @@ -229,10 +229,10 @@ where self.extrinsics_root.as_ref().try_into().expect("hash is 32 bytes"), )); - // zk_trie_root : 32 bytes → 4 felts (8 bytes/felt for hash outputs) + // zk_tree_root : 32 bytes → 4 felts (8 bytes/felt for hash outputs) // Placed before digest to ensure fixed offset regardless of digest content felts.extend(bytes_to_digest::( - self.zk_trie_root.as_ref().try_into().expect("hash is 32 bytes"), + self.zk_tree_root.as_ref().try_into().expect("hash is 32 bytes"), )); // digest – SCALE encode then pad to fixed 110 bytes to match circuit expectation @@ -248,16 +248,16 @@ where poseidon_hash.into() } - /// Create a new header with all fields including zk_trie_root. + /// Create a new header with all fields including zk_tree_root. /// - /// This is the preferred constructor when you have the ZK trie root available. - /// Use this instead of `Header::new` + `set_zk_trie_root`. + /// This is the preferred constructor when you have the ZK tree root available. + /// Use this instead of `Header::new` + `set_zk_tree_root`. pub fn new_with_zk_root( number: Number, extrinsics_root: Hash::Output, state_root: Hash::Output, parent_hash: Hash::Output, - zk_trie_root: Hash::Output, + zk_tree_root: Hash::Output, digest: Digest, ) -> Self { Self { @@ -265,26 +265,26 @@ where number, state_root, extrinsics_root, - zk_trie_root, + zk_tree_root, digest, _marker: core::marker::PhantomData, } } - /// Get the ZK trie root. - pub fn zk_trie_root(&self) -> &Hash::Output { - &self.zk_trie_root + /// Get the ZK tree root. + pub fn zk_tree_root(&self) -> &Hash::Output { + &self.zk_tree_root } - /// Set the ZK trie root. + /// Set the ZK tree root. /// - /// Called by pallet-zk-trie during block finalization. - pub fn set_zk_trie_root(&mut self, root: Hash::Output) { - self.zk_trie_root = root; + /// Called by pallet-zk-tree during block finalization. + pub fn set_zk_tree_root(&mut self, root: Hash::Output) { + self.zk_tree_root = root; } } -impl ZkTrieRootProvider for Header +impl ZkTreeRootProvider for Header where Number: Copy + Into + TryFrom, Hash: HashT, @@ -292,12 +292,12 @@ where { type Hash = Hash::Output; - fn set_zk_trie_root(&mut self, root: Self::Hash) { - self.zk_trie_root = root; + fn set_zk_tree_root(&mut self, root: Self::Hash) { + self.zk_tree_root = root; } - fn zk_trie_root(&self) -> &Self::Hash { - &self.zk_trie_root + fn zk_tree_root(&self) -> &Self::Hash { + &self.zk_tree_root } } diff --git a/runtime/Cargo.toml b/runtime/Cargo.toml index 3240f817..a8532278 100644 --- a/runtime/Cargo.toml +++ b/runtime/Cargo.toml @@ -46,7 +46,7 @@ pallet-transaction-payment-rpc-runtime-api.workspace = true pallet-treasury.workspace = true pallet-utility.workspace = true pallet-wormhole.workspace = true -pallet-zk-trie.workspace = true +pallet-zk-tree.workspace = true primitive-types.workspace = true qp-dilithium-crypto.workspace = true qp-header = { workspace = true, features = ["serde"] } @@ -116,7 +116,7 @@ std = [ "pallet-treasury/std", "pallet-utility/std", "pallet-wormhole/std", - "pallet-zk-trie/std", + "pallet-zk-tree/std", "primitive-types/std", "qp-dilithium-crypto/full_crypto", "qp-dilithium-crypto/std", diff --git a/runtime/src/apis.rs b/runtime/src/apis.rs index 48c74018..ab088a7f 100644 --- a/runtime/src/apis.rs +++ b/runtime/src/apis.rs @@ -43,7 +43,7 @@ use sp_version::RuntimeVersion; // Local module imports use super::{ AccountId, Balance, Block, Executive, InherentDataExt, Nonce, Runtime, RuntimeCall, - RuntimeGenesisConfig, System, TransactionPayment, ZkTrie, VERSION, + RuntimeGenesisConfig, System, TransactionPayment, ZkTree, VERSION, }; #[cfg(feature = "try-runtime")] use super::{Header, UncheckedExtrinsic}; @@ -172,38 +172,38 @@ impl_runtime_apis! { } } - impl pallet_zk_trie::ZkTrieApi for Runtime { - fn get_root() -> pallet_zk_trie::Hash256 { - ZkTrie::root() + impl pallet_zk_tree::ZkTreeApi for Runtime { + fn get_root() -> pallet_zk_tree::Hash256 { + ZkTree::root() } fn get_leaf_count() -> u64 { - ZkTrie::leaf_count() + ZkTree::leaf_count() } fn get_depth() -> u8 { - ZkTrie::depth() + ZkTree::depth() } - fn get_merkle_proof(leaf_index: u64) -> Option { + fn get_merkle_proof(leaf_index: u64) -> Option { use codec::Encode; // Get the leaf - let leaf = ZkTrie::leaf(leaf_index)?; + let leaf = ZkTree::leaf(leaf_index)?; // Generate the proof - let proof = ZkTrie::get_merkle_proof(leaf_index).ok()?; + let proof = ZkTree::get_merkle_proof(leaf_index).ok()?; // Compute leaf hash - let leaf_hash = pallet_zk_trie::tree::hash_leaf::(&leaf); + let leaf_hash = pallet_zk_tree::tree::hash_leaf::(&leaf); - Some(pallet_zk_trie::ZkMerkleProofRpc { + Some(pallet_zk_tree::ZkMerkleProofRpc { leaf_index, leaf_data: leaf.encode(), leaf_hash, siblings: proof.siblings, - root: ZkTrie::root(), - depth: ZkTrie::depth(), + root: ZkTree::root(), + depth: ZkTree::depth(), }) } } diff --git a/runtime/src/configs/mod.rs b/runtime/src/configs/mod.rs index cc069771..443f7fe6 100644 --- a/runtime/src/configs/mod.rs +++ b/runtime/src/configs/mod.rs @@ -63,7 +63,7 @@ use sp_version::RuntimeVersion; use super::{ AccountId, Assets, Balance, Balances, Block, BlockNumber, Hash, Nonce, OriginCaller, PalletInfo, Preimage, Referenda, Runtime, RuntimeCall, RuntimeEvent, RuntimeFreezeReason, - RuntimeHoldReason, RuntimeOrigin, RuntimeTask, Scheduler, System, Timestamp, Wormhole, ZkTrie, + RuntimeHoldReason, RuntimeOrigin, RuntimeTask, Scheduler, System, Timestamp, Wormhole, ZkTree, DAYS, EXISTENTIAL_DEPOSIT, MICRO_UNIT, TARGET_BLOCK_TIME_MS, UNIT, VERSION, }; use sp_core::U512; @@ -700,10 +700,10 @@ impl pallet_wormhole::Config for Runtime { type VolumeFeesBurnRate = VolumeFeesBurnRate; type WormholeAccountId = AccountId32; type WeightInfo = pallet_wormhole::weights::SubstrateWeight; - type ZkTrie = ZkTrie; + type ZkTree = ZkTree; } -impl pallet_zk_trie::Config for Runtime { +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 2292ec80..a06e52d9 100644 --- a/runtime/src/lib.rs +++ b/runtime/src/lib.rs @@ -15,11 +15,10 @@ use alloc::vec::Vec; use sp_core::U512; use sp_runtime::{ generic, impl_opaque_keys, - traits::{IdentifyAccount, Verify}, + traits::{BlakeTwo256, IdentifyAccount, Verify}, MultiAddress, }; use sp_version::RuntimeVersion; -use sp_runtime::traits::BlakeTwo256; pub use frame_system::Call as SystemCall; pub use pallet_balances::Call as BalancesCall; @@ -49,8 +48,7 @@ pub mod opaque { // Block header with separate hashers: // - PoseidonHasher: for block hash (ZK circuit compatible) // - BlakeTwo256: for state trie / extrinsics root (efficient native execution) - pub type Header = - qp_header::Header; + pub type Header = qp_header::Header; // Opaque block type. pub type Block = generic::Block; @@ -260,5 +258,5 @@ mod runtime { pub type Wormhole = pallet_wormhole; #[runtime::pallet_index(21)] - pub type ZkTrie = pallet_zk_trie; + pub type ZkTree = pallet_zk_tree; } From abd983bd1a28a24e4d0e5a833a1c2053102bb6b5 Mon Sep 17 00:00:00 2001 From: illuzen Date: Mon, 13 Apr 2026 12:24:11 +0800 Subject: [PATCH 12/19] merkle proof relative to a specific block --- node/src/zktree_rpc.rs | 39 +++++++++++++++++++++++++++++---------- 1 file changed, 29 insertions(+), 10 deletions(-) diff --git a/node/src/zktree_rpc.rs b/node/src/zktree_rpc.rs index 7983ad88..828c9bf5 100644 --- a/node/src/zktree_rpc.rs +++ b/node/src/zktree_rpc.rs @@ -10,6 +10,7 @@ use quantus_runtime::opaque::Block; use serde::{Deserialize, Serialize}; use sp_api::ProvideRuntimeApi; use sp_blockchain::HeaderBackend; +use sp_core::H256; /// ZK Tree state information returned by the RPC. #[derive(Debug, Clone, Serialize, Deserialize)] @@ -33,9 +34,20 @@ pub trait ZkTreeApi { /// Get a Merkle proof for a leaf at the given index. /// + /// If `at_block` is provided, fetch the proof at that specific block hash. + /// Otherwise, use the best (latest) block. + /// + /// **IMPORTANT**: For ZK proof generation, you MUST pass the block hash + /// that you're proving against. The tree root changes with each block, + /// so the Merkle proof must be from the same block as the header. + /// /// Returns `null` if the leaf index is out of bounds. #[method(name = "zkTree_getMerkleProof")] - fn get_merkle_proof(&self, leaf_index: u64) -> RpcResult>; + fn get_merkle_proof( + &self, + leaf_index: u64, + at_block: Option, + ) -> RpcResult>; } /// ZK Tree RPC handler. @@ -86,17 +98,24 @@ where Ok(ZkTreeState { root, leaf_count, depth }) } - fn get_merkle_proof(&self, leaf_index: u64) -> RpcResult> { - let best_hash = self.client.info().best_hash; + fn get_merkle_proof( + &self, + leaf_index: u64, + at_block: Option, + ) -> RpcResult> { + let block_hash = at_block.unwrap_or_else(|| self.client.info().best_hash); let proof = - self.client.runtime_api().get_merkle_proof(best_hash, leaf_index).map_err(|e| { - jsonrpsee::types::error::ErrorObject::owned( - 9003, - format!("Failed to get ZK merkle proof: {:?}", e), - None::<()>, - ) - })?; + self.client + .runtime_api() + .get_merkle_proof(block_hash, leaf_index) + .map_err(|e| { + jsonrpsee::types::error::ErrorObject::owned( + 9003, + format!("Failed to get ZK merkle proof at {:?}: {:?}", block_hash, e), + None::<()>, + ) + })?; Ok(proof) } From a2c650bed808a5670e909e999acf58d1ebe90453 Mon Sep 17 00:00:00 2001 From: illuzen Date: Mon, 13 Apr 2026 14:09:07 +0800 Subject: [PATCH 13/19] bump zk-circuits --- Cargo.toml | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 421023d9..f642aebd 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 = "1.4.2", default-features = false } -qp-wormhole-circuit-builder = { version = "1.4.2", default-features = false } -qp-wormhole-prover = { version = "1.4.2", default-features = false } -qp-wormhole-verifier = { version = "1.4.2", default-features = false } -qp-zk-circuits-common = { version = "1.4.2", default-features = false } +qp-wormhole-circuit = { version = "2.0.0", default-features = false } +qp-wormhole-circuit-builder = { version = "2.0.0", default-features = false } +qp-wormhole-prover = { version = "2.0.0", default-features = false } +qp-wormhole-verifier = { version = "2.0.0", default-features = false } +qp-zk-circuits-common = { version = "2.0.0", default-features = false } # polkadot-sdk dependencies From 4d5a94f809d45ca7c0a394e674fdcea0613f620b Mon Sep 17 00:00:00 2001 From: illuzen Date: Mon, 13 Apr 2026 14:30:56 +0800 Subject: [PATCH 14/19] lock --- Cargo.lock | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 3dbe0640..ab81a4e7 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -8397,7 +8397,7 @@ dependencies = [ [[package]] name = "qp-wormhole-aggregator" -version = "1.4.2" +version = "2.0.0" dependencies = [ "anyhow", "hex", @@ -8413,7 +8413,7 @@ dependencies = [ [[package]] name = "qp-wormhole-circuit" -version = "1.4.2" +version = "2.0.0" dependencies = [ "anyhow", "hex", @@ -8424,7 +8424,7 @@ dependencies = [ [[package]] name = "qp-wormhole-circuit-builder" -version = "1.4.2" +version = "2.0.0" dependencies = [ "anyhow", "clap", @@ -8436,14 +8436,14 @@ dependencies = [ [[package]] name = "qp-wormhole-inputs" -version = "1.4.2" +version = "2.0.0" dependencies = [ "anyhow", ] [[package]] name = "qp-wormhole-prover" -version = "1.4.2" +version = "2.0.0" dependencies = [ "anyhow", "qp-plonky2", @@ -8454,7 +8454,7 @@ dependencies = [ [[package]] name = "qp-wormhole-verifier" -version = "1.4.2" +version = "2.0.0" dependencies = [ "anyhow", "qp-plonky2-verifier", @@ -8463,7 +8463,7 @@ dependencies = [ [[package]] name = "qp-zk-circuits-common" -version = "1.4.2" +version = "2.0.0" dependencies = [ "anyhow", "hex", From 316ad0edc3b3597ef624773fd2c279efeed4ebe4 Mon Sep 17 00:00:00 2001 From: illuzen Date: Mon, 13 Apr 2026 15:24:19 +0800 Subject: [PATCH 15/19] bump zk again --- Cargo.toml | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index f642aebd..487e6486 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.0", default-features = false } -qp-wormhole-circuit-builder = { version = "2.0.0", default-features = false } -qp-wormhole-prover = { version = "2.0.0", default-features = false } -qp-wormhole-verifier = { version = "2.0.0", default-features = false } -qp-zk-circuits-common = { version = "2.0.0", default-features = false } +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 } # polkadot-sdk dependencies From 7a008e488c59b37adcf1af70e542105af4f136ee Mon Sep 17 00:00:00 2001 From: Nikolaus Heger Date: Mon, 13 Apr 2026 15:36:54 +0800 Subject: [PATCH 16/19] update cargo lock --- Cargo.lock | 28 +++++++++++++++++++++------- 1 file changed, 21 insertions(+), 7 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index abc15965..52636ff8 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -8356,7 +8356,9 @@ dependencies = [ [[package]] name = "qp-wormhole-aggregator" -version = "2.0.0" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba5a23eea8e17c97632f5056d1fecdb83d2e997f79d823fb97c514823fce8580" dependencies = [ "anyhow", "hex", @@ -8372,7 +8374,9 @@ dependencies = [ [[package]] name = "qp-wormhole-circuit" -version = "2.0.0" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b72abd3357e1c486621431109d83a259076ed941fcc7f035353a629940c443d9" dependencies = [ "anyhow", "hex", @@ -8383,7 +8387,9 @@ dependencies = [ [[package]] name = "qp-wormhole-circuit-builder" -version = "2.0.0" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9d27c981d34a35cb10ee96e16c1fb44fbb4c52f3e58a787ce089c21bf5469514" dependencies = [ "anyhow", "clap", @@ -8395,14 +8401,18 @@ dependencies = [ [[package]] name = "qp-wormhole-inputs" -version = "2.0.0" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f69e54a0f450d349cb1169bbb743a7a846475a1210760308e38f55841e5aa5c0" dependencies = [ "anyhow", ] [[package]] name = "qp-wormhole-prover" -version = "2.0.0" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68cee4d6a0317f89d1ec7a6c40a9592e5525c75b9cb21bd7d5d3b408301068bd" dependencies = [ "anyhow", "qp-plonky2", @@ -8413,7 +8423,9 @@ dependencies = [ [[package]] name = "qp-wormhole-verifier" -version = "2.0.0" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "83f7c0134a766c6624183d129abf12523247e38fc27860e3a9778f73321008ae" dependencies = [ "anyhow", "qp-plonky2-verifier", @@ -8422,7 +8434,9 @@ dependencies = [ [[package]] name = "qp-zk-circuits-common" -version = "2.0.0" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f6d5e1d764560fd797f71defbf75a1618596945c53e33033ac42cc7c2e4689f6" dependencies = [ "anyhow", "hex", From 6a5ec74154300218e2e28ee08bf277d1601ad468 Mon Sep 17 00:00:00 2001 From: Nikolaus Heger Date: Mon, 13 Apr 2026 16:38:18 +0800 Subject: [PATCH 17/19] fix test errors --- .../src/extensions/authorize_call.rs | 3 +- pallets/frame-system/src/mocking.rs | 10 +- pallets/wormhole/src/mock.rs | 2 +- primitives/header/src/lib.rs | 96 ++++++++----------- 4 files changed, 44 insertions(+), 67 deletions(-) diff --git a/pallets/frame-system/src/extensions/authorize_call.rs b/pallets/frame-system/src/extensions/authorize_call.rs index ffa25e71..84325271 100644 --- a/pallets/frame-system/src/extensions/authorize_call.rs +++ b/pallets/frame-system/src/extensions/authorize_call.rs @@ -197,7 +197,8 @@ mod tests { pub type TransactionExtension = (frame_system::AuthorizeCall,); - pub type Header = sp_runtime::generic::Header; + pub type Header = + qp_header::Header; pub type Block = sp_runtime::generic::Block; pub type UncheckedExtrinsic = sp_runtime::generic::UncheckedExtrinsic< u64, diff --git a/pallets/frame-system/src/mocking.rs b/pallets/frame-system/src/mocking.rs index 833309e0..6a124786 100644 --- a/pallets/frame-system/src/mocking.rs +++ b/pallets/frame-system/src/mocking.rs @@ -27,21 +27,17 @@ pub type MockUncheckedExtrinsic = generic::Unchec Extra, >; -/// An implementation of `sp_runtime::traits::Block` to be used in tests. pub type MockBlock = generic::Block< - generic::Header, + qp_header::Header, MockUncheckedExtrinsic, >; -/// An implementation of `sp_runtime::traits::Block` to be used in tests with u32 BlockNumber type. pub type MockBlockU32 = generic::Block< - generic::Header, + qp_header::Header, MockUncheckedExtrinsic, >; -/// An implementation of `sp_runtime::traits::Block` to be used in tests with u128 BlockNumber -/// type. pub type MockBlockU128 = generic::Block< - generic::Header, + qp_header::Header, MockUncheckedExtrinsic, >; diff --git a/pallets/wormhole/src/mock.rs b/pallets/wormhole/src/mock.rs index c7724304..48e30595 100644 --- a/pallets/wormhole/src/mock.rs +++ b/pallets/wormhole/src/mock.rs @@ -28,7 +28,7 @@ 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, + qp_header::Header, MockUncheckedExtrinsic, >; diff --git a/primitives/header/src/lib.rs b/primitives/header/src/lib.rs index 5af4cb60..cf4b46bc 100644 --- a/primitives/header/src/lib.rs +++ b/primitives/header/src/lib.rs @@ -345,84 +345,63 @@ mod tests { number: 2, state_root: BlakeTwo256::hash(b"3"), extrinsics_root: BlakeTwo256::hash(b"4"), + zk_tree_root: Default::default(), digest: Digest { logs: vec![sp_runtime::generic::DigestItem::Other(b"6".to_vec())] }, _marker: core::marker::PhantomData, }; let header_encoded = header.encode(); - assert_eq!( - header_encoded, - vec![ - 146, 205, 245, 120, 196, 112, 133, 165, 153, 34, 86, 240, 220, 249, 125, 11, 25, - 241, 241, 201, 222, 77, 95, 227, 12, 58, 206, 97, 145, 182, 229, 219, 2, 0, 0, 0, - 88, 19, 72, 51, 123, 15, 62, 20, 134, 32, 23, 61, 170, 165, 249, 77, 0, 216, 129, - 112, 93, 203, 240, 170, 131, 239, 218, 186, 97, 210, 237, 225, 235, 134, 73, 33, - 73, 151, 87, 78, 32, 196, 100, 56, 138, 23, 36, 32, 210, 84, 3, 104, 43, 187, 184, - 12, 73, 104, 49, 200, 204, 31, 143, 13, 4, 0, 4, 54 - ], - ); - assert_eq!( - Header::::decode(&mut &header_encoded[..]).unwrap(), - header - ); + let header_decoded = + Header::::decode(&mut &header_encoded[..]).unwrap(); + assert_eq!(header_decoded, header); let header = Header:: { parent_hash: BlakeTwo256::hash(b"1000"), number: 2000, state_root: BlakeTwo256::hash(b"3000"), extrinsics_root: BlakeTwo256::hash(b"4000"), + zk_tree_root: Default::default(), digest: Digest { logs: vec![sp_runtime::generic::DigestItem::Other(b"5000".to_vec())] }, _marker: core::marker::PhantomData, }; let header_encoded = header.encode(); - assert_eq!( - header_encoded, - vec![ - 197, 243, 254, 225, 31, 117, 21, 218, 179, 213, 92, 6, 247, 164, 230, 25, 47, 166, - 140, 117, 142, 159, 195, 202, 67, 196, 238, 26, 44, 18, 33, 92, 208, 7, 0, 0, 219, - 225, 47, 12, 107, 88, 153, 146, 55, 21, 226, 186, 110, 48, 167, 187, 67, 183, 228, - 232, 118, 136, 30, 254, 11, 87, 48, 112, 7, 97, 31, 82, 146, 110, 96, 87, 152, 68, - 98, 162, 227, 222, 78, 14, 244, 194, 120, 154, 112, 97, 222, 144, 174, 101, 220, - 44, 111, 126, 54, 34, 155, 220, 253, 124, 4, 0, 16, 53, 48, 48, 48 - ], - ); - assert_eq!( - Header::::decode(&mut &header_encoded[..]).unwrap(), - header - ); + let header_decoded = + Header::::decode(&mut &header_encoded[..]).unwrap(); + assert_eq!(header_decoded, header); } fn hash_header(x: &[u8]) -> [u8; 32] { let mut y = x; if let Ok(header) = Header::::decode(&mut y) { - // Only treat this as a header if we consumed the entire input. if y.is_empty() { - let max_encoded_felts = 4 * 3 + 1 + 28; // 3 hash fields (4 felts each) + 1 u32 + 28 felts + const DIGEST_LOGS_SIZE: usize = 110; + let max_encoded_felts = 4 * 4 + 1 + 28; let mut felts = Vec::with_capacity(max_encoded_felts); - let parent_hash = header.parent_hash.as_bytes(); - let number = header.number; - let state_root = header.state_root.as_bytes(); - let extrinsics_root = header.extrinsics_root.as_bytes(); - let digest = header.digest.encode(); - felts.extend(bytes_to_digest::( - parent_hash.try_into().expect("Parent hash expected to equal 32 bytes"), + header.parent_hash.as_bytes().try_into().unwrap(), + )); + felts.push(Goldilocks::from_int(header.number as u64)); + felts.extend(bytes_to_digest::( + header.state_root.as_bytes().try_into().unwrap(), )); - felts.push(Goldilocks::from_int(number as u64)); felts.extend(bytes_to_digest::( - state_root.try_into().expect("State root expected to equal 32 bytes"), + header.extrinsics_root.as_bytes().try_into().unwrap(), )); felts.extend(bytes_to_digest::( - extrinsics_root.try_into().expect("Extrinsics root expected to equal 32 bytes"), + header.zk_tree_root.as_bytes().try_into().unwrap(), )); - felts.extend(bytes_to_felts(&digest)); + + let digest_encoded = header.digest.encode(); + let mut digest_padded = [0u8; DIGEST_LOGS_SIZE]; + let copy_len = digest_encoded.len().min(DIGEST_LOGS_SIZE); + digest_padded[..copy_len].copy_from_slice(&digest_encoded[..copy_len]); + felts.extend(bytes_to_felts(&digest_padded)); return hash_to_bytes(&felts); } } - // Fallback: canonical bytes hashing for non-header data PoseidonHasher::hash_for_circuit(x) } @@ -456,20 +435,21 @@ mod tests { ), ], }; - let header = Header:: { - parent_hash: H256::from_slice( - hex::decode(parent_hash).expect("valid hex parent hash").as_slice(), - ), - number, - state_root: H256::from_slice( - hex::decode(state_root).expect("valid hex state root").as_slice(), - ), - extrinsics_root: H256::from_slice( - hex::decode(extrinsics_root).expect("valid hex extrinsics root").as_slice(), - ), - digest, - _marker: core::marker::PhantomData, - }; + let header = Header:: { + parent_hash: H256::from_slice( + hex::decode(parent_hash).expect("valid hex parent hash").as_slice(), + ), + number, + state_root: H256::from_slice( + hex::decode(state_root).expect("valid hex state root").as_slice(), + ), + extrinsics_root: H256::from_slice( + hex::decode(extrinsics_root).expect("valid hex extrinsics root").as_slice(), + ), + zk_tree_root: Default::default(), + digest, + _marker: core::marker::PhantomData, + }; let encoded = header.encode(); From 26b843dfcd859356ba502faac000dd165876be4d Mon Sep 17 00:00:00 2001 From: illuzen Date: Mon, 13 Apr 2026 16:43:02 +0800 Subject: [PATCH 18/19] new test proof --- pallets/wormhole/test-data/aggregated.hex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pallets/wormhole/test-data/aggregated.hex b/pallets/wormhole/test-data/aggregated.hex index 8d338419..379e5aa3 100644 --- a/pallets/wormhole/test-data/aggregated.hex +++ b/pallets/wormhole/test-data/aggregated.hex @@ -1 +1 @@ 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 \ No newline at end of file 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 \ No newline at end of file From 175ef9cd92943256cad37b5b413914ab8533573d Mon Sep 17 00:00:00 2001 From: illuzen Date: Mon, 13 Apr 2026 16:53:13 +0800 Subject: [PATCH 19/19] fixed tests --- pallets/zk-tree/src/tests.rs | 69 ++++++++++++++++-------------------- primitives/header/src/lib.rs | 30 ++++++++-------- 2 files changed, 46 insertions(+), 53 deletions(-) diff --git a/pallets/zk-tree/src/tests.rs b/pallets/zk-tree/src/tests.rs index 8b35f5f4..4bc30928 100644 --- a/pallets/zk-tree/src/tests.rs +++ b/pallets/zk-tree/src/tests.rs @@ -257,58 +257,49 @@ fn root_changes_on_insert() { #[test] fn different_amounts_give_different_hashes() { new_test_ext().execute_with(|| { - let (_, root1) = ZkTree::insert_leaf(make_account(1), 0, 0u32, 100u128); + // Use amounts large enough to differ after quantization. + // Amounts are quantized by dividing by 10^10 (AMOUNT_SCALE_DOWN_FACTOR). + // 1 DEV = 10^12 planck → 100 quantized units + // 2 DEV = 2*10^12 planck → 200 quantized units + let one_dev = 1_000_000_000_000u128; // 10^12 + let two_dev = 2_000_000_000_000u128; // 2*10^12 + + let (_, root1) = ZkTree::insert_leaf(make_account(1), 0, 0u32, one_dev); // Reset and insert with different amount crate::Leaves::::remove(0); crate::LeafCount::::put(0); crate::Depth::::put(0); crate::Root::::put([0u8; 32]); + // Also reset the internal nodes + let _ = crate::Nodes::::clear(u32::MAX, None); - let (_, root2) = ZkTree::insert_leaf(make_account(1), 0, 0u32, 200u128); + let (_, root2) = ZkTree::insert_leaf(make_account(1), 0, 0u32, two_dev); assert_ne!(root1, root2); }); } #[test] -fn digest_log_contains_root() { +fn zk_tree_root_set_in_frame_system() { new_test_ext().execute_with(|| { ZkTree::insert_leaf(make_account(1), 0, 0u32, 100u128); let expected_root = ZkTree::root(); - // Trigger on_finalize + // Trigger on_finalize which sets the root in frame_system ZkTree::on_finalize(1); - // Check digest - let digest = System::digest(); - assert!(!digest.logs.is_empty()); - - // Find the ZkRoot log - let found = digest.logs.iter().any(|item| { - if let sp_runtime::generic::DigestItem::Other(data) = item { - data.as_slice() == expected_root - } else { - false - } - }); - assert!(found, "ZkRoot not found in digest"); + // Check that the root was set in frame_system storage using the getter + let stored_root: H256 = frame_system::Pallet::::zk_tree_root(); + assert_eq!(stored_root.0, expected_root, "ZkTreeRoot not set correctly in frame_system"); }); } -/// Helper to extract ZkRoot from digest -fn extract_zk_root_from_digest() -> Option { - let digest = System::digest(); - for item in digest.logs.iter() { - if let sp_runtime::generic::DigestItem::Other(data) = item { - if data.len() == 32 { - let mut root = [0u8; 32]; - root.copy_from_slice(data); - return Some(root); - } - } - } - None +/// Helper to extract ZkRoot from frame_system storage +fn extract_zk_root_from_frame_system() -> Option { + let stored: H256 = frame_system::Pallet::::zk_tree_root(); + // Return Some even for zero since that's a valid empty tree root + Some(stored.0) } /// Simulate a transfer by inserting a leaf into the ZK trie. @@ -323,7 +314,7 @@ fn simulate_transfer( } #[test] -fn integration_many_transfers_updates_root_in_digest() { +fn integration_many_transfers_updates_root() { new_test_ext().execute_with(|| { let alice = make_account(1); let bob = make_account(2); @@ -405,15 +396,16 @@ fn integration_many_transfers_updates_root_in_digest() { assert_eq!(leaf_6.asset_id, 1); // Different asset assert_eq!(leaf_6.amount, 100); - // === Finally verify root appears in digest on finalize === + // === Finally verify root is set in frame_system on finalize === ZkTree::on_finalize(1); - let digest_root = extract_zk_root_from_digest().expect("ZkRoot should be in digest"); - assert_eq!(digest_root, root_after_18, "digest should contain current root"); + let stored_root = + extract_zk_root_from_frame_system().expect("ZkRoot should be in frame_system"); + assert_eq!(stored_root, root_after_18, "frame_system should contain current root"); }); } #[test] -fn integration_empty_tree_has_zero_root_in_digest() { +fn integration_empty_tree_has_zero_root_in_frame_system() { new_test_ext().execute_with(|| { // No transfers - tree is empty assert_eq!(ZkTree::leaf_count(), 0); @@ -422,10 +414,11 @@ fn integration_empty_tree_has_zero_root_in_digest() { let empty_root = ZkTree::root(); assert_eq!(empty_root, [0u8; 32], "empty tree should have zero root"); - // Finalize and check digest + // Finalize and check frame_system storage ZkTree::on_finalize(1); - let digest_root = extract_zk_root_from_digest().expect("ZkRoot should be in digest"); - assert_eq!(digest_root, empty_root); + let stored_root = + extract_zk_root_from_frame_system().expect("ZkRoot should be in frame_system"); + assert_eq!(stored_root, empty_root); }); } diff --git a/primitives/header/src/lib.rs b/primitives/header/src/lib.rs index cf4b46bc..ae994a97 100644 --- a/primitives/header/src/lib.rs +++ b/primitives/header/src/lib.rs @@ -435,21 +435,21 @@ mod tests { ), ], }; - let header = Header:: { - parent_hash: H256::from_slice( - hex::decode(parent_hash).expect("valid hex parent hash").as_slice(), - ), - number, - state_root: H256::from_slice( - hex::decode(state_root).expect("valid hex state root").as_slice(), - ), - extrinsics_root: H256::from_slice( - hex::decode(extrinsics_root).expect("valid hex extrinsics root").as_slice(), - ), - zk_tree_root: Default::default(), - digest, - _marker: core::marker::PhantomData, - }; + let header = Header:: { + parent_hash: H256::from_slice( + hex::decode(parent_hash).expect("valid hex parent hash").as_slice(), + ), + number, + state_root: H256::from_slice( + hex::decode(state_root).expect("valid hex state root").as_slice(), + ), + extrinsics_root: H256::from_slice( + hex::decode(extrinsics_root).expect("valid hex extrinsics root").as_slice(), + ), + zk_tree_root: Default::default(), + digest, + _marker: core::marker::PhantomData, + }; let encoded = header.encode();