nacadmin
/
NAC_Blockchain
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

feat(l3-storage): 补全存储层骨架代码 

遵循五大核心治理哲学：
1. 约法即是治法 - evidence_storage.rs 证据存证
2. 宪法即是规则 - state_database_ext.rs 宪法条款引用
3. 参与即是共识 - merkle_tree.rs SHA3-384不可篡改证明
4. 节点产生区块 - block_store.rs 按节点身份分区
5. 交易决定区块大小 - block_store.rs 不预设固定大小

新增文件：
- block_store.rs: 区块存储引擎
- dna_store.rs: 资产DNA存储（对接asset_dna模块）
- state_database_ext.rs: 状态数据库扩展（宪法引用）

补全骨架：
- merkle_tree.rs: SHA3-384 Merkle树完整实现
- archive_storage.rs: 历史数据归档实现
- evidence_storage.rs: 证据存证实现

保留原有代码：
- state_database.rs: 前期开发者的完整实现保持不变

工单: STORAGE-LAYER-001
This commit is contained in:
NAC Admin 2026-03-18 16:05:06 +08:00
parent 78bc376ccb
commit d8cc65b916
7 changed files with 521 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

55
protocol/nac-udm/src/l3_storage/archive_storage.rs
View File

@ -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())
}
}

82
protocol/nac-udm/src/l3_storage/block_store.rs Normal file
View File

@ -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)
}
}

83
protocol/nac-udm/src/l3_storage/dna_store.rs Normal file
View File

@ -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()
}
}

100
protocol/nac-udm/src/l3_storage/evidence_storage.rs
View File

@ -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)
}
}

117
protocol/nac-udm/src/l3_storage/merkle_tree.rs
View File

@ -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()
}
}

19
protocol/nac-udm/src/l3_storage/mod.rs
View File

@ -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};

65
protocol/nac-udm/src/l3_storage/state_database_ext.rs Normal file
View File

@ -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)
}
}