Rust实用工具库tari_utilities的使用：高效处理加密、哈希和基础数据结构操作

Tari Utilities

![Security audit badge] ![Clippy badge]
![Coverage Status]

这个crate是Tari加密货币项目的一部分，提供了一系列在Tari项目中常用的实用工具。

主要功能模块

bit

提供整数和位数组之间转换的函数

byte_array

提供数据类型作为字节数组或十六进制字符串表示的trait

convert

尝试将一系列T类型转换为U类型的函数

encoding

处理base58编码和解码的trait

epoch_time

用u64表示时间的数据结构

extend_bytes

允许调用append_raw_bytes和获取类型原始字节的trait

fixed_set

描述大小为n的固定集合的数据结构

hash

简单的Hashable trait，描述对象应如何被哈希

hex

二进制和十六进制字符串之间转换的函数

locks

RwLock的宏

message_format

处理从二进制、json或base64转换的MessageFormat trait

Hidden

用于在日志中隐藏敏感信息的包装类型

功能标志

可以通过功能标志移除某些功能：

std

允许使用epoch_time、encoding和safe_array

zero

包含zeroize支持

serialize

包含serde支持

borsh

包含borsh支持

default

包含所有功能标志

示例代码

以下是使用tari_utilities进行哈希和hex转换的完整示例：

use tari_utilities::{hex::Hex, hash::Hashable};
use sha2::{Sha256, Digest};

// 定义可哈希的结构体
#[derive(Debug)]
struct Transaction {
    sender: String,
    receiver: String,
    amount: u64,
}

impl Hashable for Transaction {
    fn hash(&self) -> Vec<u8> {
        let mut hasher = Sha256::new();
        hasher.update(self.sender.as_bytes());
        hasher.update(self.receiver.as_bytes());
        hasher.update(self.amount.to_be_bytes());
        hasher.finalize().to_vec()
    }
}

fn main() {
    // 创建交易实例
    let tx = Transaction {
        sender: "Alice".to_string(),
        receiver: "Bob".to_string(),
        amount: 100,
    };
    
    // 计算交易哈希
    let tx_hash = tx.hash();
    
    // 将哈希值转换为hex字符串
    let hex_hash = tx_hash.to_hex();
    
    println!("Transaction hash (hex): {}", hex_hash);
    
    // 从hex字符串还原字节数组
    let restored_bytes = Vec::from_hex(&hex_hash).unwrap();
    assert_eq!(tx_hash, restored_bytes);
    
    println!("Original bytes: {:?}", tx_hash);
    println!("Restored bytes: {:?}", restored_bytes);
}

另一个使用byte_array和fixed_set的示例：

use tari_utilities::{byte_array::ByteArray, fixed_set::FixedSet};

// 测试ByteArray trait
fn test_byte_array<T: ByteArray>(data: &T) {
    println!("Original: {:?}", data);
    println!("As hex: {}", data.to_hex());
    println!("As bytes: {:?}", data.as_bytes());
}

// 测试FixedSet
fn test_fixed_set() {
    let mut set = FixedSet::<10>::default();
    set.insert(5);
    set.insert(3);
    set.insert(8);
    
    println!("Set contains 5: {}", set.contains(&5));
    println!("Set contains 7: {}", set.contains(&7));
    println!("Set items: {:?}", set.iter().collect::<Vec<_>>());
}

fn main() {
    // 测试ByteArray
    let num = 123456u64;
    test_byte_array(&num);
    
    // 测试FixedSet
    test_fixed_set();
}

完整示例demo

以下是一个结合多个tari_utilities功能的完整示例，展示如何使用加密哈希、base58编码和固定集合：

use tari_utilities::{hex::Hex, hash::Hashable, encoding::Base58, fixed_set::FixedSet};
use sha2::{Sha256, Digest};

// 定义可哈希的数据结构
#[derive(Debug)]
struct BlockHeader {
    version: u32,
    prev_hash: Vec<u8>,
    timestamp: u64,
    nonce: u64,
}

impl Hashable for BlockHeader {
    fn hash(&self) -> Vec<u8> {
        let mut hasher = Sha256::new();
        hasher.update(self.version.to_be_bytes());
        hasher.update(&self.prev_hash);
        hasher.update(self.timestamp.to_be_bytes());
        hasher.update(self.nonce.to_be_bytes());
        hasher.finalize().to_vec()
    }
}

// 实现Base58编码
fn encode_and_decode(hash: &[u8]) {
    let encoded = hash.to_base58();
    println!("Base58 encoded: {}", encoded);
    
    let decoded = Vec::from_base58(&encoded).unwrap();
    assert_eq!(hash, decoded.as_slice());
    println!("Base58 decoded matches original");
}

fn main() {
    // 1. 创建区块头并计算哈希
    let header = BlockHeader {
        version: 1,
        prev_hash: vec![0; 32], // 初始哈希全0
        timestamp: 1630000000,
        nonce: 12345,
    };
    
    let header_hash = header.hash();
    println!("Header hash (hex): {}", header_hash.to_hex());
    
    // 2. Base58编码演示
    encode_and_decode(&header_hash);
    
    // 3. 使用FixedSet存储已验证的交易哈希
    let mut verified_tx_set = FixedSet::<100>::default();
    verified_tx_set.insert(header_hash[0] as usize); // 简单示例，实际应用中会使用完整哈希
    
    println!("Set contains first byte of hash: {}", 
        verified_tx_set.contains(&(header_hash[0] as usize)));
    
    // 4. 使用Hidden类型保护敏感信息
    let sensitive = tari_utilities::Hidden::new("secret key".to_string());
    println!("Sensitive info hidden in logs: {:?}", sensitive);
}

要使用tari_utilities，请在你的Cargo.toml中添加以下依赖：

[dependencies]
tari_utilities = "0.8.0"
sha2 = "0.10"

这个示例展示了：

1. 使用Hashable trait为自定义结构计算SHA256哈希
2. Base58编码解码功能
3. FixedSet固定大小集合的使用
4. Hidden类型保护敏感信息不在日志中泄露
5. 十六进制字符串转换功能