Rust固定长度哈希处理库ckb-fixed-hash-macros的使用，支持高效哈希计算与宏简化开发

ckb-fixed-hash-macros

该crate是ckb的一个组件，提供几个过程宏(proc-macros)来构建常量固定大小的哈希值。

最低支持的Rust版本政策(MSRV)

该crate的最低支持rustc版本是1.85.0

安装方法

在项目目录中运行以下Cargo命令：

cargo add ckb-fixed-hash-macros

或者将以下行添加到您的Cargo.toml中：

ckb-fixed-hash-macros = "0.202.0"

示例代码

以下是内容中提供的使用ckb-fixed-hash-macros的完整示例：

use ckb_fixed_hash_macros::H256;

// 使用宏创建固定长度的哈希值
const MY_HASH: H256 = H256([
    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
    0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
    0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
    0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
]);

fn main() {
    println!("Fixed hash: {:?}", MY_HASH);
    
    // 你也可以在运行时创建哈希
    let runtime_hash = H256([
        0x1f, 0x1e, 0x1d, 0x1c, 0x1b, 0x1a, 0x19, 0x18,
        0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10,
        0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08,
        0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00,
    ]);
    
    println!("Runtime hash: {:?}", runtime_hash);
}

完整示例demo

以下是一个扩展的完整示例，展示更多使用场景：

use ckb_fixed_hash_macros::{H160, H256, H512};

fn main() {
    // H160示例 - 20字节哈希
    const ADDRESS_HASH: H160 = H160([
        0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
        0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
        0x01, 0x02, 0x03, 0x04
    ]);
    println!("H160 address hash: {:?}", ADDRESS_HASH);

    // H256示例 - 32字节哈希
    let tx_hash = H256([
        0x1a, 0x2b, 0x3c, 0x4d, 0x5e, 0x6f, 0x70, 0x81,
        0x92, 0xa3, 0xb4, 0xc5, 0xd6, 0xe7, 0xf8, 0x09,
        0x10, 0x21, 0x32, 0x43, 0x54, 0x65, 0x76, 0x87,
        0x98, 0xa9, 0xba, 0xcb, 0xdc, 0xed, 0xfe, 0x0f
    ]);
    println!("Transaction hash: {:x?}", tx_hash);

    // H512示例 - 64字节哈希
    const LARGE_HASH: H512 = H512([
        0x00; 64 // 全部初始化为0的64字节哈希
    ]);
    println!("Large hash: {:?}", LARGE_HASH);
    
    // 哈希数组操作示例
    let mut mutable_hash = H256([0u8; 32]);
    mutable_hash[0] = 0xff;
    println!("Modified hash: {:?}", mutable_hash);
}

文档

更多详细使用方法和API文档，请参考官方文档。

许可证

该项目采用MIT许可证。


1 回复

根据您提供的完整内容，以下是一个整合了所有功能的完整示例demo：

// 完整示例：ckb-fixed-hash-macros综合使用

// 1. 添加依赖到Cargo.toml
/*
[dependencies]
ckb-fixed-hash-macros = "0.1.0"
ckb-fixed-hash = "0.1.0"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
*/

use ckb_fixed_hash_macros::hash;
use ckb_fixed_hash::{H160, H256};
use serde::{Serialize, Deserialize};
use std::str::FromStr;

// 2. 自定义哈希类型
hash!([u8; 20], MyHash160, MyHash160Visitor);
hash!([u8; 32], MyHash256, MyHash256Visitor);

// 3. 定义可序列化的区块头结构
#[derive(Serialize, Deserialize, Debug)]
struct BlockHeader {
    prev_hash: H256,
    merkle_root: MyHash256,
    nonce: u64,
}

fn main() {
    // 4. 基本使用示例
    println!("=== 基本使用示例 ===");
    let zero_hash = MyHash256::zero();
    println!("Zero hash: {:?}", zero_hash);
    
    let bytes = [1u8; 32];
    let hash_from_bytes = MyHash256::from_slice(&bytes).unwrap();
    println!("Hash from bytes: {:?}", hash_from_bytes);
    
    // 5. 使用内置哈希类型
    println!("\n=== 内置哈希类型 ===");
    let address = H160::from_slice(&[0xab; 20]).unwrap();
    println!("H160 Address: {:?}", address);
    
    // 6. 自定义哈希类型使用
    println!("\n=== 自定义哈希类型 ===");
    let custom_hash = MyHash160::from_slice(&[0xcd; 20]).unwrap();
    println!("MyHash160: {:?}", custom_hash);
    
    // 7. 哈希运算
    println!("\n=== 哈希运算 ===");
    let hash1 = H256::from_str("0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef").unwrap();
    let hash2 = H256::from_str("0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890").unwrap();
    let xor_result = hash1 ^ hash2;
    println!("XOR result: {:?}", xor_result);
    
    // 8. 序列化示例
    println!("\n=== 序列化示例 ===");
    let header = BlockHeader {
        prev_hash: H256::zero(),
        merkle_root: MyHash256::from([1u8; 32]),
        nonce: 12345,
    };
    let serialized = serde_json::to_string(&header).unwrap();
    println!("Serialized header: {}", serialized);
    
    // 9. 性能优化示例
    println!("\n=== 性能优化示例 ===");
    let hashes = vec![H256::random(), H256::random(), H256::random()];
    let combined = process_hashes(&hashes);
    println!("Combined hash: {:?}", combined);
}

// 性能优化函数：重用哈希缓冲区
fn process_hashes(hashes: &[H256]) -> H256 {
    let mut result = H256::zero();
    for hash in hashes {
        // 使用位运算合并哈希
        for i in 0..32 {
            result.0[i] ^= hash.0[i];
        }
    }
    result
}

这个完整示例演示了：

  1. 如何使用宏创建自定义哈希类型
  2. 内置哈希类型的基本操作
  3. 哈希值的比较和运算
  4. 结合serde进行序列化/反序列化
  5. 性能优化技巧
  6. 各种创建哈希值的方式

要运行此示例，请确保Cargo.toml中包含所有必要的依赖项。

回到顶部