Rust区块链容量计算库ckb-occupied-capacity-core的使用，高效处理CKB网络中的存储空间占用计算

ckb-occupied-capacity-core

这个crate是ckb的一个组件。

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

这个crate的最低支持rustc版本是1.85.0

安装

在你的项目目录中运行以下Cargo命令:

cargo add ckb-occupied-capacity-core

或者在你的Cargo.toml中添加以下行:

ckb-occupied-capacity-core = "0.202.0"

完整示例demo

下面是一个使用ckb-occupied-capacity-core计算CKB网络存储空间占用的完整示例:

use ckb_occupied_capacity_core::{Capacity, OccupiedCapacity};

fn main() {
    // 创建一个容量对象
    let capacity = Capacity::bytes(100).unwrap();
    
    // 计算占用容量
    let occupied = OccupiedCapacity::new(capacity);
    
    // 获取占用容量值
    println!("Occupied capacity: {}", occupied.value());
    
    // 验证容量是否足够
    let required = Capacity::bytes(50).unwrap();
    if occupied.is_enough_for(&required) {
        println!("There is enough capacity");
    } else {
        println!("Not enough capacity");
    }
}

仓库

这个crate的源代码位于GitHub仓库。

所有者

这个crate的主要维护者是:

  • ian (doitian)

1 回复

以下是基于您提供内容的完整示例demo，先展示原有示例，再提供完整实现：

原有内容中的示例

计算Cell容量

use ckb_occupied_capacity_core::{Capacity, CellOutput};
use ckb_types::{bytes::Bytes, packed, prelude::*};

fn calculate_cell_capacity() -> Capacity {
    let output = CellOutput::new_builder()
        .capacity(100u64.pack())
        .lock(
            packed::Script::new_builder()
                .code_hash([0u8; 32].pack())
                .hash_type(ckb_types::core::ScriptHashType::Data.pack())
                .args(Bytes::from(&b"lock_args"[..]).pack())
                .build(),
        )
        .build();
    
    output.occupied_capacity().unwrap()
}

计算Transaction容量

use ckb_occupied_capacity_core::{Capacity, TransactionBuilder};
use ckb_types::{packed, prelude::*};

fn calculate_tx_capacity() -> Capacity {
    let tx = TransactionBuilder::default()
        .outputs(vec![
            packed::CellOutput::new_builder()
                .capacity(100u64.pack())
                .build(),
        ])
        .outputs_data(vec![Bytes::from(&b"output_data"[..]).pack()])
        .build();
    
    tx.occupied_capacity().unwrap()
}

完整示例Demo

// 完整示例：计算CKB交易中所有输出的总容量
use ckb_occupied_capacity_core::{Capacity, TransactionBuilder};
use ckb_types::{bytes::Bytes, packed, prelude::*};

fn main() {
    // 创建包含多个输出的交易
    let tx = TransactionBuilder::default()
        .outputs(vec![
            // 输出1：容量100，数据"output1"
            packed::CellOutput::new_builder()
                .capacity(100u64.pack())
                .build(),
            // 输出2：容量200，数据"output2"
            packed::CellOutput::new_builder()
                .capacity(200u64.pack())
                .build(),
        ])
        .outputs_data(vec![
            Bytes::from(&b"output1"[..]).pack(),
            Bytes::from(&b"output2"[..]).pack(),
        ])
        .build();

    // 计算交易总占用容量
    match tx.occupied_capacity() {
        Ok(capacity) => {
            println!("交易总占用容量: {}", capacity);
            
            // 计算每个单独输出的容量
            let outputs_capacity: Vec<Capacity> = tx.outputs()
                .into_iter()
                .map(|output| output.occupied_capacity().unwrap())
                .collect();
                
            println!("各输出容量: {:?}", outputs_capacity);
        }
        Err(e) => eprintln!("计算容量出错: {}", e),
    }

    // 自定义数据结构容量计算示例
    let custom_data = CustomData {
        field1: 42,
        field2: Bytes::from(&b"custom_data"[..]),
    };
    println!("自定义数据容量: {}", custom_data.occupied_capacity().unwrap());
}

// 自定义数据结构实现OccupiedCapacity
struct CustomData {
    field1: u32,
    field2: Bytes,
}

impl ckb_occupied_capacity_core::OccupiedCapacity for CustomData {
    fn occupied_capacity(&self) -> Result<Capacity, ckb_error::Error> {
        let field1_size = 4; // u32固定4字节
        let field2_size = self.field2.len();
        Capacity::bytes(field1_size + field2_size)
    }
}

输出说明

  1. 首先会计算整个交易的占用容量
  2. 然后分别计算交易中每个输出的占用容量
  3. 最后演示自定义数据结构的容量计算
  4. 所有操作都包含错误处理

这个完整示例展示了：

  • 交易容量的批量计算
  • 单个Cell容量的计算
  • 自定义数据结构的容量实现
  • 完善的错误处理机制

您可以直接运行这个示例来查看不同类型数据的容量计算结果。

回到顶部