374 lines
13 KiB
Rust
374 lines
13 KiB
Rust
//! 钱包核心集成测试
|
||
|
||
use nac_wallet_core::*;
|
||
use nac_wallet_core::mnemonic::{Language, MnemonicLength};
|
||
use nac_wallet_core::multisig::{MultisigScheme, Signer};
|
||
use nac_wallet_core::security::{EncryptionConfig, AuditEvent, AuditEventType, Operation, PermissionLevel};
|
||
|
||
#[test]
|
||
fn test_mnemonic_to_address() {
|
||
// 创建助记词
|
||
let entropy = vec![0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
|
||
0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0];
|
||
let mnemonic = Mnemonic::from_entropy(&entropy, Language::English).expect("mainnet: handle error");
|
||
|
||
// 创建派生路径
|
||
let path = DerivationPath::bip44(60, 0, 0, 0);
|
||
|
||
// 生成地址
|
||
let address = AddressGenerator::from_mnemonic(&mnemonic, &path, "").expect("mainnet: handle error");
|
||
|
||
assert!(address.starts_with("0x"));
|
||
assert_eq!(address.len(), 42);
|
||
}
|
||
|
||
#[test]
|
||
fn test_batch_address_generation() {
|
||
// 创建助记词
|
||
let entropy = vec![0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
|
||
0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0];
|
||
let mnemonic = Mnemonic::from_entropy(&entropy, Language::English).expect("mainnet: handle error");
|
||
|
||
// 批量生成地址
|
||
let addresses = AddressGenerator::generate_addresses(&mnemonic, 60, 0, 10, "").expect("mainnet: handle error");
|
||
|
||
assert_eq!(addresses.len(), 10);
|
||
for (address, path) in addresses {
|
||
assert!(address.starts_with("0x"));
|
||
assert_eq!(path.components().len(), 5);
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn test_multisig_workflow() {
|
||
// 创建签名者
|
||
let signers = vec![
|
||
Signer::new("0x1111".to_string(), vec![1; 32]),
|
||
Signer::new("0x2222".to_string(), vec![2; 32]),
|
||
Signer::new("0x3333".to_string(), vec![3; 32]),
|
||
];
|
||
|
||
// 创建2-of-3多签配置
|
||
let config = MultisigConfig::m_of_n(signers.clone(), 2).expect("mainnet: handle error");
|
||
let address = MultisigAddress::from_config(config, 1000);
|
||
|
||
// 创建签名收集器
|
||
let mut collector = SignatureCollector::new();
|
||
collector.register_address(address.clone());
|
||
|
||
// 创建交易
|
||
let tx_id = collector.create_transaction(
|
||
address.address().to_string(),
|
||
vec![1, 2, 3, 4, 5],
|
||
1000
|
||
).expect("mainnet: handle error");
|
||
|
||
// 添加第一个签名
|
||
let sig1 = multisig::Signature::new(signers[0].address.clone(), vec![10, 20, 30], 1100);
|
||
collector.add_signature(&tx_id, sig1, 1100).expect("mainnet: handle error");
|
||
|
||
// 此时不能广播（只有1个签名）
|
||
assert!(!collector.can_broadcast(&tx_id).expect("mainnet: handle error"));
|
||
|
||
// 添加第二个签名
|
||
let sig2 = multisig::Signature::new(signers[1].address.clone(), vec![40, 50, 60], 1200);
|
||
collector.add_signature(&tx_id, sig2, 1200).expect("mainnet: handle error");
|
||
|
||
// 现在可以广播（有2个签名）
|
||
assert!(collector.can_broadcast(&tx_id).expect("mainnet: handle error"));
|
||
|
||
// 广播交易
|
||
collector.broadcast_transaction(&tx_id).expect("mainnet: handle error");
|
||
|
||
let tx = collector.get_transaction(&tx_id).expect("mainnet: handle error");
|
||
assert_eq!(tx.status, multisig::TransactionStatus::Broadcasted);
|
||
}
|
||
|
||
#[test]
|
||
fn test_weighted_multisig() {
|
||
// 创建加权签名者
|
||
let signers = vec![
|
||
Signer::new("0x1111".to_string(), vec![1; 32]).with_weight(3),
|
||
Signer::new("0x2222".to_string(), vec![2; 32]).with_weight(2),
|
||
Signer::new("0x3333".to_string(), vec![3; 32]).with_weight(1),
|
||
];
|
||
|
||
// 创建加权多签配置（阈值为4）
|
||
let config = MultisigConfig::weighted(signers.clone(), 4).expect("mainnet: handle error");
|
||
let address = MultisigAddress::from_config(config, 1000);
|
||
|
||
let mut collector = SignatureCollector::new();
|
||
collector.register_address(address.clone());
|
||
|
||
let tx_id = collector.create_transaction(
|
||
address.address().to_string(),
|
||
vec![1, 2, 3],
|
||
1000
|
||
).expect("mainnet: handle error");
|
||
|
||
// 添加权重为3的签名（不够）
|
||
let sig1 = multisig::Signature::new(signers[0].address.clone(), vec![1], 1100);
|
||
collector.add_signature(&tx_id, sig1, 1100).expect("mainnet: handle error");
|
||
assert!(!collector.can_broadcast(&tx_id).expect("mainnet: handle error"));
|
||
|
||
// 添加权重为2的签名（总权重5，超过阈值4）
|
||
let sig2 = multisig::Signature::new(signers[1].address.clone(), vec![2], 1200);
|
||
collector.add_signature(&tx_id, sig2, 1200).expect("mainnet: handle error");
|
||
assert!(collector.can_broadcast(&tx_id).expect("mainnet: handle error"));
|
||
}
|
||
|
||
#[test]
|
||
fn test_hardware_wallet_integration() {
|
||
// 创建设备管理器
|
||
let mut manager = DeviceManager::new();
|
||
|
||
// 扫描设备
|
||
let devices = manager.scan_devices().expect("mainnet: handle error");
|
||
assert!(devices.len() >= 2);
|
||
|
||
// 连接Ledger设备
|
||
manager.connect_ledger("ledger_001".to_string()).expect("mainnet: handle error");
|
||
assert!(manager.is_connected("ledger_001"));
|
||
|
||
// 连接Trezor设备
|
||
manager.connect_trezor("trezor_001".to_string()).expect("mainnet: handle error");
|
||
assert!(manager.is_connected("trezor_001"));
|
||
|
||
// 断开设备
|
||
manager.disconnect("ledger_001").expect("mainnet: handle error");
|
||
assert!(!manager.is_connected("ledger_001"));
|
||
}
|
||
|
||
#[test]
|
||
fn test_secure_storage_workflow() {
|
||
// 创建安全存储
|
||
let mut storage = SecureStorage::default();
|
||
|
||
// 存储多个密钥
|
||
let password = "strong_password";
|
||
storage.store_key("key1".to_string(), b"secret_data_1", password).expect("mainnet: handle error");
|
||
storage.store_key("key2".to_string(), b"secret_data_2", password).expect("mainnet: handle error");
|
||
storage.store_key("key3".to_string(), b"secret_data_3", password).expect("mainnet: handle error");
|
||
|
||
// 列出所有密钥
|
||
let keys = storage.list_keys();
|
||
assert_eq!(keys.len(), 3);
|
||
|
||
// 获取密钥
|
||
let data1 = storage.get_key("key1", password).expect("mainnet: handle error");
|
||
assert_eq!(data1, b"secret_data_1");
|
||
|
||
// 删除密钥
|
||
storage.delete_key("key2").expect("mainnet: handle error");
|
||
assert_eq!(storage.list_keys().len(), 2);
|
||
}
|
||
|
||
#[test]
|
||
fn test_permission_control() {
|
||
// 创建权限控制器
|
||
let mut controller = PermissionController::new();
|
||
|
||
// 添加用户
|
||
controller.add_user("user1".to_string(), PermissionLevel::ReadOnly);
|
||
controller.add_user("user2".to_string(), PermissionLevel::ReadWrite);
|
||
controller.add_user("admin".to_string(), PermissionLevel::Admin);
|
||
|
||
// 检查权限
|
||
assert!(controller.check_permission("user1", Operation::Read).is_ok());
|
||
assert!(controller.check_permission("user1", Operation::Write).is_err());
|
||
|
||
assert!(controller.check_permission("user2", Operation::Read).is_ok());
|
||
assert!(controller.check_permission("user2", Operation::Write).is_ok());
|
||
assert!(controller.check_permission("user2", Operation::Delete).is_err());
|
||
|
||
assert!(controller.check_permission("admin", Operation::Read).is_ok());
|
||
assert!(controller.check_permission("admin", Operation::Write).is_ok());
|
||
assert!(controller.check_permission("admin", Operation::Delete).is_ok());
|
||
assert!(controller.check_permission("admin", Operation::Export).is_ok());
|
||
}
|
||
|
||
#[test]
|
||
fn test_security_audit() {
|
||
// 创建审计器
|
||
let mut auditor = SecurityAuditor::new(1000);
|
||
|
||
// 记录事件
|
||
auditor.log_event(AuditEvent::new(
|
||
AuditEventType::KeyCreated,
|
||
"user1".to_string(),
|
||
"key1".to_string(),
|
||
None,
|
||
true,
|
||
1000,
|
||
"Created new key".to_string()
|
||
));
|
||
|
||
auditor.log_event(AuditEvent::new(
|
||
AuditEventType::KeyAccessed,
|
||
"user1".to_string(),
|
||
"key1".to_string(),
|
||
Some(Operation::Read),
|
||
true,
|
||
2000,
|
||
"Accessed key".to_string()
|
||
));
|
||
|
||
auditor.log_event(AuditEvent::new(
|
||
AuditEventType::AuthenticationFailed,
|
||
"user1".to_string(),
|
||
"key1".to_string(),
|
||
None,
|
||
false,
|
||
3000,
|
||
"Wrong password".to_string()
|
||
));
|
||
|
||
// 查询事件
|
||
let user1_events = auditor.query_events(Some("user1"), None);
|
||
assert_eq!(user1_events.len(), 3);
|
||
|
||
let failed_events = auditor.get_failed_events();
|
||
assert_eq!(failed_events.len(), 1);
|
||
|
||
// 获取统计
|
||
let stats = auditor.get_user_stats("user1");
|
||
assert_eq!(stats.total_events, 3);
|
||
assert_eq!(stats.successful_events, 2);
|
||
assert_eq!(stats.failed_events, 1);
|
||
}
|
||
|
||
#[test]
|
||
fn test_complete_wallet_workflow() {
|
||
// 1. 创建助记词
|
||
let entropy = vec![0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
|
||
0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0];
|
||
let mnemonic = Mnemonic::from_entropy(&entropy, Language::English).expect("mainnet: handle error");
|
||
|
||
// 2. 派生密钥
|
||
let seed = mnemonic.to_seed("");
|
||
let master_key = ExtendedKey::from_seed(&seed).expect("mainnet: handle error");
|
||
let path = DerivationPath::bip44(60, 0, 0, 0);
|
||
let derived_key = master_key.derive_path(&path).expect("mainnet: handle error");
|
||
|
||
// 3. 加密存储密钥
|
||
let mut storage = SecureStorage::default();
|
||
let password = "my_secure_password";
|
||
storage.store_key("master_key".to_string(), derived_key.private_key(), password).expect("mainnet: handle error");
|
||
|
||
// 4. 设置权限
|
||
let mut controller = PermissionController::new();
|
||
controller.add_user("owner".to_string(), PermissionLevel::Admin);
|
||
|
||
// 5. 审计日志
|
||
let mut auditor = SecurityAuditor::new(1000);
|
||
auditor.log_event(AuditEvent::new(
|
||
AuditEventType::KeyCreated,
|
||
"owner".to_string(),
|
||
"master_key".to_string(),
|
||
None,
|
||
true,
|
||
1000,
|
||
"Wallet initialized".to_string()
|
||
));
|
||
|
||
// 6. 验证工作流
|
||
assert!(storage.has_key("master_key"));
|
||
assert!(controller.check_permission("owner", Operation::Export).is_ok());
|
||
assert_eq!(auditor.get_all_events().len(), 1);
|
||
}
|
||
|
||
#[test]
|
||
fn test_multisig_with_security() {
|
||
// 创建多签钱包
|
||
let signers = vec![
|
||
Signer::new("0x1111".to_string(), vec![1; 32]),
|
||
Signer::new("0x2222".to_string(), vec![2; 32]),
|
||
];
|
||
let config = MultisigConfig::m_of_n(signers.clone(), 2).expect("mainnet: handle error");
|
||
let address = MultisigAddress::from_config(config, 1000);
|
||
|
||
// 设置权限
|
||
let mut controller = PermissionController::new();
|
||
controller.add_user("0x1111".to_string(), PermissionLevel::ReadWrite);
|
||
controller.add_user("0x2222".to_string(), PermissionLevel::ReadWrite);
|
||
|
||
// 审计
|
||
let mut auditor = SecurityAuditor::new(1000);
|
||
|
||
// 创建交易
|
||
let mut collector = SignatureCollector::new();
|
||
collector.register_address(address.clone());
|
||
let tx_id = collector.create_transaction(
|
||
address.address().to_string(),
|
||
vec![1, 2, 3],
|
||
1000
|
||
).expect("mainnet: handle error");
|
||
|
||
// 第一个签名者签名
|
||
if controller.check_permission("0x1111", Operation::Sign).is_ok() {
|
||
let sig1 = multisig::Signature::new(signers[0].address.clone(), vec![1], 1100);
|
||
collector.add_signature(&tx_id, sig1, 1100).expect("mainnet: handle error");
|
||
|
||
auditor.log_event(AuditEvent::new(
|
||
AuditEventType::SignOperation,
|
||
"0x1111".to_string(),
|
||
tx_id.clone(),
|
||
Some(Operation::Sign),
|
||
true,
|
||
1100,
|
||
"Signed multisig transaction".to_string()
|
||
));
|
||
}
|
||
|
||
// 第二个签名者签名
|
||
if controller.check_permission("0x2222", Operation::Sign).is_ok() {
|
||
let sig2 = multisig::Signature::new(signers[1].address.clone(), vec![2], 1200);
|
||
collector.add_signature(&tx_id, sig2, 1200).expect("mainnet: handle error");
|
||
|
||
auditor.log_event(AuditEvent::new(
|
||
AuditEventType::SignOperation,
|
||
"0x2222".to_string(),
|
||
tx_id.clone(),
|
||
Some(Operation::Sign),
|
||
true,
|
||
1200,
|
||
"Signed multisig transaction".to_string()
|
||
));
|
||
}
|
||
|
||
// 验证
|
||
assert!(collector.can_broadcast(&tx_id).expect("mainnet: handle error"));
|
||
assert_eq!(auditor.get_all_events().len(), 2);
|
||
}
|
||
|
||
#[test]
|
||
fn test_hardware_wallet_with_security() {
|
||
// 创建设备管理器
|
||
let mut manager = DeviceManager::new();
|
||
|
||
// 权限控制
|
||
let mut controller = PermissionController::new();
|
||
controller.add_user("user1".to_string(), PermissionLevel::Admin);
|
||
|
||
// 审计
|
||
let mut auditor = SecurityAuditor::new(1000);
|
||
|
||
// 连接硬件钱包（需要管理员权限）
|
||
if controller.check_permission("user1", Operation::Write).is_ok() {
|
||
manager.connect_ledger("ledger_001".to_string()).expect("mainnet: handle error");
|
||
|
||
auditor.log_event(AuditEvent::new(
|
||
AuditEventType::KeyAccessed,
|
||
"user1".to_string(),
|
||
"ledger_001".to_string(),
|
||
Some(Operation::Write),
|
||
true,
|
||
1000,
|
||
"Connected hardware wallet".to_string()
|
||
));
|
||
}
|
||
|
||
assert!(manager.is_connected("ledger_001"));
|
||
assert_eq!(auditor.get_all_events().len(), 1);
|
||
}
|