根据您提供的标题和内容，我将整理ckb-fixed-hash库的使用指南。以下是完整的内容：

Rust哈希处理库ckb-fixed-hash的使用指南

介绍

ckb-fixed-hash是一个用于高效固定长度哈希计算与校验的Rust库，主要用于Nervos CKB区块链开发，但也适用于其他需要固定长度哈希处理的场景。该库提供了对固定长度哈希类型的支持，包括常用的哈希算法实现。

主要特性

• 提供固定长度哈希类型（如H160, H256, H512等）
• 高效的内存处理和计算性能
• 支持多种编码/解码格式（hex, JSON等）
• 提供常用的哈希操作和校验功能

完整示例代码

// main.rs
use ckb_fixed_hash::{H160, H256, H512};
use std::str::FromStr;
use serde_json::{json, to_string};

fn main() {
    // 基本哈希操作演示
    basic_hash_operations();
    
    // 哈希运算演示
    bitwise_operations();
    
    // 哈希校验演示
    validate_hashes();
    
    // JSON序列化演示
    json_serialization_demo();
}

fn basic_hash_operations() {
    println!("=== 基本哈希操作 ===");
    
    // 创建不同长度的全零哈希
    let h160_zero = H160::zero();
    let h256_zero = H256::zero();
    let h512_zero = H512::zero();
    println!("H160 zero: {:?}", h160_zero);
    println!("H256 zero: {:?}", h256_zero);
    println!("H512 zero: {:?}", h512_zero);
    
    // 从字符串解析哈希
    let h160_str = "0x1234567890abcdef1234567890abcdef12345678";
    let h160 = H160::from_str(h160_str).unwrap();
    println!("Parsed H160: {:?}", h160);
    
    // 随机生成哈希
    let random_h256 = H256::random();
    println!("Random H256: {:?}", random_h256);
    
    // 比较哈希
    let hash_a = H256::random();
    let hash_b = H256::random();
    println!("Hash comparison: {} == {}: {}", 
        hash_a, hash_b, hash_a == hash_b);
    
    // 转换为字节数组
    let bytes: [u8; 32] = random_h256.into();
    println!("H256 as bytes: {:?}", bytes);
}

fn bitwise_operations() {
    println!("\n=== 位运算操作 ===");
    
    let mut hash1 = H256::random();
    let hash2 = H256::random();
    
    println!("Original hash1: {:?}", hash1);
    println!("Original hash2: {:?}", hash2);
    
    // 按位与
    let and_result = hash1 & hash2;
    println!("AND result: {:?}", and_result);
    
    // 按位或
    let or_result = hash1 | hash2;
    println!("OR result: {:?}", or_result);
    
    // 按位异或
    let xor_result = hash1 ^ hash2;
    println!("XOR result: {:?}", xor_result);
    
    // 反转位
    hash1.reverse_bits();
    println!("Reversed bits hash1: {:?}", hash1);
}

fn validate_hashes() {
    println!("\n=== 哈希校验 ===");
    
    // 有效哈希示例
    let valid_h160 = "0x1234567890abcdef1234567890abcdef12345678";
    // 无效哈希示例（长度错误）
    let invalid_h160 = "0x1234567890abcdef1234567890abcdef1234567899";
    
    // 校验有效哈希
    match H160::from_str(valid_h160) {
        Ok(hash) => println!("有效H160哈希: {:?}", hash),
        Err(e) => println!("错误: {}", e),
    }
    
    // 校验无效哈希
    match H160::from_str(invalid_h160) {
        Ok(hash) => println!("有效H160哈希: {:?}", hash),
        Err(e) => println!("错误: {}", e),
    }
}

fn json_serialization_demo() {
    println!("\n=== JSON序列化 ===");
    
    let tx_hash = H256::random();
    let contract_hash = H160::random();
    
    // 创建包含哈希的复杂数据结构
    let blockchain_data = json!({
        "block": {
            "header": {
                "hash": tx_hash,
                "parent_hash": H256::random(),
            },
            "transactions": [
                {
                    "hash": tx_hash,
                    "contract": contract_hash,
                    "value": 1000u64
                },
                {
                    "hash": H256::random(),
                    "contract": H160::random(),
                    "value": 2000u64
                }
            ]
        }
    });
    
    // 序列化为JSON字符串
    let json_str = to_string(&blockchain_data).unwrap();
    println!("序列化的JSON数据:\n{}", json_str);
    
    // 从JSON反序列化
    let deserialized: serde_json::Value = serde_json::from_str(&json_str).unwrap();
    println!("反序列化的block.hash: {:?}", deserialized["block"]["header"]["hash"]);
}

Cargo.toml配置

[package]
name = "ckb-hash-demo"
version = "0.1.0"
edition = "2021"

[dependencies]
ckb-fixed-hash = "0.7.0"
serde_json = "1.0"

性能提示

1. 对于频繁的哈希比较操作，直接使用==运算符非常高效
2. 当需要创建大量哈希时，考虑使用H256::random()批量生成
3. 使用into()方法转换为字节数组比逐字节访问更高效

注意事项

• 输入字符串必须带有"0x"前缀
• 哈希长度必须严格匹配类型定义（如H256必须是64个十六进制字符）
• 某些操作可能会在无效输入时panic，生产代码中应做好错误处理

ckb-fixed-hash库为Rust开发者提供了高效且类型安全的固定长度哈希处理能力，特别适合区块链开发和其他需要严格哈希校验的场景。