CKB C Standard Library

https://github.com/nervosnetwork/ckb-c-stdlib
Admin
CKB C Standard Library is a collection of useful patterns and utilities for writing CKB scripts,...
Tokens:36,254
Snippets:433
Trust Score:9.6
License:MIT
Update:1 month ago
Show doc for...
Tokens:
Raw
### Initialize and use spawn_args_t

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/06-types.md

Example demonstrating how to populate spawn_args_t and invoke ckb_spawn.

```c
uint64_t child_pid;
const uint64_t fds[] = {0};  // No inherited FDs
const char* args[] = {"arg1", "arg2"};

spawn_args_t spawn_args = {
  .argc = 2,
  .argv = args,
  .process_id = &child_pid,
  .inherited_fds = fds
};

int ret = ckb_spawn(0, CKB_SOURCE_CELL_DEP, 0, 0, &spawn_args);
if (ret == CKB_SUCCESS) {
  // child_pid now contains the spawned process ID
}
```

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

### Initialize BLAKE2b with custom parameters

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/06-types.md

Example of configuring and applying custom parameters to a BLAKE2b context.

```c
blake2b_param params;
memset(&params, 0, sizeof(params));
params.digest_length = 32;
params.fanout = 1;
params.depth = 1;
blake2b_state ctx;
blake2b_init_param(&ctx, &params);
```

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

### Makefile Configuration for I/O

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/04-libc-functions.md

Example Makefile snippet demonstrating the required CFLAGS for printf support.

```makefile
CFLAGS := -DCKB_PRINTF_DECLARATION_ONLY \
          -DCKB_C_STDLIB_PRINTF \
          -fno-builtin-printf \
          -Ideps/ckb-c-stdlib \
          -Ideps/ckb-c-stdlib/libc
```

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

### Apply Size-Optimized Build Configuration

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/08-configuration.md

A comprehensive example of CFLAGS and LDFLAGS for producing a minimal binary.

```makefile
CFLAGS := --target=riscv64 -march=rv64imc_zba_zbb_zbc_zbs -O3 \
          -fdata-sections -ffunction-sections \
          -fno-builtin-printf -fno-builtin-memcmp \
          -nostdlib \
          -finline-limit=1000 \
          -DCKB_PRINTF_DECLARATION_ONLY \
          -Ideps/ckb-c-stdlib -Ideps/ckb-c-stdlib/libc

LDFLAGS := -static -Wl,--gc-sections --strip-all
```

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

### printf usage example

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/04-libc-functions.md

Example of using printf with required compiler flags.

```c
// Compile with: -DCKB_C_STDLIB_PRINTF -DCKB_PRINTF_DECLARATION_ONLY
#include <stdio.h>
#include "ckb_syscalls.h"

int main() {
  int value = 42;
  printf("Value is: %d\n", value);
  return 0;
}
```

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

### Complete Keccak-256 hashing workflow

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/03-cryptography.md

A full example demonstrating initialization, updating, and finalizing a Keccak-256 hash.

```c
#include "ckb_keccak256.h"

void hash_data() {
  SHA3_CTX ctx;
  unsigned char digest[32];
  
  keccak_init(&ctx);
  keccak_update(&ctx, (unsigned char*)"data", 4);
  keccak_final(&ctx, digest);
  
  // digest contains Keccak-256 hash
}
```

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

### Dynamic Linking Usage Example

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/02-syscall-functions.md

Demonstrates loading a library with ckb_dlopen2 and resolving a function symbol using ckb_dlsym.

```c
uint8_t lib_hash[32] = {/* library code hash */};
uint8_t lib_mem[65536] __attribute__((aligned(4096)));
void* lib_handle;
size_t consumed;
int ret = ckb_dlopen2(lib_hash, 0, lib_mem, sizeof(lib_mem), &lib_handle, &consumed);
if (ret == CKB_SUCCESS) {
  typedef int (*lib_func_t)(int);
  lib_func_t func = (lib_func_t)ckb_dlsym(lib_handle, "some_function");
  if (func) {
    int result = func(42);
  }
}
```

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

### Hash Cell Convenience Example

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/05-utilities.md

Usage example for the ckb_hash_cell convenience function.

```c
blake2b_state ctx;
ckb_blake2b_init(&ctx, 32);
int ret = ckb_hash_cell(&ctx, 0, CKB_SOURCE_INPUT);
```

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

### Main Function Stack Alignment Example

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/05-utilities.md

Demonstrates the usage of stack alignment macros within a main function.

```c
int main(void) {
  CKB_SP_ALIGN;
  
  // Script code here
  
  CKB_SP_ALIGN_END;
  return 0;
}
```

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

### Install ckb-c-stdlib as a Git Submodule

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/08-configuration.md

Use this command to add the library to your project's dependencies directory.

```bash
git submodule add https://github.com/nervosnetwork/ckb-c-stdlib.git deps/ckb-c-stdlib
```

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

### ckb_debug usage example

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/04-libc-functions.md

Direct output of a debug string using ckb_debug.

```c
ckb_debug("Checkpoint 1 reached");
```

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

### Stream Hash Large Cell Example

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/05-utilities.md

Example of hashing a large cell using ckb_load_and_hash.

```c
#include "ckb_streaming.h"
#include "blake2b.h"

void hash_large_cell() {
  blake2b_state ctx;
  ckb_blake2b_init(&ctx, 32);
  
  int ret = ckb_load_and_hash(&ctx, 0, 0, CKB_SOURCE_OUTPUT,
                              ckb_load_cell_data);
  if (ret == CKB_SUCCESS) {
    uint8_t hash[32];
    blake2b_final(&ctx, hash, 32);
    // hash now contains streamed BLAKE2b of cell data
  }
}
```

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

### ckb_printf usage example

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/04-libc-functions.md

Basic usage of ckb_printf for formatted debugging.

```c
ckb_printf("Script version: %d\n", 1);
```

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

### Build instructions for ckb-c-stdlib

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

Instructions for generating a hello world project using an AI agent.

```text
Write a "hello, world" project by following the instructions in:
https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/guide.md
```

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

### void _start()

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/04-libc-functions.md

The program entry point for CKB scripts. It initializes the environment, loads arguments, executes the main function, and handles the exit process.

```APIDOC
## void _start()

### Description
This is the mandatory entry point for CKB scripts. It performs environment initialization, including setting up the global pointer register, loading argc/argv from the stack, invoking the user-defined main function, and exiting with the returned status code.

### Usage
Include the header via `#include <entry.h>` or indirectly through `<stdio.h>` and `<string.h>`.
```

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

### Get current process ID

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/02-syscall-functions.md

Retrieves the unique identifier for the current process.

```c
uint64_t ckb_process_id()
```

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

### Initialize Keccak-256 context

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/03-cryptography.md

Prepare the SHA3_CTX structure before beginning the hashing process.

```c
SHA3_CTX ctx;
keccak_init(&ctx);
```

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

### Get inherited file descriptors

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/02-syscall-functions.md

Retrieves file descriptors passed from the parent process.

```c
int ckb_inherited_fds(uint64_t* fds, size_t* length)
```

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

### Hash and Verify

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/00-index.md

Shows the process of initializing a BLAKE2b context, loading cell data, and computing the final hash.

```c
#include "blake2b.h"
#include "ckb_syscalls.h"

blake2b_state ctx;
ckb_blake2b_init(&ctx, 32);

uint8_t data[4096];
uint64_t len = sizeof(data);
ckb_load_cell_data(data, &len, 0, 0, CKB_SOURCE_OUTPUT);

blake2b_update(&ctx, data, len);
uint8_t hash[32];
blake2b_final(&ctx, hash, 32);

// Compare hash...
```

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

### Running Simulator Executables

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/simulator/README.md

These commands demonstrate how to run the simulator executables with a provided JSON configuration file. The first argument is the name of the JSON file containing the simulation data.

```bash
../build.simulator/sighash_all data.json
../build.simulator/sighash_all data2.json
../build.simulator/sighash_all data3.json
../build.simulator/sudt sudt_data.json
```

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

### Define CKB Program Entry Point

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/04-libc-functions.md

The entry point initializes the environment and calls the main function.

```c
void _start()
```

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

### Define Include Paths

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/08-configuration.md

Add directories for CKB headers and C library headers.

```bash
-Ideps/ckb-c-stdlib
-Ideps/ckb-c-stdlib/libc
```

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

### Handle variadic arguments with stdarg.h

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/04-libc-functions.md

Demonstrates the initialization and cleanup of a variadic argument list using va_start and va_end.

```c
#include <stdarg.h>

void my_printf(const char* format, ...) {
  va_list args;
  va_start(args, format);
  // Process variadic arguments
  va_end(args);
}
```

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

### Find substring with strstr

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/04-libc-functions.md

Locates the first occurrence of a substring within a string, returning a pointer to the start of the match.

```c
const char* text = "hello world";
const char* pos = strstr(text, "world");
if (pos) {
  // "world" found in text
}
```

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

### Align Stack Pointer with CKB_SP_ALIGN

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/05-utilities.md

Aligns the stack pointer to a 16-byte boundary. Use at the start of main() for compatibility with CKB VM >= 0.20.x.

```c
#define CKB_SP_ALIGN \
  __asm__( \
      "addi t0, sp, 0\n" \
      "andi sp, sp, 0xfffffffffffffff8\n" \
      "sd t0, -8(sp)\n" \
      "sd t0, -16(sp)\n" \
      "addi sp, sp, -8\n" \
      "andi sp, sp, 0xfffffffffffffff0" \
      : : : "t0")
```

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

### Safe Hash Initialization Pattern

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/07-errors.md

Demonstrates a wrapper for BLAKE2b initialization that validates output length constraints before calling the library function.

```c
#include "blake2b.h"

int safe_hash_init(blake2b_state *ctx, size_t outlen) {
  if (outlen < 1 || outlen > 64) {
    return -1;  // Invalid output length
  }
  
  int ret = ckb_blake2b_init(ctx, outlen);
  if (ret != 0) {
    ckb_debug("Failed to initialize hash");
    return ret;
  }
  
  return 0;
}
```

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

### keccak_init

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/03-cryptography.md

Initializes the Keccak-256 hashing state context.

```APIDOC
## void keccak_init(SHA3_CTX *ctx)

### Description
Initialize Keccak-256 state for hashing.

### Parameters
- **ctx** (SHA3_CTX*) - Required - Hash context to initialize

### Example
```c
SHA3_CTX ctx;
keccak_init(&ctx);
```
```

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

### Initialize BLAKE2b with Custom Parameters

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/03-cryptography.md

Initialize the hash state using a custom parameter structure.

```c
int blake2b_init_param(blake2b_state *S, const blake2b_param *P)
```

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

### Implement Resilient Script Loading with Fallback

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/07-errors.md

Demonstrates handling CKB_INDEX_OUT_OF_BOUND by falling back to input source and managing buffer size errors.

```c
#include "ckb_syscalls.h"

int resilient_script() {
  // Attempt to load with fallback
  uint8_t buffer[4096];
  uint64_t len = sizeof(buffer);
  
  int ret = ckb_load_cell_data(buffer, &len, 0, 0, CKB_SOURCE_OUTPUT);
  
  if (ret == CKB_INDEX_OUT_OF_BOUND) {
    // No output cell, try input
    ret = ckb_load_cell_data(buffer, &len, 0, 0, CKB_SOURCE_INPUT);
  }
  
  if (ret == CKB_LENGTH_NOT_ENOUGH) {
    // Data too large, allocate more or process in chunks
    // Use streaming API instead
    ckb_exit(1);
  }
  
  if (ret != CKB_SUCCESS) {
    ckb_exit(2);
  }
  
  // Data loaded successfully
  ckb_exit(0);
}
```

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

### blake2b_init_param

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/03-cryptography.md

Initializes BLAKE2b with custom parameters.

```APIDOC
## int blake2b_init_param(blake2b_state *S, const blake2b_param *P)

### Description
Initialize BLAKE2b with custom parameters.

### Parameters
- **S** (blake2b_state*) - Required - Hash state
- **P** (const blake2b_param*) - Required - Parameter structure

### Returns
- **int** - 0 on success, -1 on error
```

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

### Configure Entry Point for Shared Libraries

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/08-configuration.md

Use these definitions to skip the entry point or disable global pointer initialization for shared libraries.

```c
#define __SHARED_LIBRARY__
```

```c
#define CKB_NO_ENTRY_GP
```

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

### Implement and use custom_loader

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/06-types.md

Demonstrates implementing a custom loader function and passing it to ckb_load_and_hash for streaming data processing.

```c
int custom_loader(void* buf, uint64_t* len, size_t offset,
                  size_t index, size_t source) {
  // Custom load logic
  return ckb_load_cell_data(buf, len, offset, index, source);
}

blake2b_state ctx;
ckb_blake2b_init(&ctx, 32);
ckb_load_and_hash(&ctx, 0, 0, CKB_SOURCE_OUTPUT, custom_loader);
```

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

### Safe Dynamic Library Loading Pattern

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/07-errors.md

Demonstrates how to load a dynamic library using ckb_dlopen2 and handle specific error codes returned during the process.

```c
#include "ckb_syscalls.h"

int load_dynamic_library() {
  uint8_t code_hash[32] = {/* 32-byte hash */};
  uint8_t lib_mem[65536] __attribute__((aligned(4096)));
  void* lib_handle;
  size_t consumed;
  
  int ret = ckb_dlopen2(code_hash, 0, lib_mem, sizeof(lib_mem),
                        &lib_handle, &consumed);
  
  if (ret < 0) {
    switch (ret) {
      case ERROR_INVALID_ELF:
        ckb_debug("Invalid ELF binary");
        break;
      case ERROR_MEMORY_NOT_ENOUGH:
        ckb_debug("Memory insufficient for library");
        break;
      case ERROR_ELF_NOT_ALIGNED:
        ckb_debug("Library memory not aligned");
        break;
      case ERROR_INVALID_ARGS:
        ckb_debug("Invalid arguments to dlopen");
        break;
      default:
        ckb_debug("Unknown dlopen error");
    }
    return ret;
  }
  
  // Library loaded successfully
  typedef int (*lib_func_t)(void);
  lib_func_t func = (lib_func_t)ckb_dlsym(lib_handle, "entry");
  if (!func) {
    ckb_debug("Symbol not found in library");
    return -1;
  }
  
  return func();
}
```

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

### Single Compilation Unit Build Configuration

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/08-configuration.md

Recommended approach for optimal inlining and simplified build management using a single clang invocation.

```makefile
CC := clang
CFLAGS := --target=riscv64 -march=rv64imc_zba_zbb_zbc_zbs -O3 \
          -fdata-sections -ffunction-sections \
          -fno-builtin-printf -fno-builtin-memcmp \
          -nostdlib \
          -DCKB_C_STDLIB_PRINTF -DCKB_PRINTF_DECLARATION_ONLY \
          -Ideps/ckb-c-stdlib -Ideps/ckb-c-stdlib/libc

LDFLAGS := -static -Wl,--gc-sections

build/main: c/main.c
	mkdir -p build
	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $<
```

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

### Minimal C main file

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/guide.md

A basic C source file demonstrating the inclusion of ckb_syscalls.h and standard library headers for a RISC-V target.

```c
#include "ckb_syscalls.h"
#include <stdio.h>

int main(void) {
  printf("hello, world\n");
  return 0;
}
```

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

### ckb_blake2b_init

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/03-cryptography.md

Initializes the BLAKE2b hash state with CKB-specific personalization.

```APIDOC
## int ckb_blake2b_init(blake2b_state *S, size_t outlen)

### Description
Initialize BLAKE2b hash state for CKB. Use this instead of `blake2b_init` for CKB-specific personalization.

### Parameters
- **S** (blake2b_state*) - Required - Hash state to initialize
- **outlen** (size_t) - Required - Desired output length (1-64 bytes)

### Returns
- **int** - 0 on success, -1 on error
```

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

### Iterate Transaction Inputs

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

Demonstrates how to calculate the number of inputs and iterate through them using ckb_load_input.

```c
int count = ckb_calculate_inputs_len();
for (int i = 0; i < count; i++) {
  uint8_t input[64];
  uint64_t len = sizeof(input);
  if (ckb_load_input(input, &len, 0, i, CKB_SOURCE_INPUT) != CKB_SUCCESS) {
    ckb_exit(1);
  }
  // Process input...
}
```

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

### Initialize BLAKE2b with Key

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/03-cryptography.md

Initialize the hash state with a key for HMAC-like operations.

```c
int blake2b_init_key(blake2b_state *S, size_t outlen, const void *key,
                     size_t keylen)
```

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

### Execute Reproducible Build

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/08-configuration.md

Uses a Docker container to ensure a byte-identical build environment.

```bash
./scripts/reproducible_build_docker
```

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

### blake2b_init

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/03-cryptography.md

Initializes the BLAKE2b hash state without CKB personalization.

```APIDOC
## int blake2b_init(blake2b_state *S, size_t outlen)

### Description
Standard BLAKE2b initialization without CKB personalization.

### Parameters
- **S** (blake2b_state*) - Required - Hash state to initialize
- **outlen** (size_t) - Required - Output length (1-64 bytes)

### Returns
- **int** - 0 on success, -1 on error
```

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

### Enable Static Linking

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/08-configuration.md

Ensure all libraries are linked statically for CKB scripts.

```bash
-static
```

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

### Configure Printf Support

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/08-configuration.md

Enable printf functionality; CKB_C_STDLIB_PRINTF is required for actual output.

```bash
-DCKB_PRINTF_DECLARATION_ONLY
-DCKB_C_STDLIB_PRINTF
```

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

### Load Witness with Buffer Check

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/02-syscall-functions.md

Checked version of the witness loading syscall.

```c
int ckb_checked_load_witness(void* addr, uint64_t* len, size_t offset,
                             size_t index, size_t source)
```

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

### Pass Arguments to ckb_exec

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/06-types.md

Prepare a null-terminated array of strings and an argument count to invoke ckb_exec.

```c
const char* argv[] = {
  "program_name",
  "arg1",
  "arg2",
  NULL  // terminator optional for argc
};
int argc = 2;  // Not counting program name
ckb_exec(0, CKB_SOURCE_CELL_DEP, 0, 0, argc, argv);
```

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

### Load Script with Buffer Check

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/02-syscall-functions.md

Checked version of the script loading syscall.

```c
int ckb_checked_load_script(void* addr, uint64_t* len, size_t offset)
```

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

### Initialize Standard BLAKE2b Hash State

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/03-cryptography.md

Standard initialization without CKB-specific personalization.

```c
int blake2b_init(blake2b_state *S, size_t outlen)
```

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

### Load and Validate Cell

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/00-index.md

Demonstrates how to load cell data into a buffer and handle potential errors using ckb_checked_load_cell.

```c
#include "ckb_syscalls.h"

uint8_t cell[1024];
uint64_t len = sizeof(cell);
int ret = ckb_checked_load_cell(cell, &len, 0, 0, CKB_SOURCE_OUTPUT);
if (ret == CKB_SUCCESS) {
  // Process cell data
  ckb_exit(0);
} else if (ret == CKB_LENGTH_NOT_ENOUGH) {
  ckb_debug("Cell too large");
  ckb_exit(1);
} else {
  ckb_debug("Load failed");
  ckb_exit(2);
}
```

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

### Multiple Compilation Units Build Configuration

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/08-configuration.md

Strategy for larger projects using separate object files and the ld linker for faster incremental builds.

```makefile
CFLAGS := --target=riscv64 -march=rv64imc_zba_zbb_zbc_zbs -O3 \
          -fdata-sections -ffunction-sections \
          -fno-builtin-printf -fno-builtin-memcmp \
          -nostdlib \
          -DCKB_DECLARATION_ONLY \
          -DCKB_C_STDLIB_PRINTF -DCKB_PRINTF_DECLARATION_ONLY \
          -Ideps/ckb-c-stdlib -Ideps/ckb-c-stdlib/libc

LDFLAGS := -static --gc-sections

build/main: c/main.o c/helper.o deps/ckb-c-stdlib/libc/src/impl.o
	ld $(LDFLAGS) -o $@ $^

c/main.o: c/main.c
	$(CC) $(CFLAGS) -c -o $@ $<

c/helper.o: c/helper.c
	$(CC) $(CFLAGS) -c -o $@ $<
```

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

### Load Input with Buffer Check

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/02-syscall-functions.md

Checked version of the input loading syscall.

```c
int ckb_checked_load_input(void* addr, uint64_t* len, size_t offset,
                           size_t index, size_t source)
```

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

### blake2b_init_key

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/03-cryptography.md

Initializes BLAKE2b with a key for HMAC-like usage.

```APIDOC
## int blake2b_init_key(blake2b_state *S, size_t outlen, const void *key, size_t keylen)

### Description
Initialize BLAKE2b with a key (for HMAC-like usage).

### Parameters
- **S** (blake2b_state*) - Required - Hash state
- **outlen** (size_t) - Required - Output length
- **key** (const void*) - Required - Key material
- **keylen** (size_t) - Required - Key length (0-64 bytes)

### Returns
- **int** - 0 on success, -1 on error
```

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

### ckb_dlopen2

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/02-syscall-functions.md

Loads a dynamic library from a cell dependency into memory.

```APIDOC
## ckb_dlopen2

### Description
Loads a dynamic library from a cell dependency. Returns a handle for symbol lookup via ckb_dlsym.

### Signature
int ckb_dlopen2(const uint8_t* dep_cell_hash, uint8_t hash_type, uint8_t* aligned_addr, size_t aligned_size, void** handle, size_t* consumed_size)

### Parameters
- **dep_cell_hash** (const uint8_t*) - Required - 32-byte cell hash
- **hash_type** (uint8_t) - Required - Hash type (0 or 1)
- **aligned_addr** (uint8_t*) - Required - Aligned memory address for loading
- **aligned_size** (size_t) - Required - Memory size available
- **handle** (void**) - Required - [Out] Handle for dlsym lookups
- **consumed_size** (size_t*) - Required - [Out] Bytes consumed from aligned_addr

### Returns
- **int** - CKB_SUCCESS on success, error code otherwise
```

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

### Standard Makefile for ckb-c-stdlib

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/guide.md

A complete Makefile configuration for building C projects with the required RISC-V flags and include paths.

```makefile
CC := clang
LD := ld.lld

CFLAGS := --target=riscv64 -march=rv64imc_zba_zbb_zbc_zbs -O3 \
          -fdata-sections -ffunction-sections \
          -fno-builtin-printf -fno-builtin-memcmp \
          -nostdlib \
          -DCKB_C_STDLIB_PRINTF -DCKB_PRINTF_DECLARATION_ONLY \
          -Ideps/ckb-c-stdlib -Ideps/ckb-c-stdlib/libc
LDFLAGS := -static -Wl,--gc-sections

CHECKSUM_FILE ?= checksums.txt

default: build

build: build/main

build/main: c/main.c
    mkdir -p build
	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $<

checksum: build
	shasum -a 256 build/* > $(CHECKSUM_FILE)

clean:
	rm -rf build

.PHONY: default build checksum clean
```

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

### Configure Binary Size Optimization

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/08-configuration.md

Compiler and linker flags to reduce the final binary footprint.

```makefile
# Don't link printf if not used
# Don't include type ID validation if not needed
```

```makefile
CFLAGS += -fdata-sections -ffunction-sections
LDFLAGS += -Wl,--gc-sections
```

```makefile
CFLAGS += -O3
```

```makefile
CFLAGS += -finline-limit=1000
```

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

### Load Script Hash with Buffer Check

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/02-syscall-functions.md

Checked version of the script hash loading syscall.

```c
int ckb_checked_load_script_hash(void* addr, uint64_t* len, size_t offset)
```

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

### Handle CKB_INDEX_OUT_OF_BOUND error

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/07-errors.md

Shows how to safely iterate over inputs by calculating the total input count before attempting to load individual inputs.

```c
// Use ckb_calculate_inputs_len() for input count
int input_count = ckb_calculate_inputs_len();
for (int i = 0; i < input_count; i++) {
  uint8_t input[64];
  uint64_t len = sizeof(input);
  int ret = ckb_load_input(input, &len, 0, i, CKB_SOURCE_INPUT);
  // ret should be CKB_SUCCESS for all i < input_count
}
```

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

### Load Header with Buffer Check

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/02-syscall-functions.md

Checked version of the header loading syscall.

```c
int ckb_checked_load_header(void* addr, uint64_t* len, size_t offset,
                            size_t index, size_t source)
```

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

### Include Headers for I/O

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/04-libc-functions.md

Required headers for utilizing printf functionality in CKB scripts.

```c
#include <stdio.h>
#include "ckb_syscalls.h"
```

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

### Load Input by Field with Buffer Check

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/02-syscall-functions.md

Checked version of the input field loading syscall.

```c
int ckb_checked_load_input_by_field(void* addr, uint64_t* len, size_t offset,
                                    size_t index, size_t source, size_t field)
```

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

### Spawn cell by hash

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/02-syscall-functions.md

Convenience function to locate a cell dependency by hash and spawn it as a child process.

```c
int ckb_spawn_cell(const uint8_t* code_hash, uint8_t hash_type,
                   uint32_t offset, uint32_t length,
                   spawn_args_t* spawn_args)
```

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

### Linker Options for CKB C Standard Library

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/guide.md

Required LDFLAGS for linking CKB smart contracts.

```text
-static --gc-sections
```

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

### Program Execution Flow

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/00-index.md

Visual representation of the C script lifecycle from entry point to exit.

```text
_start (entry.h)
  ↓
Initialize stack and gp register
  ↓
Call main(argc, argv)
  ↓
main() can call:
  - Syscalls (via ckb_syscalls.h)
  - C library functions (string.h, stdio.h, etc.)
  - Hash functions (blake2b.h, ckb_keccak256.h)
  - Utilities (ckb_type_id.h, ckb_streaming.h, etc.)
  ↓
ckb_exit(code) or return from main
  ↓
Exit script with code
```

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

### Perform streaming BLAKE2b hashing

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/06-types.md

Usage pattern for initializing, updating, and finalizing a BLAKE2b hash context.

```c
blake2b_state ctx;
ckb_blake2b_init(&ctx, 32);       // Initialize for 32-byte output
blake2b_update(&ctx, data1, len1); // Hash first chunk
blake2b_update(&ctx, data2, len2); // Hash second chunk
uint8_t hash[32];
blake2b_final(&ctx, hash, 32);     // Get digest
```

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

### Load Transaction with Buffer Check

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/02-syscall-functions.md

Checked version of the transaction loading syscall.

```c
int ckb_checked_load_transaction(void* addr, uint64_t* len, size_t offset)
```

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

### Initialize CKB BLAKE2b Hash State

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/03-cryptography.md

Use this function for CKB-specific personalization when initializing the hash state.

```c
int ckb_blake2b_init(blake2b_state *S, size_t outlen)
```

```c
blake2b_state ctx;
int ret = ckb_blake2b_init(&ctx, 32);
if (ret == 0) {
  // Initialized for 32-byte output
}
```

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

### Handle CKB_LENGTH_NOT_ENOUGH error

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/07-errors.md

Demonstrates how to handle buffer size limitations when loading cell data by checking the return value and utilizing the updated length parameter.

```c
// Allocate larger buffer
#define MAX_SIZE 65536
uint8_t buffer[MAX_SIZE];
uint64_t len = sizeof(buffer);

int ret = ckb_load_cell_data(buffer, &len, 0, 0, CKB_SOURCE_OUTPUT);
if (ret == CKB_SUCCESS) {
  // Use buffer[0..len-1]
} else if (ret == CKB_LENGTH_NOT_ENOUGH) {
  // len contains required size, buffer was too small
}
```

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

### Basic CKB Script Template

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

A standard template for a CKB script, demonstrating transaction loading and exit handling.

```c
#include "ckb_syscalls.h"
#include <stdio.h>

int main(void) {
  uint8_t buffer[4096];
  uint64_t len = sizeof(buffer);
  
  int ret = ckb_load_transaction(buffer, &len, 0);
  if (ret != CKB_SUCCESS) {
    ckb_exit(1);
  }
  
  // Process transaction...
  printf("Loaded %ld bytes\n", len);
  ckb_exit(0);
}
```

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

### Perform SHA3/Keccak hashing

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/06-types.md

Usage pattern for initializing, updating, and finalizing a SHA3 hash context.

```c
SHA3_CTX ctx;
keccak_init(&ctx);
keccak_update(&ctx, (unsigned char*)"data", 4);
unsigned char digest[32];
keccak_final(&ctx, digest);
```

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

### Spawn a child process

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/02-syscall-functions.md

Spawns a child process from a cell without blocking. Use ckb_wait to synchronize.

```c
int ckb_spawn(size_t index, size_t source, size_t place, size_t bounds,
              spawn_args_t* spawn_args)
```

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

### Compare epoch values with ckb_epoch_number_with_fraction_cmp

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/05-utilities.md

Compares two epoch-with-fraction values by evaluating the epoch number first, followed by the fractional block position.

```c
int ckb_epoch_number_with_fraction_cmp(uint64_t a, uint64_t b)
```

```c
uint64_t epoch_a = 0x010020;  // Epoch 1, index 0, length 32
uint64_t epoch_b = 0x010120;  // Epoch 1, index 1, length 32
int cmp = ckb_epoch_number_with_fraction_cmp(epoch_a, epoch_b);
// cmp < 0 because index 0 < index 1 in same epoch
```

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

### Syscall Loading Pattern

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/00-index.md

Standard pattern for loading data via syscalls, handling buffer size requirements and success states.

```c
uint64_t len = buffer_size;
int ret = ckb_load_*(..., &len, ...);  // len updated with actual size
if (ret == CKB_SUCCESS) {
  // Use data, len bytes
} else if (ret == CKB_LENGTH_NOT_ENOUGH) {
  // Buffer too small, len has required size
}
```

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

### Implement Safe Buffer Loading

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/07-errors.md

Verify buffer size requirements and handle potential errors before proceeding with cell data operations.

```c
int safe_load_cell(uint8_t* buffer, uint64_t* len, size_t offset,
                   size_t index, size_t source) {
  uint64_t original_len = *len;
  
  // First attempt to get actual size
  int ret = ckb_load_cell(buffer, len, offset, index, source);
  
  if (ret == CKB_LENGTH_NOT_ENOUGH) {
    // len now contains required size
    if (*len > original_len) {
      ckb_debug("Buffer too small");
      return CKB_LENGTH_NOT_ENOUGH;
    }
  } else if (ret == CKB_INDEX_OUT_OF_BOUND) {
    ckb_debug("Cell index out of bounds");
    return ret;
  } else if (ret != CKB_SUCCESS) {
    ckb_debug("Unknown error");
    return ret;
  }
  
  return CKB_SUCCESS;
}
```

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

### Configure Section Management

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/08-configuration.md

Enable dead code elimination by placing data and functions into individual sections.

```bash
-fdata-sections -ffunction-sections
```

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

### Define spawn_args_t structure

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/06-types.md

Structure definition for configuring child process creation via ckb_spawn.

```c
typedef struct spawn_args_t {
  size_t argc;                    // Number of command-line arguments
  const char** argv;              // Array of argument strings
  uint64_t* process_id;           // [Out] Process ID of spawned process
  const uint64_t* inherited_fds;  // File descriptors to inherit (0-terminated)
} spawn_args_t;
```

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

### Manage Checksum Verification

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/08-configuration.md

Commands for generating, verifying, and updating build checksums to ensure reproducibility.

```makefile
make build checksum CHECKSUM_FILE=checksums.txt
```

```bash
shasum -a 256 -c checksums.txt
```

```bash
./scripts/reproducible_build_docker --update
```

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

### Load Header by Field with Buffer Check

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/02-syscall-functions.md

Checked version of the header field loading syscall.

```c
int ckb_checked_load_header_by_field(void* addr, uint64_t* len, size_t offset,
                                     size_t index, size_t source, size_t field)
```

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

### ckb_dlopen

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/02-syscall-functions.md

Convenience wrapper for ckb_dlopen2 with hash_type=0 (data hash).

```APIDOC
## ckb_dlopen

### Description
Convenience wrapper for ckb_dlopen2 with hash_type=0 (data hash).

### Signature
int ckb_dlopen(const uint8_t *dep_cell_data_hash, uint8_t *aligned_addr, size_t aligned_size, void **handle, size_t *consumed_size)
```

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

### Safe String Processing in C

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/04-libc-functions.md

Demonstrates manual bounds checking before copying strings to prevent buffer overflows, as runtime checks are not provided.

```c
#include <string.h>
#include <stdint.h>

#define MAX_STRING 256

int safe_string_processing() {
  char buffer[MAX_STRING];
  const char* source = "input";
  
  // Safe copy
  size_t len = strlen(source);
  if (len >= MAX_STRING) {
    return -1;  // Error: string too long
  }
  memcpy(buffer, source, len + 1);  // +1 for null terminator
  
  return 0;
}
```

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

### Build Safe Execution Arguments

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/05-utilities.md

Constructs and encodes arguments into a hex format suitable for execution.

```c
#include "ckb_exec.h"

int build_and_exec_args() {
  CkbBinaryArgsType args;
  CkbHexArgsType hex_args;
  
  ckb_exec_reset(&args);
  
  // Build arguments
  uint8_t arg1[] = {0x01, 0x02, 0x03};
  if (ckb_exec_append(&args, arg1, 3) != 0) {
    return -1;  // Failed to append
  }
  
  uint8_t arg2[] = {0x04, 0x05};
  if (ckb_exec_append(&args, arg2, 2) != 0) {
    return -1;
  }
  
  // Encode to hex format
  if (ckb_exec_encode_params(&args, &hex_args) != 0) {
    return -1;
  }
  
  // Now hex_args.buff contains colon-separated hex for exec
  return 0;
}
```

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

### Load Witness Data

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/02-syscall-functions.md

Retrieves witness data into a provided buffer. Ensure the buffer is large enough to hold the expected data size.

```c
int ckb_load_witness(void* addr, uint64_t* len, size_t offset,
                     size_t index, size_t source)
```

```c
uint8_t witness[4096];
uint64_t len = sizeof(witness);
int ret = ckb_load_witness(witness, &len, 0, 0, CKB_SOURCE_INPUT);
if (ret == CKB_SUCCESS) {
  // Witness data available (e.g., signature, proof)
}
```

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

### Load Cell with Buffer Check

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/02-syscall-functions.md

Checked version of the cell loading syscall.

```c
int ckb_checked_load_cell(void* addr, uint64_t* len, size_t offset,
                          size_t index, size_t source)
```

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

### Makefile for CKB C Projects

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/08-configuration.md

A standard Makefile configuration for compiling CKB C programs using clang and ld.lld, including flags for RISC-V targets and optimization.

```makefile
CC := clang
LD := ld.lld

CFLAGS := --target=riscv64 -march=rv64imc_zba_zbb_zbc_zbs -O3 \
          -fdata-sections -ffunction-sections \
          -fno-builtin-printf -fno-builtin-memcmp \
          -nostdlib \
          -DCKB_C_STDLIB_PRINTF -DCKB_PRINTF_DECLARATION_ONLY \
          -DCKB_ONE_BATCH_SIZE=16384 \
          -Ideps/ckb-c-stdlib -Ideps/ckb-c-stdlib/libc

LDFLAGS := -static -Wl,--gc-sections

CHECKSUM_FILE ?= checksums.txt
SOURCE := c/main.c
OUTPUT := build/main

default: build

build: $(OUTPUT)
	@if [ $$(stat -f%z $(OUTPUT) 2>/dev/null || stat -c%s $(OUTPUT)) -gt 409600 ]; then \
		echo "Warning: Binary size exceeds 400KB"; \
	fi

$(OUTPUT): $(SOURCE)
	@mkdir -p build
	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $<

checksum: build
	shasum -a 256 build/* > $(CHECKSUM_FILE)

check: build
	shasum -a 256 -c $(CHECKSUM_FILE)

clean:
	rm -rf build

.PHONY: default build checksum check clean
```

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

### Configure Printf Behavior

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/08-configuration.md

Set printf behavior via Makefile flags to control binary size and debug output.

```makefile
# Configuration 1: Printf disabled (smaller binary)
CFLAGS += -DCKB_PRINTF_DECLARATION_ONLY

# Configuration 2: Printf enabled with debug output
CFLAGS += -DCKB_PRINTF_DECLARATION_ONLY -DCKB_C_STDLIB_PRINTF

# Configuration 3: No printf support at all
# (Don't include -DCKB_PRINTF_DECLARATION_ONLY)
```

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

### Simulator Configuration JSON

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/simulator/README.md

This JSON file configures the simulator for running scripts. It specifies whether to run a lock or type script, the index of the script in the input, the transaction hash, and the filename of the dumped transaction data.

```json
{
  "is_lock_script": true,
  "script_index": 0,
  "main": "0xa98c212cf055cedbbb665d475c0561b56c68ea735c8aa830c493264effaf18bd",
  "0xa98c212cf055cedbbb665d475c0561b56c68ea735c8aa830c493264effaf18bd": "original.json"
}
```

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

### Load input metadata with ckb_load_input

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/02-syscall-functions.md

Retrieves transaction input metadata such as out-points and since references.

```c
uint8_t input[64];
uint64_t len = sizeof(input);
int ret = ckb_load_input(input, &len, 0, 0, CKB_SOURCE_INPUT);
if (ret == CKB_SUCCESS) {
  // Input metadata available
}
```

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

### Load executable code with ckb_load_cell_data_as_code

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/02-syscall-functions.md

Loads cell data into memory for dynamic script execution, requiring an aligned memory buffer.

```c
uint8_t code_buffer[65536] __attribute__((aligned(4096)));
int ret = ckb_load_cell_data_as_code(code_buffer, sizeof(code_buffer),
                                     0, 32768, 0, CKB_SOURCE_CELL_DEP);
if (ret == CKB_SUCCESS) {
  // Code is loaded at code_buffer, ready for execution
}
```

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

### Safe Type ID Loading Pattern

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/07-errors.md

Demonstrates the process of loading a Type ID from script arguments and validating it, including error handling for invalid data.

```c
#include "ckb_type_id.h"

int safe_type_id_validation() {
  uint8_t type_id[32];
  
  // Load type ID from script args at offset 0
  int ret = ckb_load_type_id_from_script_args(0, type_id);
  if (ret != CKB_SUCCESS) {
    if (ret == CKB_INVALID_DATA) {
      ckb_debug("Failed to extract type ID from script args");
    }
    return ret;
  }
  
  // Validate the type ID
  ret = ckb_validate_type_id(type_id);
  if (ret != CKB_SUCCESS) {
    if (ret == CKB_INVALID_DATA) {
      ckb_debug("Type ID validation failed");
    }
    return ret;
  }
  
  return CKB_SUCCESS;
}
```

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

### Minimal Makefile for CKB Scripts

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/00-index.md

Standard Makefile configuration for compiling CKB scripts targeting RISC-V 64-bit architecture.

```makefile
CC := clang
CFLAGS := --target=riscv64 -march=rv64imc_zba_zbb_zbc_zbs -O3 \
          -fdata-sections -ffunction-sections \
          -fno-builtin-printf -fno-builtin-memcmp \
          -nostdlib -DCKB_PRINTF_DECLARATION_ONLY \
          -Ideps/ckb-c-stdlib -Ideps/ckb-c-stdlib/libc
LDFLAGS := -static -Wl,--gc-sections

build/main: c/main.c
	mkdir -p build
	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $<
```

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

### Set Target Architecture

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/08-configuration.md

Specify the 64-bit RISC-V architecture required for CKB execution.

```bash
--target=riscv64
```

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

### Configure Exec Arguments Limits

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/08-configuration.md

Override default limits for binary argument encoding using Makefile flags.

```makefile
CFLAGS += -DCKB_EXEC_MAX_ARGS_COUNT=32 \
          -DCKB_EXEC_MAX_BUFF_LEN=65536
```

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

### Load Transaction Hash with Buffer Check

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/02-syscall-functions.md

Verifies that the transaction hash fits within the provided buffer.

```c
int ckb_checked_load_tx_hash(void* addr, uint64_t* len, size_t offset)
```

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

### ckb_vm_version

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/02-syscall-functions.md

Queries the version of the CKB VM currently executing the script.

```APIDOC
## ckb_vm_version()

### Description
Query the version of the CKB VM currently executing the script.

### Returns
- **int** - VM version number (0, 1, 2, etc.)
```

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

### Configure Garbage Collection

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/08-configuration.md

Remove unused sections to minimize the final binary size.

```bash
-Wl,--gc-sections
```

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

### Load Script Hash

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/02-syscall-functions.md

Retrieves the 32-byte hash of the currently executing script.

```c
int ckb_load_script_hash(void* addr, uint64_t* len, size_t offset)
```

```c
uint8_t script_hash[32];
uint64_t len = 32;
int ret = ckb_load_script_hash(script_hash, &len, 0);
if (ret == CKB_SUCCESS) {
  // Verify this script's identity
}
```

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

### ckb_dlopen2 Function Signature

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/02-syscall-functions.md

Loads a dynamic library from a cell dependency. Returns a handle for symbol lookup via ckb_dlsym.

```c
int ckb_dlopen2(const uint8_t* dep_cell_hash, uint8_t hash_type,
                uint8_t* aligned_addr, size_t aligned_size, void** handle,
                size_t* consumed_size)
```

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

### Integer Formatting with printf

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/04-libc-functions.md

Displays various integer representations including decimal, hexadecimal, unsigned, and octal using standard printf specifiers.

```c
void print_integers() {
  printf("Decimal: %d\n", 42);
  printf("Hex: 0x%x\n", 0xdeadbeef);
  printf("Unsigned: %u\n", 4294967295u);
  printf("Octal: %o\n", 0755);
}
```

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

### Load Cell Data with Buffer Check

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/02-syscall-functions.md

Checked version of the cell data loading syscall.

```c
int ckb_checked_load_cell_data(void* addr, uint64_t* len, size_t offset,
                               size_t index, size_t source)
```

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

### Compute Transaction Hash with BLAKE2b

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/03-cryptography.md

Uses ckb_load_transaction to load the transaction data and computes its hash using the BLAKE2b algorithm.

```c
#include "ckb_syscalls.h"
#include "blake2b.h"

void compute_tx_hash_blake2b() {
  blake2b_state ctx;
  ckb_blake2b_init(&ctx, 32);
  
  uint8_t tx[65536];
  uint64_t len = sizeof(tx);
  int ret = ckb_load_transaction(tx, &len, 0);
  
  if (ret == CKB_SUCCESS) {
    blake2b_update(&ctx, tx, len);
    uint8_t hash[32];
    blake2b_final(&ctx, hash, 32);
  }
}
```

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

### printf

Source: https://github.com/nervosnetwork/ckb-c-stdlib/blob/master/_autodocs/04-libc-functions.md

Prints formatted output using the ckb_debug syscall. Requires the -DCKB_C_STDLIB_PRINTF compiler flag to be enabled.

```APIDOC
## int printf(const char* format, ...)

### Description
Prints formatted output to the debug console. Requires the -DCKB_C_STDLIB_PRINTF compiler flag.

### Parameters
- **format** (const char*) - Required - Format string (printf-style)
- **...** (variadic) - Optional - Arguments for format specifiers

### Returns
- **int** - Number of characters output or 0 if printf is disabled.
```
Tokens:
Raw