CellScript - A DSL for Cell-Based Contracts

Infrastructure
, , ,
30

CellScript 0.24: Verifiable Builds and Reproducible Projects

When the CellScript 0.23 Registry went live, it made several gaps difficult to ignore. Internally, the compiler and package pipeline needed tighter security boundaries. Externally, projects consuming CellScript needed stronger evidence for what had been built, which source and dependencies it came from, and why the result could be trusted.

I decided to shorten the development cycle instead of leaving those problems for a distant milestone. Several other projects I maintain are beginning to use CellScript not only as a compiler, but also as a shared semantic foundation. For those projects to iterate steadily, that foundation needs reproducible builds, explicit execution evidence, and verification boundaries that do not depend on trusting the compiler alone.

That is why CellScript 0.24 arrives only ten days after 0.23.

This release focuses on four areas:

  1. Compiler artifacts can be checked independently.
  2. cellc test executes explicit backends.
  3. Cell.lock becomes authoritative for dependency resolution.
  4. CKB Lock Scripts can publish LS-IDL through the Registry.

Independent artifact verification

flowchart LR
    S["CellScript source"] --> C["CellScript compiler"]

    C --> E["CKB ELF"]
    C --> L["Lowering record"]
    C --> M["Source map"]

    E --> V["Independent artifact checker"]
    L --> V
    M --> V

    V --> R["Verification report"]
    R --> A["Auditors"]
    R --> G["Registry"]
    R --> D["Downstream projects"]

A CKB ELF build now produces two additional files:

ARTIFACT.lowering.json
ARTIFACT.sourcemap.json

The lowering record describes the path from typed IR to machine blocks. The source map connects ranges in the final ELF back to the original CellScript source.

The new cellscript-artifact-checker does not load the compiler frontend or depend on the code generator. It independently checks a bounded set of properties, including:

  • canonical JSON encoding;
  • ABI and stack-frame consistency;
  • control-flow and reachability rules;
  • the allowed RV64 instruction surface;
  • call targets, syscalls, and stack restoration;
  • bindings between the lowering record, source map, and final ELF;
  • ProofPlan references and machine-block digests.

This is not a proof that the compiler is universally correct, nor is it a complete source-to-machine equivalence proof.

It provides something narrower and more practical: Registry workers, auditors, and downstream tools can verify specific structural facts without trusting the same compiler implementation that produced the artifact.

cellc test now runs an explicit backend

Previously, a successful test could sometimes mean only that the test source compiled. CellScript 0.24 makes the execution boundary explicit.

Tests must select a backend:

cellc test --backend simulator
cellc test --backend ckb-vm
cellc test --backend all

A test scenario can describe:

  • live Cell consumption and replacement;
  • Lock Script and Type Script identities;
  • Cell deps, headers, and since;
  • witness fields;
  • expected successful results;
  • exact failure codes;
  • multi-step state transitions.

The simulator remains a development tool and does not provide consensus evidence. The CKB-VM backend provides local runtime evidence, but it is still not evidence of deployment or confirmed execution on-chain.

For compile-only checks, --no-run must be selected explicitly. The tool no longer presents a test that was never executed as a successful runtime result.

The checked-in examples/scenario_basics package contains a small positive and exact-negative example that runs on both backends.

Cell.lock is now the build authority

flowchart LR
    M["Cell.toml requirements"] --> U["Explicit repin<br/>cellc lock / cellc update"]
    X["Git and Registry sources"] --> U
    U --> L["Cell.lock v3<br/>exact dependency graph"]

    L --> B["build / check / test"]
    B --> O["Artifacts and evidence"]

    X -. "not consulted during an ordinary locked build" .-> B

CellScript 0.24 introduces Cell.lock version 3.

The lockfile is no longer a flat list of selected versions. It records a complete dependency graph, including:

  • the digest of the root Cell.toml;
  • exact dependency versions and sources;
  • immutable Git commits or Registry snapshots;
  • source-tree and dependency-manifest digests;
  • dependency edges;
  • features and test-only dependencies;
  • CKB environments bound to a chain ID and genesis hash.

Ordinary build, check, and test commands consume the existing graph. They do not silently select newer versions or follow a moved Git branch.

Dependency selection happens only during an explicit operation such as:

cellc lock
cellc update

Using --frozen additionally disables network access and lockfile writes.

This gives local development, CI, and audit environments the same dependency graph. It also prevents Registry changes, moving Git references, or external resolvers from unexpectedly affecting a normal build.

Projects upgrading from 0.23 must regenerate Cell.lock.

LS-IDL for CKB Lock Scripts

CellScript 0.24 adds an end-to-end workflow for validating, binding, publishing, and retrieving LS-IDL documents.

The cellc artifact ls-idl command can:

  • validate a bounded LS-IDL 0.1 document;
  • calculate the SHA-256 digest of the original idl.json bytes;
  • bind that digest to a CKB executable;
  • create a Registry publication bundle;
  • retrieve the original IDL using a deployed Script identity.

The Registry stores the original bytes rather than parsing and reserializing the document. Both the compiler-backed verifier and the independent artifact verifier check the IDL, its digest, and the digest committed to the executable.

This establishes which interface document was published for a Lock Script. It does not prove that the Script correctly implements that interface, and it does not replace a security audit.

Compatibility coverage includes the current upstream ckb-idl-client vectors and the checked-in IDLs used by the supported upstream tooling. A smaller walkthrough is available in examples/registry_ls_idl.

Other changes worth noting

CellScript 0.24 also includes several integration and maintenance changes:

  • CKB ELF generation now always uses the audited internal assembler. The external RISC-V toolchain fallback has been removed.
  • Native cellc run includes the VM runner by default, but accepts only standalone ELF programs that do not require transaction context.
  • The Registry has a least-privilege verifier for artifact-only CKB bundles. It depends on the standalone checker rather than the full compiler.
  • Mainnet and Pudge Testnet Registry sites share the same interface and frontend assets while keeping APIs, object storage, address prefixes, and chain state separate.
  • The Registry Type Script has a reproducible 0.24.0 ELF identity.
  • The Playground can restore local workspaces, restart a failed compiler worker, retain the last valid output after a failed compile, and display a metadata-derived Cell Flow view.
  • Fiber configuration has moved from the unmaintained serde_yaml crate to serde_yaml_ng.

CKB Adapter migration

The CKB Adapter no longer exposes the permanently fail-closed methods:

deploy_artifact
build_deploy

The supported deployment flow is now:

  1. Build and verify an unsigned transaction with build_deploy_transaction.
  2. Hand the transaction to an external wallet for authorization.
  3. Submit the signed transaction explicitly.

CellScript should not hold wallet keys or blur the boundary between constructing a transaction and authorizing it.

Upgrading from 0.23

A typical upgrade should follow this order:

  1. Regenerate Cell.lock.
  2. Rebuild the ELF and metadata.
  3. Preserve the new lowering record and source map.
  4. Verify the artifact with the standalone checker.
  5. Update CKB Adapter deployment calls.
  6. Select the intended test backend explicitly.
  7. For Lock Scripts, decide whether to publish and bind an LS-IDL document.

CellScript 0.24 does not change the Edition 2026 source-language contract. It does change persisted metadata, lockfiles, and artifact evidence, so 0.23 and 0.24 build outputs should not be mixed.

Getting the source

Until the final tag is published, the release candidate is available from:

git clone --branch nightly-0.24 \
  https://github.com/CellScript-Labs/CellScript.git

Full release notes:

CellScript 0.24 Release Notes

Repository:

CellScript-Labs/CellScript

4 Likes
CKB Ecosystem Biweekly Update