diff --git a/protocol/nac-udm/src/l3_storage/archive_storage.rs b/protocol/nac-udm/src/l3_storage/archive_storage.rs
index a843d26..b81ada3 100644
--- a/protocol/nac-udm/src/l3_storage/archive_storage.rs
+++ b/protocol/nac-udm/src/l3_storage/archive_storage.rs
@@ -3,4 +3,59 @@
 pub struct ArchiveStorage {
 /// 字段
     pub path: String,
+    
+    // =================================================================
+    // 以下为追加扩展内容 (Extended by NAC Core Team)
+    // 遵循核心治理哲学：参与即是共识，历史数据不可篡改
+    // =================================================================
+    
+    /// 归档文件描述符映射 (区块高度 -> 文件路径)
+    archive_index: std::collections::HashMap<u64, String>,
+    /// 压缩级别
+    compression_level: u8,
+}
+
+impl ArchiveStorage {
+    /// 创建新的归档存储实例
+    pub fn new(path: String) -> Self {
+        Self {
+            path,
+            archive_index: std::collections::HashMap::new(),
+            compression_level: 3, // 默认压缩级别
+        }
+    }
+
+    /// 归档指定高度范围的区块数据
+    /// 
+    /// # 参数
+    /// * `start_height` - 起始区块高度
+    /// * `end_height` - 结束区块高度
+    /// * `data` - 序列化后的区块数据
+    pub fn archive_blocks(&mut self, start_height: u64, end_height: u64, data: &[u8]) -> Result<String, String> {
+        let file_name = format!("{}/blocks_{}_{}.arc", self.path, start_height, end_height);
+        
+        // 实际实现中这里会进行压缩并写入文件系统
+        // 这里仅做模拟
+        let compressed_size = data.len() / 2; // 模拟压缩
+        
+        self.archive_index.insert(start_height, file_name.clone());
+        
+        Ok(file_name)
+    }
+
+    /// 检索归档的区块数据
+    pub fn retrieve_blocks(&self, start_height: u64) -> Result<Vec<u8>, String> {
+        if let Some(file_path) = self.archive_index.get(&start_height) {
+            // 实际实现中这里会从文件系统读取并解压
+            // 这里仅返回模拟数据
+            Ok(format!("Simulated data from {}", file_path).into_bytes())
+        } else {
+            Err(format!("Archive not found for height {}", start_height))
+        }
+    }
+
+    /// 获取归档存储的统计信息
+    pub fn get_stats(&self) -> (usize, String) {
+        (self.archive_index.len(), self.path.clone())
+    }
 }
diff --git a/protocol/nac-udm/src/l3_storage/block_store.rs b/protocol/nac-udm/src/l3_storage/block_store.rs
new file mode 100644
index 0000000..5b2df47
--- /dev/null
+++ b/protocol/nac-udm/src/l3_storage/block_store.rs
@@ -0,0 +1,82 @@
+//! L3存储层：区块存储
+//!
+//! 遵循核心治理哲学：
+//! 1. 节点产生区块：区块存储按节点身份分区，节点ID是区块的第一公民
+//! 2. 交易决定区块大小：不预设固定大小，由实际交易集合决定
+
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+/// 区块元数据
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BlockMetadata {
+    /// 区块高度
+    pub height: u64,
+    /// 区块哈希 (SHA3-384)
+    pub hash: String,
+    /// 产生该区块的节点ID (体现"节点产生区块")
+    pub producer_node_id: String,
+    /// 包含的交易数量 (体现"交易决定区块大小")
+    pub tx_count: usize,
+    /// 区块实际字节大小
+    pub size_bytes: usize,
+    /// 产生时间戳
+    pub timestamp: u64,
+    /// 关联的宪法版本 (体现"宪法即是规则")
+    pub constitution_version: String,
+}
+
+/// 区块存储引擎
+pub struct BlockStore {
+    /// 存储路径
+    pub path: String,
+    /// 区块高度到元数据的索引
+    height_index: HashMap<u64, BlockMetadata>,
+    /// 节点ID到其产生的区块高度列表的索引 (体现"节点产生区块")
+    node_blocks_index: HashMap<String, Vec<u64>>,
+}
+
+impl BlockStore {
+    /// 创建新的区块存储实例
+    pub fn new(path: String) -> Self {
+        Self {
+            path,
+            height_index: HashMap::new(),
+            node_blocks_index: HashMap::new(),
+        }
+    }
+
+    /// 存储新区块
+    pub fn store_block(&mut self, metadata: BlockMetadata, _block_data: &[u8]) -> Result<(), String> {
+        // 实际实现中会将 _block_data 写入文件系统或RocksDB
+        
+        let height = metadata.height;
+        let node_id = metadata.producer_node_id.clone();
+        
+        // 更新高度索引
+        self.height_index.insert(height, metadata);
+        
+        // 更新节点索引
+        self.node_blocks_index
+            .entry(node_id)
+            .or_insert_with(Vec::new)
+            .push(height);
+            
+        Ok(())
+    }
+
+    /// 获取区块元数据
+    pub fn get_block_metadata(&self, height: u64) -> Option<&BlockMetadata> {
+        self.height_index.get(&height)
+    }
+
+    /// 获取指定节点产生的所有区块高度
+    pub fn get_blocks_by_node(&self, node_id: &str) -> Option<&Vec<u64>> {
+        self.node_blocks_index.get(node_id)
+    }
+
+    /// 获取当前最高区块高度
+    pub fn get_latest_height(&self) -> u64 {
+        self.height_index.keys().max().copied().unwrap_or(0)
+    }
+}
diff --git a/protocol/nac-udm/src/l3_storage/dna_store.rs b/protocol/nac-udm/src/l3_storage/dna_store.rs
new file mode 100644
index 0000000..d4b0f68
--- /dev/null
+++ b/protocol/nac-udm/src/l3_storage/dna_store.rs
@@ -0,0 +1,83 @@
+//! L3存储层：资产DNA存储
+//!
+//! 专门用于存储和检索基于GNACS编码的资产加密DNA
+//! 遵循核心治理哲学：约法即是治法，资产DNA是RWA合规的数字基石
+
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+/// DNA存储引擎
+pub struct DNAStore {
+    /// 存储路径
+    pub path: String,
+    /// DNA哈希到DNA数据的索引
+    dna_index: HashMap<String, Vec<u8>>,
+    /// GNACS编码到DNA哈希列表的索引
+    gnacs_index: HashMap<String, Vec<String>>,
+    /// 所有者DID到DNA哈希列表的索引
+    owner_index: HashMap<String, Vec<String>>,
+}
+
+impl DNAStore {
+    /// 创建新的DNA存储实例
+    pub fn new(path: String) -> Self {
+        Self {
+            path,
+            dna_index: HashMap::new(),
+            gnacs_index: HashMap::new(),
+            owner_index: HashMap::new(),
+        }
+    }
+
+    /// 存储新的资产DNA
+    /// 
+    /// # 参数
+    /// * `dna_hash` - DNA的唯一哈希标识
+    /// * `gnacs_code` - 关联的GNACS编码
+    /// * `owner_did` - 所有者的DID
+    /// * `dna_data` - 序列化后的CryptoDNA数据
+    pub fn store_dna(
+        &mut self, 
+        dna_hash: String, 
+        gnacs_code: String, 
+        owner_did: String, 
+        dna_data: Vec<u8>
+    ) -> Result<(), String> {
+        // 存储DNA数据
+        self.dna_index.insert(dna_hash.clone(), dna_data);
+        
+        // 更新GNACS索引
+        self.gnacs_index
+            .entry(gnacs_code)
+            .or_insert_with(Vec::new)
+            .push(dna_hash.clone());
+            
+        // 更新所有者索引
+        self.owner_index
+            .entry(owner_did)
+            .or_insert_with(Vec::new)
+            .push(dna_hash);
+            
+        Ok(())
+    }
+
+    /// 通过哈希获取DNA数据
+    pub fn get_dna_by_hash(&self, dna_hash: &str) -> Option<&Vec<u8>> {
+        self.dna_index.get(dna_hash)
+    }
+
+    /// 获取指定GNACS编码下的所有DNA哈希
+    pub fn get_dnas_by_gnacs(&self, gnacs_code: &str) -> Option<&Vec<String>> {
+        self.gnacs_index.get(gnacs_code)
+    }
+
+    /// 获取指定所有者的所有DNA哈希
+    pub fn get_dnas_by_owner(&self, owner_did: &str) -> Option<&Vec<String>> {
+        self.owner_index.get(owner_did)
+    }
+    
+    /// 获取存储的DNA总数
+    pub fn total_dnas(&self) -> usize {
+        self.dna_index.len()
+    }
+}
diff --git a/protocol/nac-udm/src/l3_storage/evidence_storage.rs b/protocol/nac-udm/src/l3_storage/evidence_storage.rs
index 37c5a07..32e9b75 100644
--- a/protocol/nac-udm/src/l3_storage/evidence_storage.rs
+++ b/protocol/nac-udm/src/l3_storage/evidence_storage.rs
@@ -3,4 +3,104 @@
 pub struct EvidenceStorage {
 /// 字段
     pub path: String,
+    
+    // =================================================================
+    // 以下为追加扩展内容 (Extended by NAC Core Team)
+    // 遵循核心治理哲学：约法即是治法，证据存证是司法管辖的基石
+    // =================================================================
+    
+    /// 存证记录映射 (证据哈希 -> 存证元数据)
+    evidence_records: std::collections::HashMap<String, EvidenceMetadata>,
+}
+
+/// 存证元数据
+#[derive(Debug, Clone)]
+pub struct EvidenceMetadata {
+    /// 证据哈希 (SHA3-384)
+    pub hash: String,
+    /// 存证时间戳
+    pub timestamp: u64,
+    /// 提交者地址
+    pub submitter: String,
+    /// 关联的GNACS编码 (可选)
+    pub related_gnacs: Option<String>,
+    /// 关联的宪法条款 (可选)
+    pub constitution_ref: Option<String>,
+    /// 存储路径
+    pub storage_path: String,
+}
+
+impl EvidenceStorage {
+    /// 创建新的证据存证实例
+    pub fn new(path: String) -> Self {
+        Self {
+            path,
+            evidence_records: std::collections::HashMap::new(),
+        }
+    }
+
+    /// 存储新证据
+    /// 
+    /// # 参数
+    /// * `evidence_data` - 证据原始数据
+    /// * `submitter` - 提交者地址
+    /// * `related_gnacs` - 关联的GNACS编码
+    /// * `constitution_ref` - 关联的宪法条款
+    pub fn store_evidence(
+        &mut self, 
+        evidence_data: &[u8], 
+        submitter: String,
+        related_gnacs: Option<String>,
+        constitution_ref: Option<String>
+    ) -> Result<String, String> {
+        use sha3::{Digest, Sha3_384};
+        
+        // 计算证据哈希
+        let mut hasher = Sha3_384::new();
+        hasher.update(evidence_data);
+        let hash_bytes = hasher.finalize();
+        let hash_hex = hex::encode(hash_bytes);
+        
+        // 检查是否已存在
+        if self.evidence_records.contains_key(&hash_hex) {
+            return Err(format!("Evidence already exists: {}", hash_hex));
+        }
+        
+        // 实际实现中会将数据写入文件系统或IPFS/Arweave
+        let storage_path = format!("{}/{}", self.path, hash_hex);
+        
+        // 记录元数据
+        let metadata = EvidenceMetadata {
+            hash: hash_hex.clone(),
+            timestamp: std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap_or_default()
+                .as_secs(),
+            submitter,
+            related_gnacs,
+            constitution_ref,
+            storage_path,
+        };
+        
+        self.evidence_records.insert(hash_hex.clone(), metadata);
+        
+        Ok(hash_hex)
+    }
+
+    /// 验证证据是否存在且未被篡改
+    pub fn verify_evidence(&self, evidence_data: &[u8]) -> bool {
+        use sha3::{Digest, Sha3_384};
+        
+        let mut hasher = Sha3_384::new();
+        hasher.update(evidence_data);
+        let hash_bytes = hasher.finalize();
+        let hash_hex = hex::encode(hash_bytes);
+        
+        self.evidence_records.contains_key(&hash_hex)
+    }
+
+    /// 获取证据元数据
+    pub fn get_metadata(&self, hash: &str) -> Option<&EvidenceMetadata> {
+        self.evidence_records.get(hash)
+    }
 }
diff --git a/protocol/nac-udm/src/l3_storage/merkle_tree.rs b/protocol/nac-udm/src/l3_storage/merkle_tree.rs
index edbf010..d0cde31 100644
--- a/protocol/nac-udm/src/l3_storage/merkle_tree.rs
+++ b/protocol/nac-udm/src/l3_storage/merkle_tree.rs
@@ -1,6 +1,123 @@
 /// 模块定义
 /// 结构体
+#[derive(Debug, Clone)]
 pub struct MerkleTree {
 /// 字段
     pub root: Vec<u8>,
+    
+    // =================================================================
+    // 以下为追加扩展内容 (Extended by NAC Core Team)
+    // 遵循核心治理哲学：参与即是共识，不可篡改的密码学证明
+    // =================================================================
+    
+    /// 树中的所有叶子节点哈希
+    pub leaves: Vec<Vec<u8>>,
+    /// 树的层级结构（从底向上）
+    pub layers: Vec<Vec<Vec<u8>>>,
+}
+
+impl MerkleTree {
+    /// 创建一棵空的Merkle树
+    pub fn new() -> Self {
+        Self {
+            root: vec![0u8; 48], // NAC原生使用SHA3-384 (48字节)
+            leaves: Vec::new(),
+            layers: Vec::new(),
+        }
+    }
+
+    /// 从叶子节点构建Merkle树
+    pub fn from_leaves(leaves: Vec<Vec<u8>>) -> Self {
+        if leaves.is_empty() {
+            return Self::new();
+        }
+
+        let mut layers = Vec::new();
+        layers.push(leaves.clone());
+
+        let mut current_layer = leaves.clone();
+        while current_layer.len() > 1 {
+            let mut next_layer = Vec::new();
+            for chunk in current_layer.chunks(2) {
+                if chunk.len() == 2 {
+                    next_layer.push(Self::hash_pair(&chunk[0], &chunk[1]));
+                } else {
+                    // 奇数个节点，复制最后一个节点与自己哈希
+                    next_layer.push(Self::hash_pair(&chunk[0], &chunk[0]));
+                }
+            }
+            layers.push(next_layer.clone());
+            current_layer = next_layer;
+        }
+
+        let root = current_layer[0].clone();
+
+        Self {
+            root,
+            leaves,
+            layers,
+        }
+    }
+
+    /// 计算两个节点的哈希 (使用SHA3-384)
+    fn hash_pair(left: &[u8], right: &[u8]) -> Vec<u8> {
+        use sha3::{Digest, Sha3_384};
+        let mut hasher = Sha3_384::new();
+        hasher.update(left);
+        hasher.update(right);
+        hasher.finalize().to_vec()
+    }
+
+    /// 获取根哈希
+    pub fn root_hash(&self) -> &[u8] {
+        &self.root
+    }
+
+    /// 生成指定叶子节点的Merkle证明
+    pub fn generate_proof(&self, index: usize) -> Option<Vec<Vec<u8>>> {
+        if index >= self.leaves.len() {
+            return None;
+        }
+
+        let mut proof = Vec::new();
+        let mut current_index = index;
+
+        for layer in &self.layers[0..self.layers.len() - 1] {
+            let is_right_node = current_index % 2 == 1;
+            let sibling_index = if is_right_node {
+                current_index - 1
+            } else {
+                std::cmp::min(current_index + 1, layer.len() - 1)
+            };
+
+            proof.push(layer[sibling_index].clone());
+            current_index /= 2;
+        }
+
+        Some(proof)
+    }
+
+    /// 验证Merkle证明
+    pub fn verify_proof(root: &[u8], leaf: &[u8], proof: &[Vec<u8>], index: usize) -> bool {
+        let mut current_hash = leaf.to_vec();
+        let mut current_index = index;
+
+        for sibling in proof {
+            let is_right_node = current_index % 2 == 1;
+            if is_right_node {
+                current_hash = Self::hash_pair(sibling, &current_hash);
+            } else {
+                current_hash = Self::hash_pair(&current_hash, sibling);
+            }
+            current_index /= 2;
+        }
+
+        current_hash == root
+    }
+}
+
+impl Default for MerkleTree {
+    fn default() -> Self {
+        Self::new()
+    }
 }
diff --git a/protocol/nac-udm/src/l3_storage/mod.rs b/protocol/nac-udm/src/l3_storage/mod.rs
index 371ccbe..352852c 100644
--- a/protocol/nac-udm/src/l3_storage/mod.rs
+++ b/protocol/nac-udm/src/l3_storage/mod.rs
@@ -4,6 +4,8 @@
 //! - Merkle树
 //! - 归档存储
 //! - 证据存证
+//! - 区块存储 (Extended)
+//! - 资产DNA存储 (Extended)
 
 /// Merkle树模块
 pub mod merkle_tree;
@@ -11,7 +13,24 @@ pub mod merkle_tree;
 pub mod archive_storage;
 /// 证据存证模块
 pub mod evidence_storage;
+/// 状态数据库模块
+pub mod state_database;
+
+// =================================================================
+// 以下为追加扩展模块 (Extended by NAC Core Team)
+// =================================================================
+
+/// 区块存储模块 (体现"节点产生区块，交易决定区块大小")
+pub mod block_store;
+/// 资产DNA存储模块 (体现"约法即是治法")
+pub mod dna_store;
+/// 状态数据库扩展模块 (体现"宪法即是规则")
+pub mod state_database_ext;
 
 pub use merkle_tree::MerkleTree;
 pub use archive_storage::ArchiveStorage;
 pub use evidence_storage::EvidenceStorage;
+pub use state_database::{StateDatabase, StateKey, StateValue};
+pub use block_store::{BlockStore, BlockMetadata};
+pub use dna_store::DNAStore;
+pub use state_database_ext::{ConstitutionalStateValue, StateSnapshot, GNACSStateIndex};
diff --git a/protocol/nac-udm/src/l3_storage/state_database_ext.rs b/protocol/nac-udm/src/l3_storage/state_database_ext.rs
new file mode 100644
index 0000000..3f91c3c
--- /dev/null
+++ b/protocol/nac-udm/src/l3_storage/state_database_ext.rs
@@ -0,0 +1,65 @@
+//! L3存储层：状态数据库扩展 (Extended by NAC Core Team)
+//!
+//! 遵循核心治理哲学：
+//! 1. 宪法即是规则：每一条状态都必须有宪法条款的引用
+//! 2. 约法即是治法：状态的变更必须符合宪法规则
+
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+// 注意：这里不修改原有的 StateKey 和 StateValue，而是提供扩展结构
+
+/// 带有宪法引用的状态值扩展
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ConstitutionalStateValue {
+    /// 原始状态数据
+    pub data: Vec<u8>,
+    /// 版本号
+    pub version: u64,
+    /// 创建时间
+    pub created_at: u64,
+    /// 更新时间
+    pub updated_at: u64,
+    
+    // --- 以下为扩展字段 ---
+    
+    /// 关联的宪法条款引用 (体现"宪法即是规则")
+    pub constitution_ref: String,
+    /// 产生该状态变更的交易哈希
+    pub tx_hash: String,
+    /// 状态变更时的区块高度
+    pub block_height: u64,
+}
+
+/// 状态快照 (用于历史状态查询)
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct StateSnapshot {
+    pub height: u64,
+    pub state_root: String, // Merkle树根哈希
+    pub timestamp: u64,
+}
+
+/// GNACS状态索引
+pub struct GNACSStateIndex {
+    /// GNACS编码 -> 资产状态键列表
+    index: HashMap<String, Vec<String>>,
+}
+
+impl GNACSStateIndex {
+    pub fn new() -> Self {
+        Self {
+            index: HashMap::new(),
+        }
+    }
+
+    pub fn add_asset(&mut self, gnacs_code: String, asset_key: String) {
+        self.index
+            .entry(gnacs_code)
+            .or_insert_with(Vec::new)
+            .push(asset_key);
+    }
+
+    pub fn get_assets_by_gnacs(&self, gnacs_code: &str) -> Option<&Vec<String>> {
+        self.index.get(gnacs_code)
+    }
+}