CKB Std

https://github.com/nervosnetwork/ckb-std
Admin
CKB Std is a Rust library that provides essential modules, safe high-level APIs, and low-level...
Tokens:35,101
Snippets:437
Trust Score:9.6
Update:2 months ago
Show doc for...
Tokens:
Raw
### List repository examples

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/README.md

Navigate to the examples directory and list available files.

```bash
cd /workspace/home/ckb-std
ls examples/
```

--------------------------------

### Configure libc_alloc! usage

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/macros.md

Example for initializing the libc allocator for FFI compatibility.

```rust
use ckb_std::libc_alloc;
libc_alloc!()
```

--------------------------------

### Create a C shared library

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/dynamic_loading.md

Example of defining functions in C with default visibility for dynamic loading.

```c
// math_lib.c
__attribute__((visibility("default")))
int add(int a, int b) {
    return a + b;
}

__attribute__((visibility("default")))
const char* greet() {
    return "Hello from library";
}
```

--------------------------------

### Implement entry_simulator! macro

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/macros.md

Example usage of the entry_simulator! macro for testing purposes on x64 platforms.

```rust
#[cfg(feature = "native-simulator")]
use ckb_std::entry_simulator;

#[cfg(feature = "native-simulator")]
entry_simulator!(main)

fn main() -> i8 {
    0
}
```

--------------------------------

### Use assert! macro

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/macros.md

Examples of using the assert! macro with single and multiple conditions.

```rust
use ckb_std::assert;

let balance = 100u64;
assert!(10, balance >= 50);  // Exit with code 10 if balance < 50

let count = 5;
assert!(20, count > 0 && count < 10);  // Multi-condition assertion
```

--------------------------------

### Use EpochNumberWithFraction

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/types.md

Example demonstrating creation, accessors, comparison, and addition of epoch values.

```rust
use ckb_std::since::EpochNumberWithFraction;

// Epoch 100, block 42 of 144 blocks
let epoch = EpochNumberWithFraction::new(100, 42, 144);

println!("Epoch: {}", epoch.number());      // 100
println!("Block in epoch: {}", epoch.index());  // 42
println!("Epoch length: {}", epoch.length());   // 144

// Compare epochs
let epoch2 = EpochNumberWithFraction::new(100, 50, 144);
if epoch < epoch2 {
    println!("epoch is earlier in the same epoch");
}

// Add epochs
let sum = (epoch + epoch2)?;  // Option result
```

--------------------------------

### Configure default_alloc! usage

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/macros.md

Examples for using the default_alloc! macro with default or custom heap sizes.

```rust
// Use default allocation strategy
use ckb_std::default_alloc;
default_alloc!()

// Or customize for your contract
default_alloc!(4 * 1024, 1024 * 1024, 64);  // 1 MB dynamic heap
```

--------------------------------

### Implement entry! macro

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/macros.md

Example usage of the entry! macro at the crate root to define the main function.

```rust
use ckb_std::entry;

entry!(main)

fn main() -> i8 {
    // Script logic here
    if verify_signature() {
        0  // Success
    } else {
        1  // Verification failed
    }
}
```

--------------------------------

### Use Since locks

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/types.md

Example demonstrating the creation and conditional checking of absolute and relative locks.

```rust
use ckb_std::since::Since;

// Absolute lock: UTXOs mature after block 1000000
let since = Since::from_block_number(1_000_000, true)?;

// Relative lock: UTXOs mature 100 blocks after being created
let since = Since::from_block_number(100, false)?;

// Check if mature
if since.is_relative() {
    // Need to compare against base block
} else {
    // Can directly compare
}
```

--------------------------------

### logger::init()

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/logger.md

Initializes the logger system. This must be called once at the start of the script before any logging macros are used.

```APIDOC
## logger::init()

### Description
Initializes the logger. Must be called once at the start of your script to enable colored logging output.

### Signature
`pub fn init() -> Result<(), SetLoggerError>`

### Returns
- `Result<(), SetLoggerError>` - Returns Ok(()) on success, or a SetLoggerError if the logger was already initialized or could not be set as default.

### Example
```rust
use ckb_std::logger;

fn main() -> i8 {
    logger::init().ok();
    log::info!("Script started");
    0
}
```
```

--------------------------------

### Initialize the Logger

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/logger.md

Call this function once at the start of the script before using any logging macros.

```rust
pub fn init() -> Result<(), SetLoggerError>
```

```rust
use ckb_std::logger;

fn main() -> i8 {
    logger::init().ok();  // Ignore errors (logger may already be set)
    
    log::info!("Script started");
    0
}
```

--------------------------------

### QueryIter Usage Examples

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/high_level_api.md

Demonstrates iterating over input and output cells to perform calculations or filtering. Note that the iterator panics on errors other than IndexOutOfBound.

```rust
use ckb_std::high_level::{QueryIter, load_cell_capacity, Source};

// Iterate all input cells
let iter = QueryIter::new(load_cell_capacity, Source::Input);

// Sum all input capacities
let total_input: u64 = iter
    .map(|cap| cap.unwrap_or(0))
    .sum();

// Count all output cells
let output_count = QueryIter::new(load_cell_capacity, Source::Output)
    .count();

// Find cells matching criteria
for (index, capacity) in QueryIter::new(load_cell_capacity, Source::Output)
    .enumerate()
    .filter_map(|(i, cap)| cap.ok().map(|c| (i, c)))
{
    if capacity > 10000000000 {
        println!("Found large cell at output index {}", index);
    }
}
```

--------------------------------

### Use assert_eq! macro

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/macros.md

Example of using the assert_eq! macro to compare values with a custom exit code.

```rust
use ckb_std::assert_eq;

let expected_len = 32;
let actual = some_hash.len();
assert_eq!(15, expected_len, actual);  // Exit with code 15 if lengths differ
```

--------------------------------

### load_header_epoch_start_block_number

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/high_level_api.md

Loads the starting block number of an epoch from a header.

```APIDOC
## load_header_epoch_start_block_number(index: usize, source: Source) -> Result<u64, SysError>

### Description
Loads the starting block number of an epoch from a header.

### Parameters
- **index** (usize) - Required - Header index
- **source** (Source) - Required - Header source

### Returns
- **Result<u64, SysError>** - Epoch start block number
```

--------------------------------

### Initialize Logger and Handle Errors

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/logger.md

Initialize the logger at the start of your process and handle potential initialization failures.

```rust
fn process_transaction() -> i8 {
    if let Err(e) = logger::init() {
        // Logging setup failed, fall back to debug macro
        return 1;
    }

    match load_transaction() {
        Ok(tx) => {
            info!("Loaded transaction");
            validate_tx(&tx)
        }
        Err(e) => {
            error!("Failed to load transaction: {:?}", e);
            1
        }
    }
}
```

--------------------------------

### Load header epoch start block number in Rust

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/high_level_api.md

Retrieves the starting block number of an epoch from a header.

```rust
pub fn load_header_epoch_start_block_number(index: usize, source: Source) -> Result<u64, SysError>
```

--------------------------------

### Use assert_ne! macro

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/macros.md

Example of using the assert_ne! macro to ensure inequality with a custom exit code.

```rust
use ckb_std::assert_ne;

let code = 0;
assert_ne!(5, code, 0);  // Exit with code 5 if code == 0
```

--------------------------------

### Extract LockValue

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/types.md

Example showing how to extract and match on the underlying metric of a Since lock.

```rust
use ckb_std::since::Since;

let since = Since::new(0x1000000000000064); // 100 blocks, relative
if let Some(lock) = since.extract_lock_value() {
    match lock.block_number() {
        Some(blocks) => println!("Relative block lock: {} blocks", blocks),
        None => println!("Not a block-based lock"),
    }
}
```

--------------------------------

### Debug Syscall Usage

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/syscalls.md

Example of using the debug syscall to output formatted messages to CKB node logs.

```rust
use ckb_std::syscalls;

syscalls::debug(alloc::format!("Debug message: {}", value));
```

--------------------------------

### Use debug! macro in Rust

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/macros.md

Example usage of the debug! macro within a main function to log transaction data.

```rust
use ckb_std::debug;
use ckb_std::high_level;

fn main() -> i8 {
    let tx_hash = high_level::load_tx_hash().unwrap();
    debug!("Transaction hash loaded");
    debug!("First 4 bytes: {:02x?}", &tx_hash[..4]);
    0
}
```

--------------------------------

### Load Cell Capacity Function Signature

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/INDEX.md

Example of the function signature for loading cell capacity in the high-level API.

```rust
pub fn load_cell_capacity(index: usize, source: Source) -> Result<u64, SysError>
```

--------------------------------

### Define Entry Point

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/README.md

Sets up the main entry point for the smart contract using the entry macro.

```rust
use ckb_std::entry;

entry!(main)

fn main() -> i8 {
    // Validation logic
    if validate() {
        0  // Success
    } else {
        1  // Failure
    }
}
```

--------------------------------

### entry!

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/macros.md

Defines the program entry point (_start function) and sets up the panic handler, lang items, and argument passing for a CKB contract script.

```APIDOC
## entry!(main)

### Description
Defines the program entry point (_start function) and sets up the panic handler, lang items, and argument passing for a CKB contract script. The provided function must have the signature `fn() -> i8` and return an exit code.

### Parameters
- **main** (path) - Required - The function name (typically `main`) to be used as the entry point.

### Requirements
- Must be at the crate root.
- Only valid for `riscv64` target.
- Requires `extern crate alloc`.

### Example
```rust
use ckb_std::entry;

entry!(main)

fn main() -> i8 {
    if verify_signature() {
        0
    } else {
        1
    }
}
```

--------------------------------

### Build with native simulator

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/features_and_modules.md

Enable the CKB x64 simulator for local development and testing via cargo features.

```bash
cargo build --features native-simulator
```

--------------------------------

### entry_simulator!

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/macros.md

Alternative entry point for native simulator testing, suitable for x64 simulator execution.

```APIDOC
## entry_simulator!(main)

### Description
An alternative entry point macro for native simulator testing. It omits RISC-V-specific _start assembly and does not require the specific stack layout used on-chain.

### Features
- Requires `native-simulator` feature flag.

### Example
```rust
#[cfg(feature = "native-simulator")]
use ckb_std::entry_simulator;

#[cfg(feature = "native-simulator")]
entry_simulator!(main)

fn main() -> i8 {
    0
}
```

--------------------------------

### Load and use a shared library in Rust

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/dynamic_loading.md

Demonstrates initializing a CKBDLContext, loading a library by its hash, and retrieving symbols to execute functions.

```rust
use ckb_std::dynamic_loading::{CKBDLContext, Symbol};
use ckb_std::error::SysError;

/// SHA256 hash of the compiled shared library cell
const MATH_LIB_HASH: [u8; 32] = [
    235, 179, 185, 44, 159, 213, 242, 94, 42, 196, 68, 5, 213, 248, 71, 106,
    136, 183, 99, 125, 37, 214, 63, 59, 57, 87, 65, 80, 177, 92, 23, 255,
];

entry!(main)

fn main() -> i8 {
    // Create context with 64 KB buffer (page-aligned)
    let mut context = unsafe { CKBDLContext::<[u8; 64 * 1024]>::new() };

    // Load the library
    let lib = match context.load(&MATH_LIB_HASH) {
        Ok(lib) => lib,
        Err(_) => return 1,
    };

    // Load and call functions
    unsafe {
        // Function: int add(int a, int b)
        type AddFn = unsafe extern "C" fn(u64, u64) -> u64;
        let add: Symbol<AddFn> = match lib.get(b"add") {
            Some(sym) => sym,
            None => return 2,
        };

        let result = add(10, 20);
        if result != 30 {
            return 3;
        }

        // Function: const char* greet()
        type GreetFn = unsafe extern "C" fn() -> *const u8;
        let greet: Symbol<GreetFn> = match lib.get(b"greet") {
            Some(sym) => sym,
            None => return 4,
        };

        let msg_ptr = greet();
        // msg_ptr points to a C string in the library
    }

    debug!("Library loaded and used successfully");
    0
}
```

--------------------------------

### Initialize CKBDLContext

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/dynamic_loading.md

Creates a new context with a page-aligned buffer. The buffer size must be explicitly defined.

```rust
#[deprecated(since = "0.7.3")]
pub unsafe fn new() -> Self
```

```rust
use ckb_std::dynamic_loading::CKBDLContext;

// Allocate 64 KB buffer (must be page-aligned)
let mut context = unsafe { CKBDLContext::<[u8; 64 * 1024]>::new() };
```

--------------------------------

### Configure Minimal Build

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/README.md

Use this configuration in Cargo.toml to include only essential features.

```toml
ckb-std = { version = "1.1.0", default-features = false, features = ["ckb-types"] }
```

--------------------------------

### Initialize and use logging

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/features_and_modules.md

Set up the logger module to enable standard Rust log macros for debugging.

```rust
use ckb_std::logger;

fn main() -> i8 {
    logger::init().ok();
    
    log::info!("Script started");
    log::warn!("Something might be wrong");
    log::error!("An error occurred");
    
    0
}
```

--------------------------------

### Define entry! macro

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/macros.md

Defines the program entry point and sets up the panic handler and argument passing for a CKB contract script.

```rust
#[macro_export]
macro_rules! entry {
    ($main:path) => { ... }
}
```

--------------------------------

### Compile for CKB-VM

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/README.md

Commands to add the required target and build the project.

```bash
rustup target add riscv64imac-unknown-none-elf

cargo build --target=riscv64imac-unknown-none-elf
```

--------------------------------

### Get Library consumed size

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/dynamic_loading.md

Returns the number of bytes of the buffer actually used for the loaded library.

```rust
pub fn consumed_size(&self) -> usize
```

```rust
let lib = context.load(&code_hash)?;
println!("Library uses {} bytes", lib.consumed_size());
```

--------------------------------

### Define entry_simulator! macro

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/macros.md

Defines an alternative entry point for native simulator testing, excluding RISC-V specific assembly.

```rust
#[cfg(feature = "native-simulator")]
#[macro_export]
macro_rules! entry_simulator {
    ($main:path) => { ... }
}
```

--------------------------------

### Declare and use syscalls module

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/features_and_modules.md

Include the syscalls module and demonstrate loading a cell using the low-level API.

```rust
pub mod syscalls;
```

```rust
use ckb_std::syscalls::{load_cell, Source};

let cell = load_cell(&mut buf, 0, 0, Source::Input)?;
```

--------------------------------

### Entry Point

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/quick_reference.md

Defines the main entry point for a CKB contract using the entry! macro.

```APIDOC
## entry!(main)

### Description
Defines the entry point for the contract. The main function should return 0 for success and a non-zero value for failure.

### Signature
`fn main() -> i8`
```

--------------------------------

### Dependency Configurations

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/features_and_modules.md

Recommended Cargo.toml configurations for different contract requirements.

```toml
[dependencies]
ckb-std = { version = "1.1.0", default-features = false, features = ["allocator", "ckb-types"] }
```

```toml
[dependencies]
ckb-std = { version = "1.1.0", features = ["log"] }
```

```toml
[dependencies]
ckb-std = { version = "1.1.0", features = ["libc", "dlopen-c"] }
```

```toml
[dependencies]
ckb-std = { version = "1.1.0", features = ["native-simulator"] }
```

```toml
[dependencies]
ckb-std = { version = "1.1.0", default-features = false, features = ["ckb-types"] }
```

--------------------------------

### Use Logging

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/README.md

Initializes the logger to enable info and error logging within the contract.

```rust
use ckb_std::logger;
use log::*;

fn main() -> i8 {
    logger::init().ok();
    
    info!("Validation started");
    error!("Critical issue: {}", code);
    
    0
}
```

--------------------------------

### QueryIter Constructor Definition

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/high_level_api.md

Signature for creating a new QueryIter instance.

```rust
pub fn new(query_fn: F, source: Source) -> Self
```

--------------------------------

### Configure Memory Allocation in Rust

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/README.md

Sets up the global allocator with either default or custom heap sizes.

```rust
use ckb_std::default_alloc;

// Use defaults
default_alloc!()

// Or customize
default_alloc!(4 * 1024, 1024 * 1024, 64);  // 1 MB dynamic heap
```

--------------------------------

### Declare entry module

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/features_and_modules.md

Include the entry module, which is hidden from documentation.

```rust
#[doc(hidden)]
pub mod entry;
```

--------------------------------

### Initialize ckb-std logger

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/README.md

Initialize the logger to use the standard log crate with color support.

```rust
use ckb_std::logger;
use log::*;

logger::init().ok();
info!("Informational message");
error!("Error message");
```

--------------------------------

### Configure C-based dynamic loading feature

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/dynamic_loading.md

Enable the dlopen-c feature in your Cargo.toml to utilize the more efficient C-based implementation for dynamic loading.

```toml
ckb-std = { version = "1.1.0", features = ["dlopen-c"] }
```

--------------------------------

### Build with type-id support

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/features_and_modules.md

Enable Type ID validation and utilities by specifying the feature during build.

```bash
cargo build --features type-id
```

--------------------------------

### default_alloc!

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/macros.md

Configures the global memory allocator using a mixed strategy of fixed-size block heap and dynamic heap. This macro must be invoked at the crate root and requires the 'allocator' feature.

```APIDOC
## default_alloc!

### Description
Configures the global memory allocator for no_std Rust contracts using a mixed strategy of fixed-size block heap and dynamic heap.

### Parameters
- **fixed_heap_size** (expr) - Optional - Size of fixed 64-byte block pool (bytes). Default: 4 * 1024.
- **dynamic_heap_size** (expr) - Optional - Size of dynamic allocation pool (bytes). Default: 516 * 1024.
- **min_block_size** (expr) - Optional - Minimum dynamic block size (bytes). Default: 64.

### Requirements
- Must be invoked at crate root
- Requires `allocator` feature

### Example
```rust
use ckb_std::default_alloc;
default_alloc!(4 * 1024, 1024 * 1024, 64);
```
```

--------------------------------

### Check VM Version

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/README.md

Retrieve the CKB-VM version at runtime.

```rust
use ckb_std::syscalls::vm_version;

let version = vm_version()?;
```

--------------------------------

### Use InputField in Syscalls

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/types.md

Demonstrates loading input fields using load_input_by_field.

```rust
use ckb_std::syscalls::{load_input_by_field, Source, InputField};

// Load the since value
let mut buf = [0u8; 8];
load_input_by_field(&mut buf, 0, 0, Source::Input, InputField::Since)?;
let since = u64::from_le_bytes(buf);
```

--------------------------------

### Build Commands for Logger Support

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/logger.md

Commands to build your project with the log feature enabled, including release and Capsule-specific builds.

```bash
# Build with logger feature enabled
cargo build --target=riscv64imac-unknown-none-elf --features log

# Release build with debug output
RUSTFLAGS="--cfg debug_assertions" cargo build \
  --target=riscv64imac-unknown-none-elf \
  --release \
  --features log

# With Capsule
capsule build --features log
capsule build --release --debug-output --features log
```

--------------------------------

### Use Place in Syscalls

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/types.md

Demonstrates using the Place enum variants to specify code loading locations in exec syscalls.

```rust
use ckb_std::syscalls::{exec, Source, Place};

// Execute code from a dependency cell's data
exec(0, Source::CellDep, Place::Cell as usize, 0, &[])?;

// Execute code from a witness
exec(0, Source::Input, Place::Witness as usize, 0, &[])?;
```

--------------------------------

### Run tests with Capsule

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/README.md

Execute tests using the Capsule framework.

```bash
capsule test
```

--------------------------------

### Load Transaction

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/quick_reference.md

Retrieve the entire transaction structure.

```rust
use ckb_std::high_level::load_transaction;

let tx = load_transaction()?;
```

--------------------------------

### Declare dynamic_loading_c_impl module

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/features_and_modules.md

Include the C-based dynamic loading implementation, gated by riscv64 architecture and dlopen-c feature.

```rust
#[cfg(all(target_arch = "riscv64", feature = "dlopen-c"))]
pub mod dynamic_loading_c_impl;
```

--------------------------------

### Structured Logger Initialization

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/logger.md

Initialize the logger to enable color-coded output and severity levels.

```rust
use ckb_std::logger;
use log::*;

logger::init().ok();

error!("Invalid signature");  // Red, [ERROR]
info!("Processing input 0");   // Green, [INFO]
```

--------------------------------

### Execute Low-Level Syscalls

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/quick_reference.md

Perform data loading, retrieve VM info, control process flow, and manage code execution using the syscalls module.

```rust
use ckb_std::syscalls::{self, Source};

// Load data
syscalls::load_cell(&mut buf, 0, 0, Source::Input)?;
syscalls::load_cell_data(&mut buf, 0, 0, Source::Input)?;
syscalls::load_witness(&mut buf, 0, 0, Source::Input)?;

// Info
let cycles = syscalls::current_cycles();
let version = syscalls::vm_version()?;

// Process control
syscalls::exit(0);  // Terminate

// Code execution
syscalls::exec(0, Source::CellDep, 0, 0, &argv)?;
let pid = syscalls::spawn(0, Source::CellDep, 0, 0, &mut spgs)?;
let code = syscalls::wait(pid)?;
```

--------------------------------

### Build Commands for ckb-std

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/quick_reference.md

Standard and specialized build commands for compiling CKB smart contracts to the RISC-V target.

```bash
# Standard build
cargo build --target=riscv64imac-unknown-none-elf

# With atomic lowering (Rust 1.95+)
RUSTFLAGS="-C passes=lower-atomic" cargo build --target=riscv64imac-unknown-none-elf

# Release with debug output
RUSTFLAGS="--cfg debug_assertions" cargo build --release --target=riscv64imac-unknown-none-elf

# With Capsule
capsule build
capsule build --release --debug-output
```

--------------------------------

### Conditional Logging Optimization

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/logger.md

Techniques to minimize logging overhead in production environments.

```rust
#[cfg(debug_assertions)]
log::debug!("Detailed trace");

#[cfg(not(debug_assertions))]
// Code not compiled in release
```

```rust
// Only shown if configured at DEBUG level
log::debug!("Detailed info");
```

--------------------------------

### Iterate All Inputs

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/README.md

Uses QueryIter to aggregate capacity across all input cells.

```rust
use ckb_std::high_level::{QueryIter, load_cell_capacity, Source};

let total_capacity = QueryIter::new(load_cell_capacity, Source::Input)
    .map(|cap| cap.unwrap_or(0))
    .sum::<u64>();
```

--------------------------------

### Configure Feature Flags

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/quick_reference.md

Various Cargo.toml configurations for ckb-std, including minimal, logging, and C interop features.

```toml
# All default (recommended)
ckb-std = "1.1.0"

# Minimal
ckb-std = { version = "1.1.0", default-features = false, features = ["ckb-types"] }

# With logging
ckb-std = { version = "1.1.0", features = ["log"] }

# With C interop
ckb-std = { version = "1.1.0", features = ["libc", "dlopen-c"] }

# Testing with simulator
ckb-std = { version = "1.1.0", features = ["native-simulator"] }
```

--------------------------------

### env::argv()

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/types.md

Retrieves the command-line arguments passed to the current process. This function is available at runtime within script execution.

```APIDOC
## Function: ckb_std::env::argv()

### Description
Returns a slice of `Arg` objects representing the command-line arguments passed to the current script via `exec` or `spawn` syscalls.

### Return Type
`&'static [Arg]`

### Usage Example
```rust
use ckb_std::env;

let args = env::argv();
for (i, arg) in args.iter().enumerate() {
    match arg.to_str() {
        Ok(s) => println!("Arg {}: {}", i, s),
        Err(_) => println!("Arg {}: (invalid UTF-8)", i),
    }
}
```
```

--------------------------------

### Configure global allocator with allocator feature

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/features_and_modules.md

Use the default_alloc! macro to enable dynamic memory allocation when the allocator feature is active.

```rust
#[cfg(feature = "allocator")]
use ckb_std::default_alloc;

#[cfg(feature = "allocator")]
default_alloc!()
```

--------------------------------

### Run CKB contract tests

Source: https://github.com/nervosnetwork/ckb-std/blob/master/test/README.md

Executes the test suite for the CKB contract using the make utility.

```sh
make test
```

--------------------------------

### CKBDLContext::load

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/dynamic_loading.md

Loads a shared library from a dependency cell identified by its 32-byte data hash.

```APIDOC
## fn load<'a>(&'a mut self, dep_cell_data_hash: &[u8]) -> Result<Library, Error>

### Description
Loads a shared library from a dependency cell with the specified data hash. This process involves finding the cell, loading the ELF binary into the context buffer, parsing headers, and performing symbol relocation.

### Parameters
- **dep_cell_data_hash** (&[u8]) - Required - 32-byte data hash of the dependency cell containing the library.

### Returns
- **Result<Library, Error>** - Returns a handle to the loaded library on success, or an error if the cell is not found, the ELF is invalid, or memory is insufficient.
```

--------------------------------

### Iterate over process arguments

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/types.md

Use env::argv to retrieve and iterate through command-line arguments, handling potential UTF-8 conversion errors.

```rust
use ckb_std::env;

let args = env::argv();
for (i, arg) in args.iter().enumerate() {
    match arg.to_str() {
        Ok(s) => println!("Arg {}: {}", i, s),
        Err(_) => println!("Arg {}: (invalid UTF-8)", i),
    }
}
```

--------------------------------

### pipe()

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/syscalls.md

Creates a bidirectional pipe for inter-process communication. Returns a tuple containing the read and write file descriptors.

```APIDOC
## pipe()

### Description
Creates a bidirectional pipe for inter-process communication. Returns read and write file descriptors.

### Returns
Result<(u64, u64), SysError> - (read_fd, write_fd) tuple

### Errors
- SysError::MaxFdsCreated - Maximum file descriptors reached
```

--------------------------------

### Load Script Structure in Rust

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/syscalls.md

Loads the complete script structure, including code and arguments, into a buffer.

```rust
use ckb_std::syscalls;

let mut buf = [0u8; 256];
let len = syscalls::load_script(&mut buf, 0)?;
```

--------------------------------

### Enable Debug Assertions

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/README.md

Build with debug assertions enabled in release mode.

```bash
RUSTFLAGS="--cfg debug_assertions" cargo build --release --target=riscv64imac-unknown-none-elf
```

--------------------------------

### Use HeaderField in Syscalls

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/types.md

Demonstrates loading header fields using load_header_by_field.

```rust
use ckb_std::syscalls::{load_header_by_field, Source, HeaderField};

// Load epoch number from a header
let mut buf = [0u8; 8];
load_header_by_field(&mut buf, 0, 0, Source::HeaderDep, HeaderField::EpochNumber)?;
let epoch = u64::from_le_bytes(buf);
```

--------------------------------

### spawn_cell

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/high_level_api.md

Spawns a new process from dependency cell code.

```APIDOC
## spawn_cell

### Description
Spawns a new process from dependency cell code.

### Signature
`pub fn spawn_cell(code_hash: &[u8], hash_type: ScriptHashType, argv: &[&CStr], inherited_fds: &[u64]) -> Result<u64, SysError>`

### Parameters
- **code_hash** (&[u8]) - Required - 32-byte code hash
- **hash_type** (ScriptHashType) - Required - Hash type
- **argv** (&[&CStr]) - Required - Process arguments
- **inherited_fds** (&[u64]) - Required - File descriptors to pass to child

### Returns
- **Result<u64, SysError>** - Process ID or error
```

--------------------------------

### Capsule build shorthand

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/macros.md

Shorthand command for building with debug output using the Capsule tool.

```bash
capsule build --release --debug-output
```

--------------------------------

### Customize Memory Allocator Heap Size

Source: https://github.com/nervosnetwork/ckb-std/blob/master/README.md

Configure the fixed and dynamic heap sizes for the default allocator using the default_alloc! macro.

```rust
default_alloc!(4 * 1024, 516 * 1024, 64)
```

--------------------------------

### Create a pipe

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/syscalls.md

Creates a bidirectional pipe for inter-process communication. Returns a tuple containing the read and write file descriptors.

```rust
pub fn pipe() -> Result<(u64, u64), SysError>
```

```rust
use ckb_std::syscalls;

let (read_fd, write_fd) = syscalls::pipe()?;
```

--------------------------------

### load_script

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/syscalls.md

Loads the complete script structure (code and args) currently being executed.

```APIDOC
## pub fn load_script(buf: &mut [u8], offset: usize) -> Result<usize, SysError>

### Description
Loads the complete script structure (code and args) currently being executed.

### Parameters
- **buf** (&mut [u8]) - Required - Writable buffer to receive data
- **offset** (usize) - Required - Read offset within the script

### Returns
- **Result<usize, SysError>** - Loaded data length or error

### Example
```rust
use ckb_std::syscalls;

let mut buf = [0u8; 256];
let len = syscalls::load_script(&mut buf, 0)?;
```
```

--------------------------------

### Basic Debug Logging in Rust

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/logger.md

Standard debug macro usage without structured logging features.

```rust
use ckb_std::debug;

debug!("Error: Invalid signature");
debug!("Processing input 0");
```

--------------------------------

### CKBDLContext::load_with_offset

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/dynamic_loading.md

Advanced method to load a library into a specific offset and size within the context buffer.

```APIDOC
## fn load_with_offset<'a>(&'a mut self, dep_cell_data_hash: &[u8], offset: usize, size: usize) -> Result<Library, Error>

### Description
Loads a library with a custom offset and size within the buffer. This is useful for custom memory layouts, provided the buffer remains properly aligned.

### Parameters
- **dep_cell_data_hash** (&[u8]) - Required - 32-byte data hash of the dependency cell.
- **offset** (usize) - Required - Offset within the buffer to load to.
- **size** (usize) - Required - Maximum size to load.

### Returns
- **Result<Library, Error>** - Returns a handle to the loaded library on success, or an error.
```

--------------------------------

### Configure Panic Exit Code

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/macros.md

Demonstrates how to set a custom exit code for assertion panics and reset it to the default value.

```rust
use ckb_std::asserts::set_panic_exit_code;

set_panic_exit_code(25);
assert!(true);  // If this were false, would exit with 25
set_panic_exit_code(-1);  // Reset to default
```

--------------------------------

### Re-export log

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/features_and_modules.md

Enables standard logging macros after initializing the logger.

```rust
#[cfg(feature = "log")]
pub use log;
```

--------------------------------

### Debug and Log Messages

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/quick_reference.md

Utilize the debug macro for simple output or the log crate features for structured logging levels.

```rust
use ckb_std::debug;
use log::*;

// Simple debug macro (no feature needed)
debug!("Message: {}", value);

// Structured logging (requires log feature)
info!("Informational");
warn!("Warning");
error!("Error");
debug!("Debug details");
```

--------------------------------

### load_witness

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/high_level_api.md

Loads raw witness data as a byte vector.

```APIDOC
## load_witness

### Description
Loads raw witness data as a byte vector.

### Signature
`pub fn load_witness(index: usize, source: Source) -> Result<Vec<u8>, SysError>`

### Parameters
- **index** (usize) - Witness index
- **source** (Source) - Witness source

### Returns
- **Result<Vec<u8>, SysError>** - Witness bytes

### Note
Can panic if witness is too large (out of memory).
```

--------------------------------

### Use Source Enum in Syscalls

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/types.md

Demonstrates loading cell data using different Source variants.

```rust
use ckb_std::syscalls::{load_cell, Source};
use ckb_std::ckb_constants::Source;

// Load all inputs
for i in 0.. {
    match load_cell(&mut buf, 0, i, Source::Input) {
        Ok(_) => { /* process input i */ },
        Err(SysError::IndexOutOfBound) => break,
        Err(e) => return Err(e),
    }
}

// Load dependency cells only
let dep = load_cell(&mut buf, 0, 0, Source::CellDep)?;

// Load cells with the same lock script as the current script
for i in 0.. {
    match load_cell(&mut buf, 0, i, Source::GroupInput) {
        Ok(_) => { /* process grouped input */ },
        Err(SysError::IndexOutOfBound) => break,
        Err(e) => return Err(e),
    }
}
```

--------------------------------

### Load Library with Offset

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/dynamic_loading.md

Advanced method to load a library into a specific offset and size within the buffer, requiring manual alignment management.

```rust
pub fn load_with_offset<'a>(
    &'a mut self,
    dep_cell_data_hash: &[u8],
    offset: usize,
    size: usize,
) -> Result<Library, Error>
```

--------------------------------

### load_witness_args

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/high_level_api.md

Loads and parses WitnessArgs structure.

```APIDOC
## load_witness_args

### Description
Loads and parses WitnessArgs structure (lock, input_type, output_type fields).

### Signature
`pub fn load_witness_args(index: usize, source: Source) -> Result<WitnessArgs, SysError>`

### Parameters
- **index** (usize) - Witness index
- **source** (Source) - Witness source

### Returns
- **Result<WitnessArgs, SysError>** - Parsed WitnessArgs

### Note
Can panic if witness data is too large (out of memory).
```

--------------------------------

### vm_version

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/syscalls.md

Retrieves the current CKB-VM version.

```APIDOC
## vm_version() -> Result<u64, SysError>

### Description
Returns the current CKB-VM version. Returns Ok(1) for the new hardfork CKB-VM version, Ok(2) for later versions. Consumes 500 cycles.

### Returns
- **Ok(u64)** - VM version number (1 or 2)
- **Err(SysError::Unknown)** - Unknown version
```

--------------------------------

### Declare env module

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/features_and_modules.md

Include the environment module for command-line argument retrieval.

```rust
pub mod env;
```

--------------------------------

### Spawn a new process with spawn_cell

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/high_level_api.md

Spawns a new process using code from a dependency cell, returning a process ID on success.

```rust
pub fn spawn_cell(
    code_hash: &[u8],
    hash_type: ScriptHashType,
    argv: &[&CStr],
    inherited_fds: &[u64],
) -> Result<u64, SysError>
```

```rust
use ckb_std::high_level::spawn_cell;
use ckb_types::core::ScriptHashType;

let pid = spawn_cell(&code_hash, ScriptHashType::Data, &[], &[])?;
```

--------------------------------

### Handle Dynamic Loading Errors in Rust

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/dynamic_loading.md

Use this pattern to match against specific Error variants when loading a library with CKBDLContext. Ensure the buffer size is appropriate for the target library.

```rust
use ckb_std::dynamic_loading::{CKBDLContext, Error};

let mut context = unsafe { CKBDLContext::<[u8; 64 * 1024]>::new() };

match context.load(&CODE_HASH) {
    Ok(lib) => {
        // Use library
    }
    Err(Error::CellNotFound) => {
        debug!("Dependency library not found");
        return 1;
    }
    Err(Error::InvalidElf) => {
        debug!("Dependency contains invalid ELF");
        return 2;
    }
    Err(Error::MemoryNotEnough) => {
        debug!("Library too large for buffer");
        // Could use larger buffer, but limited by VM
        return 3;
    }
    Err(Error::InvalidAlign) => {
        debug!("Buffer not page-aligned");
        return 4;
    }
    Err(Error::Sys(sys_err)) => {
        debug!("Syscall error: {:?}", sys_err);
        return 5;
    }
    Err(Error::ContextFailure) => {
        debug!("Failed to initialize context");
        return 6;
    }
}
```

--------------------------------

### Compile shared library for RISC-V

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/dynamic_loading.md

Commands to compile the C source into a shared object file using GCC or Clang.

```bash
# Compile for RISC-V
riscv64-unknown-elf-gcc -shared -o math_lib.so math_lib.c

# Or with Clang
clang --target=riscv64 -shared -o math_lib.so math_lib.c
```

--------------------------------

### Load witness data in Rust

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/syscalls.md

Loads witness data from a transaction input or output.

```rust
pub fn load_witness(
    buf: &mut [u8],
    offset: usize,
    index: usize,
    source: Source,
) -> Result<usize, SysError>
```

```rust
use ckb_std::syscalls::{load_witness, Source};

let mut witness = [0u8; 512];
let len = load_witness(&mut witness, 0, 0, Source::Input)?;
```

--------------------------------

### Define libc_alloc! macro

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/macros.md

Macro definition for the libc-based memory allocator.

```rust
#[macro_export]
macro_rules! libc_alloc {
    () => { ... }
}
```

--------------------------------

### Implement Structured Logging in Rust

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/logger.md

Use standard log macros like info!, error!, warn!, and debug! within your CKB-std functions.

```rust
use ckb_std::logger;
use log::*;

fn validate_cell(index: usize) -> Result<u64, i32> {
    info!("Validating cell {}", index);
    
    let capacity = load_cell_capacity(index, Source::Input)
        .map_err(|e| {
            error!("Failed to load cell {}: {:?}", index, e);
            1
        })?;
    
    if capacity == 0 {
        warn!("Cell {} has zero capacity", index);
        return Err(2);
    }
    
    debug!("Cell {} has capacity {}", index, capacity);
    Ok(capacity)
}
```

--------------------------------

### Load Cell Output in Rust

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/high_level_api.md

Retrieves the complete CellOutput structure. Note that this may panic if the cell data exceeds available memory.

```rust
use ckb_std::high_level::{load_cell, Source};

let cell = load_cell(0, Source::Input)?;
let capacity = cell.capacity();
```

--------------------------------

### load_script

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/high_level_api.md

Loads the Script structure containing code hash, hash type, and arguments.

```APIDOC
## fn load_script()

### Description
Loads the Script structure containing code hash, hash type, and arguments. Automatically handles multi-buffer loading.

### Returns
Result<Script, SysError> - Parsed script or error
```

--------------------------------

### Place Enumeration

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/syscalls.md

Defines the location from which to load code.

```rust
pub enum Place {
    Cell = 0,      // Load from cell data
    Witness = 1,   // Load from witness
}
```

--------------------------------

### Define CKBDLContext Structure

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/dynamic_loading.md

The structure requires 4096-byte alignment to satisfy the W^X memory model requirements.

```rust
#[repr(C)]
#[repr(align(4096))]
pub struct CKBDLContext<T>(T);
```

--------------------------------

### Load Input Structure

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/syscalls.md

Loads the OutPoint and since value for a specific input.

```rust
pub fn load_input(
    buf: &mut [u8],
    offset: usize,
    index: usize,
    source: Source,
) -> Result<usize, SysError>
```

--------------------------------

### Use CellField in Syscalls

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/types.md

Demonstrates loading specific cell fields using load_cell_by_field.

```rust
use ckb_std::syscalls::{load_cell_by_field, Source, CellField};
use std::mem::size_of;

// Load just the capacity (efficient)
let mut buf = [0u8; 8];
load_cell_by_field(&mut buf, 0, 0, Source::Input, CellField::Capacity)?;
let capacity = u64::from_le_bytes(buf);

// Load the lock script
let mut script_buf = [0u8; 256];
load_cell_by_field(&mut script_buf, 0, 0, Source::Input, CellField::Lock)?;
```

--------------------------------

### exec

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/syscalls.md

Replaces the current process with code from a cell, maintaining the same VM instance and cycle counter. This is used for code composition and modular scripts.

```APIDOC
## exec

### Signature
`pub fn exec(index: usize, source: Source, place: usize, bounds: usize, argv: &[&CStr]) -> u64`

### Description
Replaces the current process with code from a cell, maintaining the same VM instance and cycle counter. Used for code composition and modular scripts.

### Parameters
- **index** (usize) - Cell index
- **source** (Source) - Cell source (typically CellDep)
- **place** (usize) - 0 for cell data, 1 for witness
- **bounds** (usize) - High 32 bits = offset, low 32 bits = length (0 = read to end)
- **argv** (&[&CStr]) - Array of C-string arguments for the loaded program

### Returns
- **u64** - Error code on failure

### Example
```rust
use ckb_std::syscalls::{exec, Source};
use std::ffi::CStr;

let code_hash = [/* 32 bytes */];
let argv = [CStr::from_bytes_with_nul(b"arg1\0").unwrap()];
let ret = exec(0, Source::CellDep, 0, 0, &argv);
if ret != 0 {
    // exec failed
}
```
```

--------------------------------

### load_input_out_point

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/high_level_api.md

Loads the OutPoint from an input.

```APIDOC
## load_input_out_point(index: usize, source: Source)

### Description
Loads the OutPoint (transaction hash and cell index reference) from an input.

### Parameters
- **index** (usize) - Required - Input index
- **source** (Source) - Required - Input source

### Returns
- **Result<OutPoint, SysError>** - OutPoint reference
```

--------------------------------

### assert!

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/macros.md

A wrapper around core::assert! that allows specifying a custom exit code (i8) to be returned if the condition evaluates to false.

```APIDOC
## assert!(code, condition)

### Description
Evaluates a condition and triggers a panic with a custom exit code if the condition is false.

### Parameters
- **code** (expr) - Required - The i8 exit code to set if the assertion fails.
- **condition** (expr) - Required - The boolean condition to evaluate.

### Example
```rust
use ckb_std::assert;
assert!(10, balance >= 50);
```
```

--------------------------------

### Declare global_alloc_macro module

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/features_and_modules.md

Include the global allocator macro module, which is hidden from documentation.

```rust
#[doc(hidden)]
pub mod global_alloc_macro;
```

--------------------------------

### spawn

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/syscalls.md

Creates a new independent process from cell code without replacing the current process.

```APIDOC
## spawn

### Signature
`pub fn spawn(index: usize, source: Source, place: usize, bounds: usize, spgs: &mut SpawnArgs) -> Result<u64, SysError>`

### Description
Creates a new independent process from cell code. Unlike `exec`, this does not replace the current process.

### Parameters
- **index** (usize) - Cell index containing executable code
- **source** (Source) - Cell source (typically CellDep)
- **place** (usize) - 0 for cell data, 1 for witness
- **bounds** (usize) - High 32 bits = offset, low 32 bits = length
- **spgs** (&mut SpawnArgs) - Spawn arguments struct with argc, argv, process_id, inherited_fds

### Returns
- **Result<u64, SysError>** - Process ID on success

### Example
```rust
use ckb_std::syscalls::{spawn, Source, SpawnArgs};

let mut process_id = 0;
let argv_ptr = vec![];
let fds = vec![0]; // terminate list
let mut spgs = SpawnArgs {
    argc: 0,
    argv: argv_ptr.as_ptr(),
    process_id: &mut process_id as *mut u64,
    inherited_fds: fds.as_ptr(),
};

let pid = spawn(0, Source::CellDep, 0, 0, &mut spgs)?;
```
```

--------------------------------

### Declare dynamic_loading module

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/features_and_modules.md

Include the dynamic loading module, gated by the ckb-types feature.

```rust
#[cfg(feature = "ckb-types")]
pub mod dynamic_loading;
```

--------------------------------

### Re-export set_script_info

Source: https://github.com/nervosnetwork/ckb-std/blob/master/_autodocs/features_and_modules.md

Simulator-specific function for setting script context during testing.

```rust
#[cfg(feature = "native-simulator")]
pub use ckb_x64_simulator::set_script_info;
```
Tokens:
Raw