336 lines
11 KiB
Rust
336 lines
11 KiB
Rust
use crate::types::*;
|
||
use async_trait::async_trait;
|
||
use sled::Db;
|
||
use std::collections::HashMap;
|
||
use std::sync::Arc;
|
||
use tokio::sync::RwLock;
|
||
|
||
/// 验证器池trait
|
||
#[async_trait]
|
||
pub trait ValidatorPool: Send + Sync {
|
||
/// 注册验证器
|
||
async fn register_validator(&self, validator: ValidatorInfo) -> Result<()>;
|
||
|
||
/// 注销验证器
|
||
async fn unregister_validator(&self, address: Address) -> Result<()>;
|
||
|
||
/// 获取活跃验证器列表
|
||
async fn get_active_validators(&self) -> Result<Vec<ValidatorInfo>>;
|
||
|
||
/// 加载验证器（从数据库）
|
||
async fn load_validators(&self) -> Result<()>;
|
||
|
||
/// 验证消息签名
|
||
async fn verify_message_signatures(
|
||
&self,
|
||
message: &CrossChainMessage,
|
||
) -> Result<bool>;
|
||
|
||
/// 获取验证器信息
|
||
async fn get_validator(&self, address: Address) -> Result<ValidatorInfo>;
|
||
|
||
/// 更新验证器声誉
|
||
async fn update_reputation(&self, address: Address, delta: i64) -> Result<()>;
|
||
}
|
||
|
||
/// 验证器池实现
|
||
pub struct ValidatorPoolImpl {
|
||
db: Arc<Db>,
|
||
validators: Arc<RwLock<HashMap<Address, ValidatorInfo>>>,
|
||
config: BridgeConfig,
|
||
}
|
||
|
||
impl ValidatorPoolImpl {
|
||
pub fn new(db: Arc<Db>, config: BridgeConfig) -> Self {
|
||
let validators = Arc::new(RwLock::new(HashMap::new()));
|
||
Self {
|
||
db,
|
||
validators,
|
||
config,
|
||
}
|
||
}
|
||
|
||
/// 从数据库加载验证器
|
||
pub async fn load_validators(&self) -> Result<()> {
|
||
let prefix = b"validator:";
|
||
let mut validators = self.validators.write().await;
|
||
|
||
for item in self.db.scan_prefix(prefix) {
|
||
let (_, value) = item.map_err(|e| BridgeError::DatabaseError(e.to_string()))?;
|
||
let validator: ValidatorInfo = bincode::deserialize(&value)
|
||
.map_err(|e| BridgeError::DatabaseError(e.to_string()))?;
|
||
validators.insert(validator.address, validator);
|
||
}
|
||
|
||
log::info!("Loaded {} validators from database", validators.len());
|
||
Ok(())
|
||
}
|
||
|
||
/// 保存验证器到数据库
|
||
fn save_validator(&self, validator: &ValidatorInfo) -> Result<()> {
|
||
let key = format!("validator:{}", hex::encode(validator.address));
|
||
let value = bincode::serialize(validator)
|
||
.map_err(|e| BridgeError::DatabaseError(e.to_string()))?;
|
||
|
||
self.db.insert(key.as_bytes(), value)
|
||
.map_err(|e| BridgeError::DatabaseError(e.to_string()))?;
|
||
|
||
Ok(())
|
||
}
|
||
|
||
/// 从数据库删除验证器
|
||
fn delete_validator(&self, address: Address) -> Result<()> {
|
||
let key = format!("validator:{}", hex::encode(address));
|
||
self.db.remove(key.as_bytes())
|
||
.map_err(|e| BridgeError::DatabaseError(e.to_string()))?;
|
||
Ok(())
|
||
}
|
||
|
||
/// 从数据库加载所有验证器
|
||
fn load_all_validators(&self) -> Result<Vec<ValidatorInfo>> {
|
||
let mut validators = Vec::new();
|
||
let prefix = b"validator:";
|
||
|
||
for item in self.db.scan_prefix(prefix) {
|
||
let (_key, value) = item.map_err(|e| BridgeError::DatabaseError(e.to_string()))?;
|
||
let validator: ValidatorInfo = bincode::deserialize(&value)
|
||
.map_err(|e| BridgeError::DatabaseError(e.to_string()))?;
|
||
validators.push(validator);
|
||
}
|
||
|
||
Ok(validators)
|
||
}
|
||
|
||
/// 验证单个签名（使用NAC的签名验证）
|
||
fn verify_signature(
|
||
&self,
|
||
message_hash: &Hash,
|
||
signature: &Signature,
|
||
validator_address: &Address,
|
||
) -> bool {
|
||
// TODO: 实现实际的签名验证逻辑
|
||
// 这里简化实现，假设签名有效
|
||
true
|
||
}
|
||
}
|
||
|
||
#[async_trait]
|
||
impl ValidatorPool for ValidatorPoolImpl {
|
||
async fn register_validator(&self, validator: ValidatorInfo) -> Result<()> {
|
||
// 验证质押金额
|
||
let min_stake = 10_000 * 10u128.pow(18); // 最小质押10,000 NAC
|
||
if validator.stake_amount < min_stake {
|
||
return Err(BridgeError::Other(
|
||
format!("Insufficient stake: {} < {}", validator.stake_amount, min_stake)
|
||
));
|
||
}
|
||
|
||
// 保存到数据库
|
||
self.save_validator(&validator)?;
|
||
|
||
// 更新内存缓存
|
||
let mut validators = self.validators.write().await;
|
||
validators.insert(validator.address, validator.clone());
|
||
|
||
log::info!(
|
||
"Validator registered: address={}, stake={}",
|
||
hex::encode(validator.address),
|
||
validator.stake_amount
|
||
);
|
||
|
||
Ok(())
|
||
}
|
||
|
||
async fn unregister_validator(&self, address: Address) -> Result<()> {
|
||
// 从数据库删除
|
||
self.delete_validator(address)?;
|
||
|
||
// 从内存缓存删除
|
||
let mut validators = self.validators.write().await;
|
||
validators.remove(&address);
|
||
|
||
log::info!("Validator unregistered: address={}", hex::encode(address));
|
||
|
||
Ok(())
|
||
}
|
||
|
||
async fn get_active_validators(&self) -> Result<Vec<ValidatorInfo>> {
|
||
let validators = self.validators.read().await;
|
||
let active: Vec<ValidatorInfo> = validators
|
||
.values()
|
||
.filter(|v| v.is_active)
|
||
.cloned()
|
||
.collect();
|
||
|
||
Ok(active)
|
||
}
|
||
|
||
async fn verify_message_signatures(
|
||
&self,
|
||
message: &CrossChainMessage,
|
||
) -> Result<bool> {
|
||
// 检查签名数量
|
||
if message.signatures.len() < self.config.min_validator_signatures {
|
||
return Ok(false);
|
||
}
|
||
|
||
// 获取活跃验证器
|
||
let active_validators = self.get_active_validators().await?;
|
||
if active_validators.is_empty() {
|
||
return Err(BridgeError::Other("No active validators".to_string()));
|
||
}
|
||
|
||
// 计算消息哈希（NAC的48字节哈希）
|
||
let message_hash = message.id;
|
||
|
||
// 验证每个签名
|
||
let mut valid_signatures = 0;
|
||
for signature in &message.signatures {
|
||
for validator in &active_validators {
|
||
if self.verify_signature(&message_hash, signature, &validator.address) {
|
||
valid_signatures += 1;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 检查是否达到最小签名数
|
||
Ok(valid_signatures >= self.config.min_validator_signatures)
|
||
}
|
||
|
||
async fn get_validator(&self, address: Address) -> Result<ValidatorInfo> {
|
||
let validators = self.validators.read().await;
|
||
validators
|
||
.get(&address)
|
||
.cloned()
|
||
.ok_or(BridgeError::Other(format!("Validator not found: {:?}", address)))
|
||
}
|
||
|
||
async fn update_reputation(&self, address: Address, delta: i64) -> Result<()> {
|
||
let mut validators = self.validators.write().await;
|
||
|
||
if let Some(validator) = validators.get_mut(&address) {
|
||
if delta < 0 {
|
||
validator.reputation = validator.reputation.saturating_sub((-delta) as u64);
|
||
} else {
|
||
validator.reputation = validator.reputation.saturating_add(delta as u64);
|
||
}
|
||
|
||
// 保存到数据库
|
||
self.save_validator(validator)?;
|
||
|
||
log::info!(
|
||
"Validator reputation updated: address={}, new_reputation={}",
|
||
hex::encode(address),
|
||
validator.reputation
|
||
);
|
||
}
|
||
|
||
Ok(())
|
||
}
|
||
|
||
async fn load_validators(&self) -> Result<()> {
|
||
// 加载所有验证器到内存
|
||
let validators = self.load_all_validators()?;
|
||
let mut validator_map = self.validators.write().await;
|
||
for validator in validators {
|
||
validator_map.insert(validator.address, validator);
|
||
}
|
||
log::info!("Loaded {} validators from database", validator_map.len());
|
||
Ok(())
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
|
||
#[tokio::test]
|
||
async fn test_register_validator() {
|
||
let db = Arc::new(sled::Config::new().temporary(true).open().unwrap());
|
||
let config = BridgeConfig::default();
|
||
let pool = ValidatorPoolImpl::new(db, config);
|
||
|
||
let validator = ValidatorInfo {
|
||
address: [1u8; 32],
|
||
stake_amount: 10_000 * 10u128.pow(18),
|
||
reputation: 100,
|
||
is_active: true,
|
||
};
|
||
|
||
pool.register_validator(validator.clone()).await.unwrap();
|
||
|
||
let loaded = pool.get_validator(validator.address).await.unwrap();
|
||
assert_eq!(loaded.address, validator.address);
|
||
assert_eq!(loaded.stake_amount, validator.stake_amount);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn test_get_active_validators() {
|
||
let db = Arc::new(sled::Config::new().temporary(true).open().unwrap());
|
||
let config = BridgeConfig::default();
|
||
let pool = ValidatorPoolImpl::new(db, config);
|
||
|
||
// 注册2个活跃验证器
|
||
let validator1 = ValidatorInfo {
|
||
address: [1u8; 32],
|
||
stake_amount: 10_000 * 10u128.pow(18),
|
||
reputation: 100,
|
||
is_active: true,
|
||
};
|
||
|
||
let validator2 = ValidatorInfo {
|
||
address: [2u8; 32],
|
||
stake_amount: 20_000 * 10u128.pow(18),
|
||
reputation: 200,
|
||
is_active: true,
|
||
};
|
||
|
||
pool.register_validator(validator1).await.unwrap();
|
||
pool.register_validator(validator2).await.unwrap();
|
||
|
||
let active = pool.get_active_validators().await.unwrap();
|
||
assert_eq!(active.len(), 2);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn test_unregister_validator() {
|
||
let db = Arc::new(sled::Config::new().temporary(true).open().unwrap());
|
||
let config = BridgeConfig::default();
|
||
let pool = ValidatorPoolImpl::new(db, config);
|
||
|
||
let validator = ValidatorInfo {
|
||
address: [1u8; 32],
|
||
stake_amount: 10_000 * 10u128.pow(18),
|
||
reputation: 100,
|
||
is_active: true,
|
||
};
|
||
|
||
pool.register_validator(validator.clone()).await.unwrap();
|
||
pool.unregister_validator(validator.address).await.unwrap();
|
||
|
||
let result = pool.get_validator(validator.address).await;
|
||
assert!(result.is_err());
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn test_update_reputation() {
|
||
let db = Arc::new(sled::Config::new().temporary(true).open().unwrap());
|
||
let config = BridgeConfig::default();
|
||
let pool = ValidatorPoolImpl::new(db, config);
|
||
|
||
let validator = ValidatorInfo {
|
||
address: [1u8; 32],
|
||
stake_amount: 10_000 * 10u128.pow(18),
|
||
reputation: 100,
|
||
is_active: true,
|
||
};
|
||
|
||
pool.register_validator(validator.clone()).await.unwrap();
|
||
pool.update_reputation(validator.address, 50).await.unwrap();
|
||
|
||
let updated = pool.get_validator(validator.address).await.unwrap();
|
||
assert_eq!(updated.reputation, 150);
|
||
}
|
||
}
|