720 lines
22 KiB
Rust
720 lines
22 KiB
Rust
///! 跨分片交易处理模块
|
||
///!
|
||
///! 处理跨分片的资产转移和证书验证
|
||
///!
|
||
///! **NAC原生设计原则**：
|
||
///! - 使用Asset（资产），不是Token
|
||
///! - 使用Certificate（证书），不是Contract
|
||
///! - 使用SHA3-384哈希，不是SHA256/Keccak256
|
||
///! - 通过CBPP共识协调
|
||
///! - 使用Constitutional Receipt验证
|
||
|
||
use crate::primitives::{Address, Hash};
|
||
use std::collections::{HashMap, VecDeque};
|
||
use serde::{Deserialize, Serialize};
|
||
|
||
/// 跨分片交易
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
/// CrossShardTransaction
|
||
pub struct CrossShardTransaction {
|
||
/// 交易ID
|
||
pub tx_id: Hash,
|
||
/// 源分片ID
|
||
pub source_shard: u64,
|
||
/// 目标分片ID
|
||
pub target_shard: u64,
|
||
/// 发送者地址
|
||
pub sender: Address,
|
||
/// 接收者地址
|
||
pub receiver: Address,
|
||
/// 资产类型（GNACS编码）
|
||
pub asset_type: String,
|
||
/// 资产数量
|
||
pub amount: u64,
|
||
/// 交易状态
|
||
pub status: CrossShardTxStatus,
|
||
/// 创建时间
|
||
pub created_at: u64,
|
||
/// 锁定证明
|
||
pub lock_proof: Option<LockProof>,
|
||
/// 解锁证明
|
||
pub unlock_proof: Option<UnlockProof>,
|
||
/// Constitutional Receipt哈希
|
||
pub cr_hash: Option<Hash>,
|
||
}
|
||
|
||
impl CrossShardTransaction {
|
||
/// 创建新的跨分片交易
|
||
pub fn new(
|
||
tx_id: Hash,
|
||
source_shard: u64,
|
||
target_shard: u64,
|
||
sender: Address,
|
||
receiver: Address,
|
||
asset_type: String,
|
||
amount: u64,
|
||
created_at: u64,
|
||
) -> Self {
|
||
Self {
|
||
tx_id,
|
||
source_shard,
|
||
target_shard,
|
||
sender,
|
||
receiver,
|
||
asset_type,
|
||
amount,
|
||
status: CrossShardTxStatus::Pending,
|
||
created_at,
|
||
lock_proof: None,
|
||
unlock_proof: None,
|
||
cr_hash: None,
|
||
}
|
||
}
|
||
|
||
/// 设置锁定证明
|
||
pub fn set_lock_proof(&mut self, proof: LockProof) {
|
||
self.lock_proof = Some(proof);
|
||
self.status = CrossShardTxStatus::Locked;
|
||
}
|
||
|
||
/// 设置解锁证明
|
||
pub fn set_unlock_proof(&mut self, proof: UnlockProof) {
|
||
self.unlock_proof = Some(proof);
|
||
self.status = CrossShardTxStatus::Completed;
|
||
}
|
||
|
||
/// 设置Constitutional Receipt
|
||
pub fn set_cr_hash(&mut self, cr_hash: Hash) {
|
||
self.cr_hash = Some(cr_hash);
|
||
}
|
||
}
|
||
|
||
/// 跨分片交易状态
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
||
/// CrossShardTxStatus
|
||
pub enum CrossShardTxStatus {
|
||
/// 待处理
|
||
Pending,
|
||
/// 已锁定（源分片）
|
||
Locked,
|
||
/// 已铸造（目标分片）
|
||
Minted,
|
||
/// 已完成
|
||
Completed,
|
||
/// 已失败
|
||
Failed,
|
||
/// 已回滚
|
||
Rolledback,
|
||
}
|
||
|
||
/// 锁定证明
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
/// LockProof
|
||
pub struct LockProof {
|
||
/// 源分片ID
|
||
pub shard_id: u64,
|
||
/// 锁定区块哈希
|
||
pub block_hash: Hash,
|
||
/// 锁定交易哈希
|
||
pub tx_hash: Hash,
|
||
/// 锁定时间
|
||
pub locked_at: u64,
|
||
/// 验证者签名
|
||
pub validator_signatures: Vec<Vec<u8>>,
|
||
}
|
||
|
||
/// 解锁证明
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
/// UnlockProof
|
||
pub struct UnlockProof {
|
||
/// 目标分片ID
|
||
pub shard_id: u64,
|
||
/// 铸造区块哈希
|
||
pub block_hash: Hash,
|
||
/// 铸造交易哈希
|
||
pub tx_hash: Hash,
|
||
/// 铸造时间
|
||
pub minted_at: u64,
|
||
/// 验证者签名
|
||
pub validator_signatures: Vec<Vec<u8>>,
|
||
}
|
||
|
||
/// 跨分片交易处理器
|
||
#[derive(Debug, Clone)]
|
||
/// CrossShardTxProcessor
|
||
pub struct CrossShardTxProcessor {
|
||
/// 当前分片ID
|
||
shard_id: u64,
|
||
/// 待处理交易队列
|
||
pending_queue: VecDeque<CrossShardTransaction>,
|
||
/// 已锁定交易
|
||
locked_txs: HashMap<Hash, CrossShardTransaction>,
|
||
/// 已完成交易
|
||
completed_txs: HashMap<Hash, CrossShardTransaction>,
|
||
/// 失败交易
|
||
failed_txs: HashMap<Hash, (CrossShardTransaction, String)>,
|
||
/// 处理统计
|
||
stats: ProcessorStats,
|
||
}
|
||
|
||
/// 处理器统计
|
||
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
|
||
/// ProcessorStats
|
||
pub struct ProcessorStats {
|
||
/// 总交易数
|
||
pub total_txs: u64,
|
||
/// 待处理交易数
|
||
pub pending_count: u64,
|
||
/// 已锁定交易数
|
||
pub locked_count: u64,
|
||
/// 已完成交易数
|
||
pub completed_count: u64,
|
||
/// 失败交易数
|
||
pub failed_count: u64,
|
||
/// 平均处理时间（毫秒）
|
||
pub avg_processing_time: u64,
|
||
}
|
||
|
||
impl CrossShardTxProcessor {
|
||
/// 创建新的跨分片交易处理器
|
||
pub fn new(shard_id: u64) -> Self {
|
||
Self {
|
||
shard_id,
|
||
pending_queue: VecDeque::new(),
|
||
locked_txs: HashMap::new(),
|
||
completed_txs: HashMap::new(),
|
||
failed_txs: HashMap::new(),
|
||
stats: ProcessorStats::default(),
|
||
}
|
||
}
|
||
|
||
/// 提交跨分片交易
|
||
pub fn submit_transaction(&mut self, tx: CrossShardTransaction) -> Result<(), String> {
|
||
// 验证分片ID
|
||
if tx.source_shard != self.shard_id && tx.target_shard != self.shard_id {
|
||
return Err("Transaction does not involve this shard".to_string());
|
||
}
|
||
|
||
// 验证金额
|
||
if tx.amount == 0 {
|
||
return Err("Amount must be greater than zero".to_string());
|
||
}
|
||
|
||
// 添加到待处理队列
|
||
self.pending_queue.push_back(tx);
|
||
self.stats.total_txs += 1;
|
||
self.stats.pending_count += 1;
|
||
|
||
Ok(())
|
||
}
|
||
|
||
/// 处理源分片锁定
|
||
pub fn process_lock(&mut self, tx_id: &Hash, lock_proof: LockProof) -> Result<(), String> {
|
||
// 从待处理队列中查找交易
|
||
let tx_index = self.pending_queue
|
||
.iter()
|
||
.position(|tx| tx.tx_id == *tx_id)
|
||
.ok_or("Transaction not found in pending queue")?;
|
||
|
||
let mut tx = self.pending_queue.remove(tx_index).unwrap();
|
||
|
||
// 验证是否为源分片
|
||
if tx.source_shard != self.shard_id {
|
||
return Err("This shard is not the source shard".to_string());
|
||
}
|
||
|
||
// 验证锁定证明
|
||
self.verify_lock_proof(&lock_proof)?;
|
||
|
||
// 设置锁定证明
|
||
tx.set_lock_proof(lock_proof);
|
||
|
||
// 移动到已锁定交易
|
||
self.locked_txs.insert(tx_id.clone(), tx);
|
||
self.stats.pending_count -= 1;
|
||
self.stats.locked_count += 1;
|
||
|
||
Ok(())
|
||
}
|
||
|
||
/// 处理目标分片铸造
|
||
pub fn process_mint(&mut self, tx_id: &Hash, unlock_proof: UnlockProof) -> Result<(), String> {
|
||
// 从已锁定交易中查找
|
||
let mut tx = self.locked_txs
|
||
.remove(tx_id)
|
||
.ok_or("Transaction not found in locked transactions")?;
|
||
|
||
// 验证是否为目标分片
|
||
if tx.target_shard != self.shard_id {
|
||
return Err("This shard is not the target shard".to_string());
|
||
}
|
||
|
||
// 验证解锁证明
|
||
self.verify_unlock_proof(&unlock_proof)?;
|
||
|
||
// 设置解锁证明
|
||
tx.set_unlock_proof(unlock_proof);
|
||
|
||
// 移动到已完成交易
|
||
self.completed_txs.insert(tx_id.clone(), tx);
|
||
self.stats.locked_count -= 1;
|
||
self.stats.completed_count += 1;
|
||
|
||
Ok(())
|
||
}
|
||
|
||
/// 验证锁定证明
|
||
fn verify_lock_proof(&self, proof: &LockProof) -> Result<(), String> {
|
||
// 验证签名数量（至少需要2/3验证者签名）
|
||
if proof.validator_signatures.len() < 3 {
|
||
return Err("Insufficient validator signatures".to_string());
|
||
}
|
||
|
||
// 验证签名有效性
|
||
// 构造需要签名的消息：shard_id + block_hash + tx_hash + locked_at
|
||
let mut message = Vec::new();
|
||
message.extend_from_slice(&proof.shard_id.to_le_bytes());
|
||
message.extend_from_slice(proof.block_hash.as_bytes());
|
||
message.extend_from_slice(proof.tx_hash.as_bytes());
|
||
message.extend_from_slice(&proof.locked_at.to_le_bytes());
|
||
|
||
// 验证每个签名（简化版本：只检查签名非空）
|
||
// 实际应该使用ed25519或secp256k1进行密码学验证
|
||
for sig in &proof.validator_signatures {
|
||
if sig.is_empty() {
|
||
return Err("Invalid signature: empty".to_string());
|
||
}
|
||
// 实际应该调用: Signature::from_slice(sig).verify(&message, validator_pubkey)
|
||
}
|
||
|
||
Ok(())
|
||
}
|
||
|
||
/// 验证解锁证明
|
||
fn verify_unlock_proof(&self, proof: &UnlockProof) -> Result<(), String> {
|
||
// 验证签名数量
|
||
if proof.validator_signatures.len() < 3 {
|
||
return Err("Insufficient validator signatures".to_string());
|
||
}
|
||
|
||
// 验证签名有效性
|
||
// 构造需要签名的消息：shard_id + block_hash + tx_hash + minted_at
|
||
let mut message = Vec::new();
|
||
message.extend_from_slice(&proof.shard_id.to_le_bytes());
|
||
message.extend_from_slice(proof.block_hash.as_bytes());
|
||
message.extend_from_slice(proof.tx_hash.as_bytes());
|
||
message.extend_from_slice(&proof.minted_at.to_le_bytes());
|
||
|
||
// 验证每个签名（简化版本：只检查签名非空）
|
||
// 实际应该使用ed25519或secp256k1进行密码学验证
|
||
for sig in &proof.validator_signatures {
|
||
if sig.is_empty() {
|
||
return Err("Invalid signature: empty".to_string());
|
||
}
|
||
// 实际应该调用: Signature::from_slice(sig).verify(&message, validator_pubkey)
|
||
}
|
||
|
||
Ok(())
|
||
}
|
||
|
||
/// 标记交易失败
|
||
pub fn mark_failed(&mut self, tx_id: &Hash, reason: String) -> Result<(), String> {
|
||
// 从待处理队列中查找
|
||
if let Some(index) = self.pending_queue.iter().position(|tx| tx.tx_id == *tx_id) {
|
||
let mut tx = self.pending_queue.remove(index).unwrap();
|
||
tx.status = CrossShardTxStatus::Failed;
|
||
self.failed_txs.insert(tx_id.clone(), (tx, reason));
|
||
self.stats.pending_count -= 1;
|
||
self.stats.failed_count += 1;
|
||
return Ok(());
|
||
}
|
||
|
||
// 从已锁定交易中查找
|
||
if let Some(mut tx) = self.locked_txs.remove(tx_id) {
|
||
tx.status = CrossShardTxStatus::Failed;
|
||
self.failed_txs.insert(tx_id.clone(), (tx, reason));
|
||
self.stats.locked_count -= 1;
|
||
self.stats.failed_count += 1;
|
||
return Ok(());
|
||
}
|
||
|
||
Err("Transaction not found".to_string())
|
||
}
|
||
|
||
/// 回滚交易
|
||
pub fn rollback_transaction(&mut self, tx_id: &Hash) -> Result<(), String> {
|
||
// 从已锁定交易中查找
|
||
let mut tx = self.locked_txs
|
||
.remove(tx_id)
|
||
.ok_or("Transaction not found in locked transactions")?;
|
||
|
||
tx.status = CrossShardTxStatus::Rolledback;
|
||
self.failed_txs.insert(tx_id.clone(), (tx, "Rolled back".to_string()));
|
||
self.stats.locked_count -= 1;
|
||
self.stats.failed_count += 1;
|
||
|
||
Ok(())
|
||
}
|
||
|
||
/// 获取交易状态
|
||
pub fn get_transaction_status(&self, tx_id: &Hash) -> Option<CrossShardTxStatus> {
|
||
// 检查待处理队列
|
||
if let Some(tx) = self.pending_queue.iter().find(|tx| tx.tx_id == *tx_id) {
|
||
return Some(tx.status.clone());
|
||
}
|
||
|
||
// 检查已锁定交易
|
||
if let Some(tx) = self.locked_txs.get(tx_id) {
|
||
return Some(tx.status.clone());
|
||
}
|
||
|
||
// 检查已完成交易
|
||
if let Some(tx) = self.completed_txs.get(tx_id) {
|
||
return Some(tx.status.clone());
|
||
}
|
||
|
||
// 检查失败交易
|
||
if let Some((tx, _)) = self.failed_txs.get(tx_id) {
|
||
return Some(tx.status.clone());
|
||
}
|
||
|
||
None
|
||
}
|
||
|
||
/// 获取待处理交易列表
|
||
pub fn get_pending_transactions(&self) -> Vec<CrossShardTransaction> {
|
||
self.pending_queue.iter().cloned().collect()
|
||
}
|
||
|
||
/// 获取已锁定交易列表
|
||
pub fn get_locked_transactions(&self) -> Vec<CrossShardTransaction> {
|
||
self.locked_txs.values().cloned().collect()
|
||
}
|
||
|
||
/// 获取统计信息
|
||
pub fn get_stats(&self) -> ProcessorStats {
|
||
self.stats.clone()
|
||
}
|
||
|
||
/// 清理已完成交易（保留最近N个）
|
||
pub fn cleanup_completed(&mut self, keep_count: usize) -> usize {
|
||
if self.completed_txs.len() <= keep_count {
|
||
return 0;
|
||
}
|
||
|
||
let to_remove = self.completed_txs.len() - keep_count;
|
||
|
||
// 按时间排序，移除最旧的交易
|
||
let mut txs: Vec<_> = self.completed_txs.iter().collect();
|
||
txs.sort_by_key(|(_, tx)| tx.created_at);
|
||
|
||
// 收集要删除的交易ID
|
||
let tx_ids_to_remove: Vec<Hash> = txs.iter()
|
||
.take(to_remove)
|
||
.map(|(tx_id, _)| (*tx_id).clone())
|
||
.collect();
|
||
|
||
let mut removed = 0;
|
||
for tx_id in tx_ids_to_remove {
|
||
self.completed_txs.remove(&tx_id);
|
||
removed += 1;
|
||
}
|
||
|
||
removed
|
||
}
|
||
}
|
||
|
||
/// 跨分片路由器
|
||
#[derive(Debug, Clone)]
|
||
/// CrossShardRouter
|
||
pub struct CrossShardRouter {
|
||
/// 分片拓扑
|
||
shard_topology: HashMap<u64, Vec<u64>>,
|
||
/// 路由表
|
||
routing_table: HashMap<(u64, u64), Vec<u64>>,
|
||
}
|
||
|
||
impl CrossShardRouter {
|
||
/// 创建新的跨分片路由器
|
||
pub fn new() -> Self {
|
||
Self {
|
||
shard_topology: HashMap::new(),
|
||
routing_table: HashMap::new(),
|
||
}
|
||
}
|
||
|
||
/// 添加分片连接
|
||
pub fn add_shard_connection(&mut self, shard_a: u64, shard_b: u64) {
|
||
self.shard_topology
|
||
.entry(shard_a)
|
||
.or_insert_with(Vec::new)
|
||
.push(shard_b);
|
||
|
||
self.shard_topology
|
||
.entry(shard_b)
|
||
.or_insert_with(Vec::new)
|
||
.push(shard_a);
|
||
}
|
||
|
||
/// 计算最短路径
|
||
pub fn find_route(&mut self, source: u64, target: u64) -> Option<Vec<u64>> {
|
||
// 检查缓存
|
||
if let Some(route) = self.routing_table.get(&(source, target)) {
|
||
return Some(route.clone());
|
||
}
|
||
|
||
// BFS查找最短路径
|
||
let mut queue = VecDeque::new();
|
||
let mut visited = HashMap::new();
|
||
let mut parent = HashMap::new();
|
||
|
||
queue.push_back(source);
|
||
visited.insert(source, true);
|
||
|
||
while let Some(current) = queue.pop_front() {
|
||
if current == target {
|
||
// 重建路径
|
||
let mut path = vec![target];
|
||
let mut node = target;
|
||
|
||
while let Some(&prev) = parent.get(&node) {
|
||
path.push(prev);
|
||
node = prev;
|
||
}
|
||
|
||
path.reverse();
|
||
|
||
// 缓存路径
|
||
self.routing_table.insert((source, target), path.clone());
|
||
|
||
return Some(path);
|
||
}
|
||
|
||
if let Some(neighbors) = self.shard_topology.get(¤t) {
|
||
for &neighbor in neighbors {
|
||
if !visited.contains_key(&neighbor) {
|
||
visited.insert(neighbor, true);
|
||
parent.insert(neighbor, current);
|
||
queue.push_back(neighbor);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
None
|
||
}
|
||
|
||
/// 获取分片邻居
|
||
pub fn get_neighbors(&self, shard_id: u64) -> Vec<u64> {
|
||
self.shard_topology
|
||
.get(&shard_id)
|
||
.cloned()
|
||
.unwrap_or_default()
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
|
||
#[test]
|
||
fn test_cross_shard_tx_creation() {
|
||
let tx_id = Hash::from_slice(&[1u8; 32]).unwrap();
|
||
let sender = Address::from_slice(&[1u8; 20]).unwrap();
|
||
let receiver = Address::from_slice(&[2u8; 20]).unwrap();
|
||
|
||
let tx = CrossShardTransaction::new(
|
||
tx_id,
|
||
1,
|
||
2,
|
||
sender,
|
||
receiver,
|
||
"GNACS-001".to_string(),
|
||
1000,
|
||
1000,
|
||
);
|
||
|
||
assert_eq!(tx.source_shard, 1);
|
||
assert_eq!(tx.target_shard, 2);
|
||
assert_eq!(tx.amount, 1000);
|
||
assert_eq!(tx.status, CrossShardTxStatus::Pending);
|
||
}
|
||
|
||
#[test]
|
||
fn test_processor_submit_transaction() {
|
||
let mut processor = CrossShardTxProcessor::new(1);
|
||
|
||
let tx_id = Hash::from_slice(&[1u8; 32]).unwrap();
|
||
let sender = Address::from_slice(&[1u8; 20]).unwrap();
|
||
let receiver = Address::from_slice(&[2u8; 20]).unwrap();
|
||
|
||
let tx = CrossShardTransaction::new(
|
||
tx_id,
|
||
1,
|
||
2,
|
||
sender,
|
||
receiver,
|
||
"GNACS-001".to_string(),
|
||
1000,
|
||
1000,
|
||
);
|
||
|
||
assert!(processor.submit_transaction(tx).is_ok());
|
||
assert_eq!(processor.stats.total_txs, 1);
|
||
assert_eq!(processor.stats.pending_count, 1);
|
||
}
|
||
|
||
#[test]
|
||
fn test_processor_process_lock() {
|
||
let mut processor = CrossShardTxProcessor::new(1);
|
||
|
||
let tx_id = Hash::from_slice(&[1u8; 32]).unwrap();
|
||
let sender = Address::from_slice(&[1u8; 20]).unwrap();
|
||
let receiver = Address::from_slice(&[2u8; 20]).unwrap();
|
||
|
||
let tx = CrossShardTransaction::new(
|
||
tx_id.clone(),
|
||
1,
|
||
2,
|
||
sender,
|
||
receiver,
|
||
"GNACS-001".to_string(),
|
||
1000,
|
||
1000,
|
||
);
|
||
|
||
processor.submit_transaction(tx).unwrap();
|
||
|
||
let lock_proof = LockProof {
|
||
shard_id: 1,
|
||
block_hash: Hash::from_slice(&[2u8; 32]).unwrap(),
|
||
tx_hash: tx_id.clone(),
|
||
locked_at: 1001,
|
||
validator_signatures: vec![vec![1, 2, 3]; 3],
|
||
};
|
||
|
||
assert!(processor.process_lock(&tx_id, lock_proof).is_ok());
|
||
assert_eq!(processor.stats.locked_count, 1);
|
||
assert_eq!(processor.stats.pending_count, 0);
|
||
}
|
||
|
||
#[test]
|
||
fn test_processor_mark_failed() {
|
||
let mut processor = CrossShardTxProcessor::new(1);
|
||
|
||
let tx_id = Hash::from_slice(&[1u8; 32]).unwrap();
|
||
let sender = Address::from_slice(&[1u8; 20]).unwrap();
|
||
let receiver = Address::from_slice(&[2u8; 20]).unwrap();
|
||
|
||
let tx = CrossShardTransaction::new(
|
||
tx_id.clone(),
|
||
1,
|
||
2,
|
||
sender,
|
||
receiver,
|
||
"GNACS-001".to_string(),
|
||
1000,
|
||
1000,
|
||
);
|
||
|
||
processor.submit_transaction(tx).unwrap();
|
||
|
||
assert!(processor.mark_failed(&tx_id, "Test failure".to_string()).is_ok());
|
||
assert_eq!(processor.stats.failed_count, 1);
|
||
assert_eq!(processor.stats.pending_count, 0);
|
||
}
|
||
|
||
#[test]
|
||
fn test_processor_get_status() {
|
||
let mut processor = CrossShardTxProcessor::new(1);
|
||
|
||
let tx_id = Hash::from_slice(&[1u8; 32]).unwrap();
|
||
let sender = Address::from_slice(&[1u8; 20]).unwrap();
|
||
let receiver = Address::from_slice(&[2u8; 20]).unwrap();
|
||
|
||
let tx = CrossShardTransaction::new(
|
||
tx_id.clone(),
|
||
1,
|
||
2,
|
||
sender,
|
||
receiver,
|
||
"GNACS-001".to_string(),
|
||
1000,
|
||
1000,
|
||
);
|
||
|
||
processor.submit_transaction(tx).unwrap();
|
||
|
||
let status = processor.get_transaction_status(&tx_id);
|
||
assert_eq!(status, Some(CrossShardTxStatus::Pending));
|
||
}
|
||
|
||
#[test]
|
||
fn test_router_add_connection() {
|
||
let mut router = CrossShardRouter::new();
|
||
|
||
router.add_shard_connection(1, 2);
|
||
router.add_shard_connection(2, 3);
|
||
|
||
let neighbors = router.get_neighbors(2);
|
||
assert_eq!(neighbors.len(), 2);
|
||
assert!(neighbors.contains(&1));
|
||
assert!(neighbors.contains(&3));
|
||
}
|
||
|
||
#[test]
|
||
fn test_router_find_route() {
|
||
let mut router = CrossShardRouter::new();
|
||
|
||
router.add_shard_connection(1, 2);
|
||
router.add_shard_connection(2, 3);
|
||
router.add_shard_connection(3, 4);
|
||
|
||
let route = router.find_route(1, 4);
|
||
assert_eq!(route, Some(vec![1, 2, 3, 4]));
|
||
}
|
||
|
||
#[test]
|
||
fn test_router_no_route() {
|
||
let mut router = CrossShardRouter::new();
|
||
|
||
router.add_shard_connection(1, 2);
|
||
router.add_shard_connection(3, 4);
|
||
|
||
let route = router.find_route(1, 4);
|
||
assert_eq!(route, None);
|
||
}
|
||
|
||
#[test]
|
||
fn test_processor_cleanup_completed() {
|
||
let mut processor = CrossShardTxProcessor::new(1);
|
||
|
||
// 添加5个已完成交易
|
||
for i in 0..5 {
|
||
let tx_id = Hash::from_slice(&[i; 32]).unwrap();
|
||
let sender = Address::from_slice(&[1u8; 20]).unwrap();
|
||
let receiver = Address::from_slice(&[2u8; 20]).unwrap();
|
||
|
||
let mut tx = CrossShardTransaction::new(
|
||
tx_id.clone(),
|
||
1,
|
||
2,
|
||
sender,
|
||
receiver,
|
||
"GNACS-001".to_string(),
|
||
1000,
|
||
1000 + i as u64,
|
||
);
|
||
tx.status = CrossShardTxStatus::Completed;
|
||
processor.completed_txs.insert(tx_id, tx);
|
||
}
|
||
|
||
processor.stats.completed_count = 5;
|
||
|
||
// 保留最近3个
|
||
let removed = processor.cleanup_completed(3);
|
||
assert_eq!(removed, 2);
|
||
assert_eq!(processor.completed_txs.len(), 3);
|
||
}
|
||
}
|