Status: active 0.30 implementation and acceptance plan. It is not a release announcement, a grammar freeze, or evidence that the listed capabilities are already complete.
The separate 0.30 capability ledger is authoritative for product-capability admission, evidence ceilings, release scope, and issue-closure recommendations. The executable-surface registry remains authoritative only for syntax and IR shapes already admitted by the compiler; neither record may be used to broaden the universe claimed by the other.
The 0.30 implementation branch starts from 0.26b commit 08c0ef38. The
candidate release path is a direct stable-version jump from 0.25 to 0.30. The
experimental 0.26b branch may be absorbed into 0.30 without publishing a 0.26
stable release. Until that decision is finalized, 0.26b remains an
evidence-bearing development line rather than a release promise. No Cargo
version, source edition, metadata schema, witness ABI, deployment identity, or
published package changes merely because this branch and plan use the 0.30
name.
The first Stage 1 implementation slice is now present: authoring successor
relations accept lock = exact_hash(script_hash) only for the dedicated
ScriptHash source domain. Typed CKB transaction-view hash fields produce that
type, while ckb::script_hash(Hash) makes conversion from an already trusted
raw hash explicit. The conversion does not prove Script existence, deployment,
or authorization. Formatter/LSP support and real CKB-VM matching and
substitution-negative fixtures ship with the compiler path. The bounded #25
Script-construction slice also adds script::args, script::new, and
script::hash: fixed args up
to 459 bytes are serialized as canonical Molecule Script data and hashed with
CKB Blake2b-256. CKB-VM differentials cover all four hash types and the exact
upper bound; invalid dynamic hash types return error 72. The frozen
cryptographic and authorization capability matrix
now classifies all ten portfolio capabilities and twelve value domains and is
validated as part of the business-corpus digest. All ten capabilities bind to
maximum-shape resource profiles; the exact BIP340 profile reproduces the
CellScript parent Lock and NovaSeal child verifier in complete CKB transaction
context during the release gate. Address decoding, dynamic
Script args, unrestricted native signature algorithms, and unbounded
cryptographic surfaces remain outside the admitted portfolio.
The implementation used cellscript-source-semantics-2027-0.30-dev1 during
development. The release candidate freezes that bounded contract under
cellscript-source-semantics-2027-0.30-v1; neither identity redefines
authoring1 or freezes the wider 1.0 grammar.
The first #24 runtime-view tranche is specified by the
0.30 CKB runtime-view matrix.
The additive typed HeaderDep and six-domain Since subset is specified in the
0.30 temporal-domain contract; it does
not by itself close issue #12.
Metadata schema 72 retains cellscript-ckb-runtime-view-v1 together with the
structured cellscript-ckb-runtime-access-provenance-v1 source/index/range
contract and adds the explicit bounded output Plan mapping. Typed Cell views
expose occupied/unoccupied capacity, consensus data hashes and input since.
The admitted input half of #7 is implemented and accepted under the
bounded GroupInput contract.
Native input BoundedCellSet<T, N> authoring now selects the current complete
Type Script's canonical GroupInput array, decodes fixed-width resources,
executes each pure predicate and numeric accumulator update exactly once, and
discharges every selected linear input. Shared simulator/CKB-VM cases, a 1024
element resource guard, independent machine mutations, and a ten-case live CKB
acceptance corpus cover the admitted input boundary. The admitted output half
is defined separately by the
bounded output Plan contract.
Typed HeaderDep views expose all three fields admitted by CKB's
LOAD_HEADER_BY_FIELD; and complete Script hashes are separated from code and
args hashes. CKB-VM tests cover a nonzero epoch, the derived epoch-start block,
one-past-last HeaderDep failure, and CellDep data-hash substitution. The matrix
also records exact CKB-VM Since vectors and checked decoder failures for all
mode/metric combinations. Checked EpochDuration construction and EpochNumber
add/sub now enforce the 24-bit domain with executable overflow and underflow
evidence. Exact 208-byte full-header decoding now supplies typed block number
and millisecond timestamp reads. Dynamic source indexes retain their parameter
binding and 32-bit runtime bound through metadata, generated TypeScript
builders, CKB-VM execution, and the standalone checker. Lowering record v8 now
binds the five HeaderDep field contracts to their final syscall, selector,
width, offset, and terminal-error instructions. It also binds canonical
constructed-Script hashing to the 53-byte Molecule prefix, fixed args bound,
hash-type set, byte-copy loops, Blake2b target, and error 72. The same version
now independently binds the bounded policy witness fallback, canonical
one-to-eight-record scan, Type/current-Script-hash selection, common-check
dominance, declared tag targets, selected argument forwarding and exact action
adapters to decoded machine instructions. Action predicate meaning and
deployment authentication remain separate evidence. Remaining work includes
complete builder parity, measurement, and release evidence. Owner-tagged
bounded raw/lock/entry/output_type witness views now
close the variable witness-value row with literal 65,536-byte bounds, exact
scalar reads, streaming Blake2b, stable absent/over-bound failures, and
schema/checker mutation coverage.
The runtime now also exposes the canonical 32-byte raw transaction hash through
ckb::transaction_hash() and LOAD_TX_HASH, with exact range provenance and
real CKB-VM evidence. The bounded
env::sighash_all_zero_lock(group, inputs, extra, bytes) domain uses that hash,
replaces the complete first group WitnessArgs.lock payload with equal-length
zero bytes, and commits to later group witnesses and transaction-level extra
witnesses in canonical order. A real CKB-VM differential matches the pinned
ckb-sdk-rust message generator. Its SighashAllDigest result, four literal
bounds, exact transform, scope, and order are bound in metadata schema 72 and
the independent checker. This is the simple all-zero placeholder domain; it
does not claim multisig layouts that preserve a nonzero configuration prefix,
and the older generic env::sighash_all(source) spelling remains fail-closed.
The P0 chain-identity prerequisite from issue #17 is also implemented on this
branch: transitive dependency environments are selected by exact chain ID and
genesis hash, explicit local-name mappings are revalidated, independent edges
remain explicit, external resolvers no longer look up an inherited label, and
canonical lock node IDs bind the complete selection. ProtocolBundle work can
therefore consume a frozen dependency graph without treating environment names
as deployment identity.
Issue #18's compiler-compatibility prerequisite is also implemented: the root
and all discovered transitive manifests are checked against the active
compiler before source loading, path/Git/Registry incompatibilities use stable
E2600 diagnostics with aggregated incoming-edge JSON, Registry resolution
selects only compatible releases, and lockfile v5 binds and revalidates the
range separately from exact build-compiler evidence. Versions 1 through 4 are
migrated only by explicit repinning.
Issue #16's package-instance prerequisite is implemented as the declared
single-package-coordinate-v1 resolver model. Coordinates are namespace plus
declared name; one selected graph admits one exact
version/source/feature/environment instance per coordinate, and E2601 rejects
incompatible incoming edges before a lock is written. Locked and frozen
materialization never selects a replacement, and versions 1 through 4 require
explicit repinning into the v5 schema.
The goal is business-scenario coverage comparable to hand-written Rust CKB Scripts for a defined, bounded portfolio. It is not unrestricted Rust language parity. CellScript should cover the common validation, state-transition, authorization, composition, and transaction-inspection needs of that portfolio without requiring a hand-written replacement for the primary verifier. Exact, identity-pinned external cryptographic or protocol verifiers remain a supported composition boundary when the compiler cannot and should not prove their internals.
CellScript reaches the 0.30 capability target only when every required portfolio fixture can be:
- expressed through the adopted authoring surface and versioned package contracts;
- compiled to a production-admitted CKB-VM artifact with no hidden fail-closed placeholder on an accepting path;
- constructed by generated builders using the same source, role, witness, and output correspondence contract enforced on chain;
- checked by typed metadata and the standalone artifact checker at the exact boundary each checker claims;
- executed through matched positive and adversarial CKB-VM fixtures, with a hand-written Rust reference where an equivalent implementation is practical;
- measured for ELF size, cycles, stack, witness bytes, transaction size, and occupied capacity; and
- reproduced through the applicable development, CI, backend, release, and deployment-evidence gates.
Passing one syntax example, emitting an ELF, or matching one Rust benchmark does not satisfy this definition. Capability claims must name the admitted source, runtime, builder, artifact-checker, product, and deployment universe.
The existing GitHub issues cover much of the foundation, but they do not yet form a complete 0.30 business-capability plan.
| Capability needed for the 0.30 target | Existing owner | Coverage assessment |
|---|---|---|
| Bounded variable-cardinality Type-group inputs | #7 | Implemented and accepted for native input BoundedCellSet<T, N> over the current complete Type Script's canonical GroupInput array, with fixed-width decoding, exact 0..=N cardinality, per-element predicates/accumulators, linear discharge, independent machine validation, shared simulator/CKB-VM fixtures, and live stateful CKB evidence. The required dev, ci, and backend gates passed on 2026-09-09 at 43e58780. Generic transaction iteration, non-Type roles, arbitrary loop effects, and dynamic outputs are outside this contract. |
| Bounded output plans and one-to-one output correspondence | #8 | Implemented and accepted on 0.30 for the admitted fixed-width direct-Plan-field contract: native authoring, shared CSARGv1 witness composition, exact GroupOutput order/count/data/Lock/Type/capacity checks, generated builders, transaction and adapter validation, independent machine evidence, shared fixtures, and clean-source 14-case live CKB and production evidence. The required dev, ci, and backend gates passed on 2026-09-09 at 00f39a16. Computed or dynamic output templates remain fail-closed. |
| Multi-Script transaction construction and conflict handling | #9 | Covered as the architecture owner. The ProtocolBundle must precede any .celltx convenience syntax. |
| Typed roles across Script boundaries | #10 | Closed artifact-known Cell/witness roles are implemented in ProtocolBundle with exact schema/interface/ELF/deployment identity. The bounded 0.30 scope is closed; runtime-selected open roles are explicitly deferred to #29 on top of #28's compatible-handle contract. |
| Runtime Script and verifier handles | #11 | Exact artifact receipts and fixed-width values are implemented for independently checked ProtocolBundle artifacts. Canonical checked Script construction/hashing is implemented for fixed args up to 459 bytes. The bounded 0.30 scope is closed; generic compatible-open handles are explicitly deferred to #28. |
Timelocks, epochs, timestamps, and Since |
#12 | Covered for typed temporal domains. The frozen business inventory now binds all four positive and five adversarial rows to one independently checked artifact and nine distinct CKB transactions with exact sidecar, raw-transaction, and serialized-transaction identities. It does not own the rest of the transaction-view and syscall surface; independent review is explicitly waived and the exact candidate replay passes. |
| Digest-committed substate and authenticated openings | #13 | The bounded fixed-width candidate is implemented: nominal Commitment<T>, explicit one-shot witness Opening<T>, exact CellScriptPackedHashV0/CKB Blake2b-256 identity, compare-before-materialize lowering, entry-witness builder metadata, successor output-field reuse, checked-runtime ProofPlan and typed-checker records, standalone inline-machine binding and mutation coverage (including exact cell-field root-slot plus offset provenance), formatter/LSP parity, golden vectors, maximum-shape resource gates, and real CKB-VM pass/tamper coverage for every committed-state inventory row. Dynamic values remain outside that evidence; independent review is explicitly waived. See the committed-substate contract. |
| Honest capability and product-completeness claims | #14 | Implemented by the versioned, gate-checked product capability ledger. It records status, priority, owner, reviewer state, dependencies, evidence ceiling, release scope, disposition, remaining work, and non-goals for #7 through #27 without redefining the executable-surface registry. |
| Reproducible workspace, resolver, compiler-requirement, build-plan, and upgrade behavior | #15, #16, #17, #18, #19, #20 | Implemented on the 0.30 branch: canonical workspace graphs, single-package-coordinate resolution, chain-identity-safe environments, enforced compiler requirements and Registry selection, stable resolve/build inspection schemas, and hashed transactional upgrade plans with reverse-dependent compilation and explicit apply. This closes the toolchain composition prerequisite without making a release or deployment claim. |
| Typed zero-knowledge verifier contracts | #22 | Covered as research and typed external-verifier composition. A circuit DSL is outside the 0.30 core. |
| Stable public value-generics surface | #23 | Proposal A is implemented and accepted on 0.30: public cross-package value templates and pure functions, fixed_value normalization, field-derived aggregate abilities, canonical interface hashing and compatibility, Registry/checker validation, and product-surface parity. The required dev, ci, and backend gates passed on 2026-09-08 at 69488316. |
| Typed CKB transaction views and runtime adapters | #24 | The bounded v1 candidate unifies admitted Cell/input/output/CellDep/header/witness/Script/hash/source operations without a raw syscall escape hatch. Typed provenance, CKB-VM adversarial coverage, and five exact non-cryptographic resource profiles cover the complete typed read-only handle table and its persistent-policy/generated-builder path: transaction/header/temporal, Output/GroupOutput/Script, stateful order policy, Input/GroupInput/CellDep/WitnessArgs, and a complete PolicyWitnessV1 view artifact. The independent checker also closes the exact InputView<T> to internal OutPoint-reference boundary. Full-header hashing and an in-language multisig-prefix signing transform are excluded from the frozen corpus. The repository-local implementation/evidence slice is complete and independent review is explicitly waived. |
| Cryptographic and authorization-domain contracts | #25 | The candidate matrix freezes ten capabilities and twelve value domains across native hashing, complete Script identity, raw transaction identity, bounded zero-Lock SighashAll, standard multisig, exact handles, committed openings, BIP340, and general trusted delegation. Nine rows bind maximum-shape cycle, stack, ELF, witness, transaction, and dependency budgets, including the reproducible BIP340 child-verifier measurement. Independent review is explicitly waived, the unified release gate passes, and the exact NovaSeal parent/BIP340 child plus bounded consensus and business artifacts are live in the checked-in Pudge deployment evidence. The admitted #25 scope was closed after the candidate and deployment evidence were pushed on 2026-09-19. See the capability matrix. |
| Rust-comparable business acceptance corpus | #26 | The candidate eight-family inventory, content-digest gate, matched-reference boundaries, and a real four-artifact/five-group CKB-VM settlement anchor are implemented. The anchor rejects authorization, fungible-state, settlement-output, persistent-policy-state, and CellDep substitutions and gates cycles, stack frame, ELF, witness, transaction, and occupied-capacity measurements. Its persistent partial_fill/settle/cancel policy consumes prior verified outputs across transactions. ProtocolBundle admits the anchor's exact artifacts, builders, Plan evidence, roles, witnesses, and CellDeps, materializes the identical executed transaction bytes, and binds aggregate VM evidence to each direct CellScript group. The canonical fixture pins all four ELF, lowering-record, source-map, and verified-bundle identities, the positive and all five rejected transaction identities, and its ProtocolBundle hash. Scenario evidence binds the positive anchor, identical ProtocolBundle materialization, both stateful policy outcomes, four transaction substitutions, and a pre-materialization PB200 role conflict to exact artifacts and transactions; all four positive and all five adversarial multi-Script inventory rows are exact-artifact fixtures. Every positive and adversarial row across all eight families now binds exact artifact and transaction identities. NFT/DOB uses one signed persistent lifecycle plus a separately identified typed-view capacity-adjustment artifact so the record does not overstate unsupported in-policy capacity mutation. External-verifier uses seven checked parents over fixed EXEC, SPAWN/WAIT, and exact verifier-handle contracts, while retaining the child internals as an explicit trusted boundary. Order/AMM adds the matched pool-merge artifact, local live-set replay rejection, and a focused price/reserve/output-order CKB-VM artifact for its last four rows. The maintainer re-accepted retrievable NovaSeal and iCKB reference commits; local production admission passed on pinned CKB f7fa4436, independent review is explicitly waived, and the accepted twelve-artifact scope is live in two confirmed Pudge transactions. The admitted #26 scope was closed after the candidate and deployment evidence were pushed on 2026-09-19. See the 0.30 business corpus. |
| Product, publication, and deployment closure | #27 | Candidate 74cff5fd and the current product gitlinks were pushed and read back on 2026-09-19: VS Code ee0f259a, website 6a61e49, NovaSeal 1e7c812, iCKB 53c5078a, and DOB 30709c97. Compiler/editor versions are 0.30.0; the opt-in source identity is cellscript-source-semantics-2027-0.30-v1. Canonical WASM SHA-256 is 419e8260c3c6acc9f950adf422de90163533c14af96043ebb7429f935b1393d6, with 571,696 gzip bytes under the 600 KiB budget. The candidate passed dev, full ci within release, backend, and release, including fresh pinned CKB f7fa4436 production/stateful acceptance. Independent review is explicitly waived. The twelve selected Pudge artifacts remain live in transactions 0x49572cfd…a562 and 0x24273eb1…54e9; reproduction from 74cff5fd matched their executable bytes while retaining historical deployment provenance 3cf60a10. Publication remains open under the no-TAC constraint. See the dated issue audit for the evidence boundary. |
The four gaps found during the 0.30 review now have explicit issue owners:
- a typed, bounded CKB transaction-view and runtime-adapter closure covering the admitted Cell, input, header, witness, Script, hash, source, and syscall result families as one versioned contract;
- a cryptographic capability policy defining which primitives are compiler built-ins, which are exact external verifier contracts, and how message-domain and Script-identity types prevent confused-deputy use;
- a named business-equivalence corpus that turns Token, NFT, order, AMM, temporal, multisig, committed-state, and multi-Script scenarios into release acceptance rather than examples; and
- end-to-end 0.30 product and deployment closure across generated builders, language services, the browser product, package publication, node admission, deployment identity, and the recorded independent-review waiver.
Issues #24 through #27 record their dependencies, failure boundaries, acceptance matrices, resource requirements, and stop conditions. This RFC owns their release-level coordination; it does not use the existence of an issue to silently admit a raw runtime feature.
Complete the adopted resource, action, lock, and require authoring model
over the versioned semantic foundation. Successor relations must work in
ordinary branches and cover replacement, fixed and bounded split/merge,
creation, retirement, identity, Lock, Type, data, and capacity policy without
requiring authors to write preview4's verbose container form.
The focused v1 schema-change plan/receipt workflow is implemented for one
explicitly selected local concrete same except relation, including added-field
implicit-preservation blocking and stale receipt rejection. Required remaining
closure includes graph-wide upgrade-plan receipt consumption, exact Script
identity types, complete accepted-path role accounting, multiple actions under one
persistent deployed policy, complex action/helper ABIs, formatter and recovering
parser support, LSP and editor behavior, and direct AST/IR elaboration. The
retained preview4 grammar remains executable reference evidence and is not the
0.30 authoring target or an intermediate-language requirement.
Treat #7 and #8 as one author-visible lifecycle system while preserving their separate security contracts. The admitted surface supports transaction-chosen cardinality from zero through a declared maximum, canonical group-relative selection, exact schema and Script identity, deterministic decoding, per-element checks, linear input discharge, and exact plan-to-output correspondence.
The implementation must cover bounded fungible splits and merges, batched state updates, receipt settlement, and capped claims. Missing, extra, duplicated, reordered, foreign, malformed, or over-bound elements must fail with stable errors. Builders and verifiers must consume one versioned ordering and witness specification.
The #7 input contract and #8 output contract are complete for their admitted
source and runtime boundaries. The output side uses bounded-output-plan-v1,
binds each Plan ordinal to the same GroupOutput ordinal, and rejects missing,
extra, reordered, foreign, malformed, under-capacity, or field/Lock-mismatched
outputs. See
the bounded output plan contract.
Define a new issue and a versioned support matrix for the CKB data a production contract can inspect. The initial matrix must decide and test:
- current Script and Script hash;
- Cell data, capacity, occupied capacity, Lock and Type Scripts and hashes;
- input out points and
since; - headers, header dependencies, epochs, timestamps, and block numbers;
- raw witnesses and
WitnessArgsfields with explicit ownership and bounds; - transaction and script-group sources, indexes, lengths, and out-of-bound behavior;
- transaction preimages and the exact message domains used for authorization;
- CellDep lookup and exact-identity EXEC or SPAWN/WAIT adapters; and
- stable handling of syscall errors, partial reads, malformed Molecule values, and oversized byte ranges.
CellScript does not need a raw numeric-syscall escape hatch. Every admitted operation must have a typed source contract, deterministic memory bound, metadata record, codegen implementation, independent machine check where claimed, and positive/adversarial VM evidence. Unsupported syscalls continue to fail before production artifact emission.
Implement #9, #10, and #11 in dependency order. The first product boundary is an artifact-only ProtocolBundle that admits exact checked artifacts, resolves global and group-relative roles, reports witness/index/CellDep conflicts, builds one transaction, and preserves per-Script evidence. Typed source syntax may be added only after that contract is stable.
The Phase 0 and offline composition core now use
cellscript-protocol-bundle-input-v1 and emit a canonical
cellscript-protocol-bundle-v1 hash. cellc protocol bundle check admits each
ELF through the standalone checker and detects the complete documented
ownership, placement, witness, dependency, Script/resource identity, capacity,
fee/change, network/profile, signature-domain, and out-of-range index conflict
matrix. Action entries now bind their generated builder manifest and exact
selected-action projection, and the same skeleton is validated against every
artifact's metadata builder assumptions with PB212 for missing or invalid
evidence. The emitted evidence truthfully leaves transaction serialization,
CKB-VM execution, and chain evidence unexecuted. The first runtime-adapter
slice now independently rechecks that report and materializes one concrete
Molecule transaction with exact raw/full hashes, size, capacity/fee evidence,
and global/group-relative indexes sharing one transaction-byte identity.
The adapter can also bind a successful node estimate_cycles result to every
direct group under that byte identity while retaining the aggregate cycles and
truthfully leaving per-group cycles unattributed. Exact-chain live input
resolution now verifies each ordered OutPoint, packed CellOutput, data,
capacity, and fee before dry-run. Live deployment resolution also verifies
direct code Cells and fully expanded dep groups against each admitted ELF hash
and Script code identity under the same transaction and chain evidence.
The adapter now gates signing on both live receipts, delegates key operations to
caller-supplied SDK unlockers, preserves compiler-owned witness fields, verifies
the signed bytes through node execution and tx-pool acceptance, and gates
submission on that evidence. Automatic builder-selected live Cells and
independently measured per-group cycles remain outside current evidence.
Confirmation now polls the canonical
transaction location to a caller-selected depth, restarts after an observed
reorg, and preserves the final inclusion/tip snapshot without claiming absolute
finality. See
CellScript ProtocolBundle v1.
The first #10 closure is also implemented without adding source syntax.
cellscript-protocol-closed-role-v1 references the existing physical Cell or
witness claims, requires one exclusive provider and shared-read consumers at
the identical physical source, and requires every participant's checked
metadata to expose the same Molecule type name/hash. Resolution copies exact
package, entry, interface, ELF, and deployment identities into the canonical
bundle. PB213 reports type, ownership, correspondence, or closed-foreign
identity conflicts. Runtime-selected/open participants remain blocked on #11's
typed Script-handle contract.
The exact-artifact #11 layer is now implemented across the artifact and source
runtime boundaries.
Each admitted artifact receives an exact receipt over package/lock-node/entry/role,
interface and typed-semantics hashes, ELF, target profile, the existing package
ABI identity, verified bundle, complete CKB Script, code CellDep, and chain.
The corresponding CSHDLv1-fixed-202 value commits to the receipt and the
runtime-relevant hash axes while remaining an ordinary value with no Cell
lifecycle authority. ProtocolBundle emits the full-value CKB Blake2b-256 hash;
ExactScriptHandle witness parameters and role-specific checked helpers bind
that literal to the selected Lock/Type Script hash or verifier CellDep data
hash in CKB-VM. Data-hash and Type-hash code identity are explicit separate
policies. cellc tx validate also binds exact values to their compiled
CSARGv1 parameter positions and resolved transaction Script/CellDep identity
before signing.
The first deployment-line data foundation is implemented separately. It
hash-links exact Type-hash version receipts, derives compatibility against the
baseline and predecessor across all six interface dimensions, records
monotonic active/yanked state, and emits the fixed 386-byte CSLINv1 value
committed as CSREGv1 || handle_hash. The distinct ckb-type-hash target
profile now admits only Type-hash generated-artifact deployment and the
standalone checker preserves that profile/hash-type contract. Standard TYPE_ID
admission/code Cell evidence, exact admission transitions, and mandatory
ProtocolBundle binding are implemented off chain. The CKB adapter independently
resolves both TYPE_ID Cells as live, rechecks their exact Scripts/data/network,
and blocks signing on substitution. Fixed DeploymentLineHandle witness values
and role-specific checked helpers now bind the active admission commitment,
exact code CellDep, and selected full Script identity in CKB-VM; spent admission
out points remain unavailable under ordinary CKB CellDep liveness. Generic
ScriptHandle<I> types, runtime-selected compatible construction,
compatible-open handles, and open cross-Script roles remain open.
Generated TypeScript action builders now expose the same ProtocolBundle v1
state names and artifact-binding schema as the Rust adapter. Their client
orders offline checking, live resolution, external signing resumption, signed
node execution, tx-pool acceptance, and submission. It accepts opaque signer
results and never accepts a private key field. Generated artifacts expose their
checked Molecule schema contracts, and bindClosedProtocolRole refuses a
provider or consumer that lacks the exact requested type/hash. They also bind
the exact-handle schemas and ABI/profile identities in their manifest and can
attach a successful checker-returned receipt/value only when all generated
artifact and deployment axes agree. Registry verified-build evidence
publishes the same bundle schema, artifact-binding schema, and runtime-adapter
identity only for complete independently checked CKB ELF bundles; source-only
and generic hash-bound artifacts remain unmarked. The website-rendered
ProtocolBundle end-to-end tutorial
uses those same schemas, states, and evidence limits.
Extend trusted external verification through exact artifact, interface, deployment, argument-adapter, and result contracts. General process or pipe programming is not required for parity. A new bounded IPC adapter is admitted only for a named business fixture and must define process, descriptor, cycle, buffer, deadlock, and error behavior. The compiler must never claim to prove an external verifier's internal parser, authorization, cryptography, or protocol semantics.
Define the cryptographic capability issue before adding primitives. The 0.30
core should provide exact domain-separated hash and signature contracts required
by the acceptance corpus, while larger or protocol-specific verification uses
the typed, identity-pinned external-verifier path. Raw Address, complete
Script, Script hash, code/data hash, public key, signature, message digest,
commitment, proof, and witness bytes must remain distinct types or checked
conversions.
Complete #13 for authenticated openings. Keep #22 as an optional research workstream unless a selected 0.30 fixture requires a ZK verifier contract; even then, 0.30 standardizes provenance, identity, statement binding, witness placement, and result enforcement rather than introducing a circuit DSL.
Create a dedicated issue and a canonical corpus containing at least:
| Family | Required scenario |
|---|---|
| Fungible asset | Authorized mint, transfer, bounded split, bounded merge, burn, replay rejection, and total-supply or conservation policy. |
| NFT or DOB | Mint with unique identity, metadata update, ownership transfer, capacity adjustment, burn, and duplicate-identity rejection. |
| Order and AMM | Partial fill or partial order, settlement across interacting asset groups, reserve/accounting checks, slippage or price bound, and adversarial output reordering. |
| Temporal | Absolute and relative timelock, vesting transition, typed epoch/timestamp/Since mismatch rejection, and required header-dependency behavior. |
| Authorization | Single-signature or standard Lock integration, multisig threshold change and spend, issuer authority, post-signing mutation rejection, and exact message-domain checks. |
| Committed state | Authenticated opening, successor commitment, stale or wrong opening rejection, and witness-envelope composition. |
| Multi-Script | One transaction involving at least three independently built artifacts with shared Cells or witnesses, ProtocolBundle conflict detection, per-group execution, and exact deployment identities. |
| External verifier | A real exact-hash verifier invoked through EXEC or SPAWN/WAIT, with wrong-dependency, wrong-adapter, nonzero-status, and post-build substitution failures. |
Each family needs positive and adversarial cases. Where a matched Rust reference exists, both implementations must run against the same serialized transaction fixtures and agree on accept/reject outcomes. Performance comparisons must name the exact checked scope and build profile; they are evidence for the corpus, not a universal claim that CellScript is smaller or faster than Rust.
Close #15 through #20 where they affect the selected corpus. Generated TypeScript and Rust-facing builders must materialize typed parameters, merge shared indexes and witnesses, preserve signing fields, and validate the same roles and output plans enforced by the Script. Native CLI, package loading, formatter, LSP, VS Code, metadata-only WASM, website Playground, Registry interfaces, and artifact checker must all report the same admitted capability boundary.
The browser bundle must pass its tracked size budget or the compiler surface must be intentionally split behind a versioned product contract. A committed bundle from an older capability set cannot serve as 0.30 evidence.
Comparable business coverage does not require:
- unrestricted recursion, unbounded loops, or allocator-backed unbounded Cell collections;
- arbitrary inline assembly, raw syscall numbers, CSRs, atomics, floating point, or the complete GNU assembler surface;
- automatic translation of arbitrary Rust crates into CellScript;
- compiler proof of the internals of an external cryptographic or protocol verifier;
- transaction-wide fuzzy Cell matching or authority inferred from names, schemas, builder choices, or Registry records;
- a circuit language or universal zero-knowledge system; or
- preserving experimental preview4 text as the final public grammar.
When a business fixture needs a capability outside this list, the requirement must be stated as a typed, bounded contract. The project should not respond by adding an untracked general-purpose escape hatch.
- File the four missing scoped issues identified above. Completed as #24 through
#27 when the
0.30implementation branch was opened. - Freeze the required business corpus and matched Rust reference boundaries. The candidate inventory and digest gate are implemented; release evidence is tracked separately and remains incomplete.
- Resolve shared witness ownership across #8, #13, and #22.
- Resolve the 0.30 Script identity, authorization, and source-value type contracts.
- Record whether 0.26 will be skipped; do not create a 0.26 stable tag merely to preserve numeric continuity.
- Complete the remaining authoring relations and graph-wide consumption of focused schema acknowledgements.
- Complete #12 for the admitted corpus. #7 and #8 are complete for the accepted
bounded GroupInput and GroupOutput-plan contracts, and #23 is complete on the
branch with its required
dev,ci, andbackendgate evidence. - Implement the typed CKB runtime-view issue and cryptographic capability issue.
- Extend typed semantics, ProofPlan, source maps, lowering records, runtime errors, and independent mutations together.
- Complete #9, #10, and #11 in dependency order.
- Close the relevant #15-#20 package, environment, build, and upgrade prerequisites. The branch now implements the complete #15-#20 toolchain composition, including transactional upgrade-plan generation and explicit stale-safe apply.
- Generate complete builders and execute multi-Script transaction fixtures.
- Execute every required corpus family under simulator and CKB-VM where each is authoritative.
- Run matched Rust differential cases and retain disagreements as release blockers until explained and resolved.
- Record worst-case resources and enforce budgets without deleting required checks or narrowing the promised corpus.
- Complete independent security reviews for dynamic selection/output correspondence, authorization, external delegation, and multi-Script composition.
- Pass
./scripts/cellscript_gate.sh dev,ci,backend, and the applicablereleasegate on the exact candidate source. - Rebuild and verify WASM, VS Code, generated builders, package contents, Registry-facing records, and all versioned sidecars.
- Reproduce clean-source CKB acceptance and stateful scenarios, then add node admission and deployment evidence for the selected network scope.
- Publish 0.30 only after the capability matrix identifies every row as implemented, deliberately excluded, or separately trusted with an exact boundary. A partial implementation retains a development identity.
The preferred planning assumption is that 0.26b changes are selectively folded into 0.30. The branch is valuable evidence for typed provenance, dispositions, entry selection, authoring experiments, trusted delegation, policy dispatch, CKB-VM lifecycle tests, independent checking, and backend economics. Absorbing that work does not require publishing a 0.26 stable artifact.
The transition must preserve compatibility axes independently:
- Edition 2026 meaning remains stable unless an explicit migration contract says otherwise.
- Preview4 and
authoring1source identities keep their recorded meaning; 0.30 introduces a new source identity only after the grammar and semantics are accepted. - Existing witness, output-plan, policy, metadata, checker, target-profile, and deployment formats are retained or versioned with explicit readers and migration tests.
- Existing Data1 deployments are not relabeled as VM2/Data2 artifacts.
- Package compiler requirements and chain identity are checked before source loading or dependency selection.
- No release document may describe 0.26b development evidence as a shipped 0.26 contract or describe the 0.30 target as already implemented.
The 0.30 capability claim is accepted only when all required workstreams A-G and their issue dependencies are complete for the frozen corpus. ZK research, unbounded algorithms, raw syscall access, and general process/pipe programming may remain outside the release. Their exclusion does not weaken the claim as long as the published comparison states that CellScript matches the selected bounded CKB business portfolio rather than arbitrary hand-written Rust.