MALT Core v0.0.7

Release date: 2026-08-17

This is the first stable Core release from DeWebProtocol/malt-core. MALT
remains pre-v1 and experimental.

Release Contract

The source tag is the authoritative release artifact. This release publishes:

• the Go module at github.com/dewebprotocol/malt-core;
• structured typed MALT roots in the private-use 0x30VSBB codec layout;
• the malt.resolve/v0alpha1, malt.read/v0alpha1, and
  malt.map-proof/v0alpha1 verification profiles;
• the experimental client-root profiles documented in
  Client-Root Contract;
• the frozen Resolve/Read conformance corpus v1 for structured version-2 roots;
• the frozen Resolve/Read conformance corpus v2 for version-3 roots;
• the frozen Map-proof conformance corpus v1 for KZG and IPA membership,
  non-membership, and adversarial rejection;
• the frozen client-root conformance corpus v1 for exact KZG and IPA candidate
  computation and fail-closed inputs; and
• reproducible, content-addressed browser Verifier and Writer asset sets.

Split Writer assets use malt.web-writer.provenance/v3, which binds their
profiles and Core-enforced runtime invariants without asserting host device
selection or retry policy.

MALTVersionID=3 is a wire-format version, not the source release version.

Changes Since v0.0.7-rc.5

Core repository and module namespace

The application-neutral SDK repository moved from DeWebProtocol/malt to
DeWebProtocol/malt-core. Its Go module path is now
github.com/dewebprotocol/malt-core; downstream source imports must migrate to
that path and pin v0.0.7.

All earlier Core commits, tags, GitHub Releases, and release assets remain
unchanged in DeWebProtocol/malt-core. No historical tag was deleted,
retracted, moved, or recreated. See the
repository migration notice for old-path and
runtime-namespace implications.

The namespace migration does not alter roots, CIDs, commitment parameters,
commitments, proofs, transcripts, ProofLists, receipts, existing protocol
schemas, existing Resolve/Read conformance vectors, or wire encodings relative
to v0.0.7-rc.5. Final v0.0.7 adds dedicated Map-proof and client-root corpus
envelopes, schemas, and vectors without changing their enclosed wire profiles.
The release WASM assets are rebuilt from the renamed module and bind the new
repository, module, commit, corpus digests, and checksums in their provenance.

Final language-neutral conformance corpora

The checked-in malt.map-proof.conformance/v1 corpus covers KZG and IPA Map
membership, non-membership, proof tampering, cross-root relabeling, wrong-key
requests, target tampering, and strict JSON rejection. The checked-in
malt.client-root.conformance/v1 corpus binds complete update views and
semantic intents to exact candidate bundles, materializations, next views, and
sample operational receipts, with stale-base, view-tamper, wrong-backend, and
strict JSON rejection cases.

Go and browser/WASM tests consume the same frozen JSON bytes. The conformance
profile names version corpus envelopes; they do not change the enclosed wire
profile identifiers. Client-root candidates and receipts remain operational
outcomes, not portable transition, publication, freshness, or trust proofs.

Changes Since v0.0.7-rc.4

Authenticated Writer session checkpoints

The SDK Writer can now seal a verified session checkpoint using a caller-owned
32-byte key. The checkpoint authenticates the normalized update view, every
working root, and a caller-supplied digest of the materializer bytes. A valid
checkpoint restores the verified session state without recomputing every
complete vector.

The in-memory ArcSet materializer now supports deterministic detached state
export and strict restoration. Restore rejects duplicate scopes, roots, paths,
conflicting targets, invalid CIDs, and missing or multiply owned node paths.

Checkpoint persistence and key protection remain trusted-client policy. The
caller must restore the exact materializer bytes bound by the authenticated
digest before restoring a session. Cache misses, corrupt state, or unavailable
keys must fall back to normal Session.Load verification. A checkpoint is a
local execution cache, not a portable transition, publication, freshness, or
trust proof.

This SDK addition does not alter roots, CIDs, commitment parameters,
commitments, proofs, transcripts, ProofLists, receipts, schemas, or wire
encodings.

Changes Since v0.0.7-rc.3 Through v0.0.7-rc.4

Batched Map Writer commitments

The graph Writer now converts all canonical changes for one Map object into a
single semantic BatchUpdate. The radix implementation opens and validates
the existing top-level node once, applies affected subtree changes in
batch-local state, and computes and persists one final top-level commitment
after every change succeeds.

Input ordering is preserved, including multiple changes below the same root
slot. Tests require the batched result to match sequential updates exactly and
require one final top-level commitment for a multi-arc batch.

This optimization removes repeated top-level KZG or IPA commitment work from
multi-arc Writer transactions. It is an execution optimization, not an
aggregated proof or a new transition-proof contract. It does not alter roots,
CIDs, commitment parameters, commitments, proofs, transcripts, ProofLists,
receipts, schemas, or wire encodings.

Changes Since v0.0.7-rc.2 Through v0.0.7-rc.3

Fast KZG verifier initialization

Portable and browser verifiers now construct a verification-only KZG scheme.
It loads the canonical G1 generator and the first two G2 opening-key points,
without parsing or retaining the 4096-point Writer commitment key. The final
Verifier WASM does not link the 393,216-byte preprocessed Writer setup asset.

Fast KZG Writer initialization

KZG Writers now decode build-time validated canonical Lagrange G1 coordinates
instead of parsing the upstream JSON setup and decompressing 4096 points at
runtime. Both compact assets are derived from the exact pinned
go-kzg-4844 v1.1.0 setup. Generation enforces the upstream setup SHA-256,
performs full curve and subgroup validation, and emits asset fingerprints.

A reconstruction test repeats that derivation and byte-compares the committed
assets. Compatibility tests use unique values in every KZG slot and compare
commitments and openings at multiple bit patterns against the pinned upstream
implementation.

The rc.3 delta changes KZG setup loading and internal commitment, opening, and
verification execution while preserving externally observable parameters and
encodings. It does not alter roots, CIDs, commitments, proofs, transcripts,
ProofLists, receipts, schemas, or wire encodings.

Changes Since v0.0.7-rc.1 Through v0.0.7-rc.2

Separate Verifier and Writer runtimes

The browser Verifier no longer initializes Writer-only commitment state or IPA
fixed-base committer tables. Writer functionality is published as one KZG
module and three IPA modules using the direct, compact, and fast
committer profiles. Applications can load the Verifier independently and
initialize a Writer only when local mutation is required.

All IPA profiles preserve the same parameter set, commitments, typed roots,
transcripts, proofs, and wire formats. Profile selection never changes an IPA
operation into KZG.

Hardened Writer lifecycle

The browser Writer controller now provides lazy backend/profile
initialization, cancellation-safe startup, explicit single-runtime ownership,
exact backend/profile targeting, observable idle Worker failures, and
fail-closed retirement of fatal runtimes. Failed stateful operations are not
automatically replayed against a replacement runtime. Selecting a profile from
device signals or retrying another profile remains host policy.

Content-addressed WASM delivery

Verifier and Writer files are published as coordinated asset sets. Each set is
identified by the full SHA-256 digest of its exact SHA256SUMS bytes. Release
archive filenames bind both the extracted asset-set digest and the exact
compressed archive digest:

malt-verifier-v0.0.7-<asset-set-sha256>-<archive-sha256>.tar.gz
malt-writer-v0.0.7-<asset-set-sha256>-<archive-sha256>.tar.gz

Only complete digest paths are immutable. Consumers must load every file in a
runtime from one asset set, must not mix digests, and must reload when the
application entrypoint selects a new digest. The full contract is documented
in WASM Release Assets.

Protocol Baseline From v0.0.7-rc.1

Structured typed roots: 0x30VSBB

Typed MALT root codecs now use the project private-use 0x30VSBB layout, where
V identifies the wire version, S the semantic kind, and BB the commitment
backend suite. New constructors emit these version-3 codecs:

Semantic kind	KZG	IPA
Map	0x303101	0x303102
List	0x303201	0x303202

Decoders fail closed on unknown versions, semantics, backend suites,
combinations, identity-hash sizes, and mixed-profile children. Structured
version-2 roots remain readable and verifiable, but default constructors do not
emit them.

4096-slot KZG semantic geometry

KZG Map and List nodes now use all 4096 commitment positions. KZG Maps consume
SHA-256 keys as 12-bit radix digits. KZG Lists reserve position zero for
authenticated metadata and expose 4095 content positions. IPA remains a
256-position suite, using 8-bit Map digits and 255 List content positions.

The same backend-sized geometry is used by semantic producers,
materialization, and portable verification.

Verifiable Map non-membership

The new Map-proof contract verifies both membership and non-membership for KZG
and IPA roots. An exact absent keyed relation can be authenticated by:

• a proved empty radix slot;
• a conflicting terminal leaf; or
• a complete fixed-domain collision bucket.

Version-3 collision buckets authenticate their empty tail positions, enabling
sound collision-bucket non-membership. The release adds MapProofRequest,
MapProofResult, MapProver, VerifyMapProof, the
malt.map-proof/v0alpha1 schemas, the terminal ProofList step
map_absence, and the matching Go SDK and browser/WASM verification boundary.

Other Protocol and SDK Changes

• Add deterministic Resolve/Read conformance corpora for KZG and IPA.
• Add complete-view client-root values, sdk/writer, exact candidate-root
  bundles, root-bound Map materialization witnesses, and receipt-gated writer
  sessions.
• Add the browser Writer boundary that rc.2 now publishes as separate KZG and
  IPA profile modules.
• Add request-scoped read and writer observations for diagnostics.
• Narrow materializer and graph-writer dependencies to the capabilities used by
  each algorithm.
• Rebuild a verified structured-version-2 complete view as version 3 before
  applying client-side changes.
• Reject incomplete List materialization, noncanonical Map-proof coordinates,
  target relabeling, invalid UTF-8, stale intents, mismatched receipts, and
  mixed backend/version materialization.
• Remove radix.ProveTimings, (*radix.Map).ProveWithTimings, the obsolete
  process-global logger package, the former graph/querypath helper, and the
  unused zap and multierr dependencies.

Compatibility

The rc.2, rc.3, rc.4, and rc.5 changes do not alter MALT roots, CIDs, transcripts,
parameter sets, commitments, ProofLists, receipts, or proof encodings. Browser
integrations built against v0.0.7-rc.1 must adopt the split Writer filenames
and the createMaltWriterWorker controller API. Writer asset consumers must
validate malt.web-writer.provenance/v3.

The v0.0.7 release-candidate line remains an intentional pre-v1 source- and
wire-breaking change relative to v0.0.6.

v0.0.6 emitted the flat experimental codecs 0x300001 through 0x300004.
The current decoder intentionally does not classify those roots as structured
MALT roots. This release does not provide a flat-root migration layer;
experimental roots and their materialized proof-serving state should be
recreated.

Structured version-2 roots (0x302...) were introduced on main after
v0.0.6 and are not v0.0.6 roots. They remain available for read, proof, and
exact complete-view replay. New constructors emit version 3, and
collision-bucket non-membership requires the version-3 fixed-domain bucket
profile.

Removed Go APIs have no forwarding compatibility shims. The /v1 suffixes on
client-root profiles version serialized experimental profiles; they do not
declare MALT or its Go APIs stable at v1.

Known Limits

• Non-membership proves only whether one exact keyed relation is absent from a
  Map. It does not prove List-index, graph-path, object, payload-byte, or remote
  data absence.
• Ordinary Read keeps its existing missing-key result,
  ErrQueryNotFound; there is no corresponding List non-membership API.
• Collision-bucket non-membership is available only for version-3 fixed-domain
  buckets.
• The browser/WASM verifier is the same Go verifier compiled for WebAssembly,
  not an independent cryptographic implementation.
• Core does not select Writer profiles from browser capability hints or retry a
  different profile after failure; applications must define that host policy.
• A running client must reload after its application entrypoint selects a new
  Verifier or Writer asset-set digest.
• Client-root bundles and materialization receipts are not portable
  state-transition, publication, freshness, or trust proofs.

Release Validation

The final release gate includes:

set -euo pipefail
git fetch --prune --tags origin
git rev-parse --verify 'v0.0.7-rc.5^{commit}'
git merge-base --is-ancestor v0.0.7-rc.5 HEAD
git diff --check v0.0.7-rc.5...HEAD
test -z "$(gofmt -l $(find . -name '*.go' -not -path './vendor/*'))"
go test ./...
GOARCH=386 go test ./auth/commitment/kzg ./auth/commitment/ipa
sh scripts/test-verifier-wasm-vectors.sh
scripts/test-writer-wasm.sh
go vet ./...
go build -buildvcs=false ./...
scripts/build-wasm-release.sh v0.0.7 dist/wasm-release
scripts/check-wasm-release.sh dist/wasm-release
node scripts/test-wasm-release-adversarial.mjs dist/wasm-release

The verifier WASM gate runs 49 current Resolve/Read vectors plus 14 frozen
Map-proof vectors with both backends enabled, and 25 Resolve/Read plus 7
Map-proof vectors in each backend-selected verifier run. The Writer WASM gate
runs one exact accepted client-root vector and four rejected vectors for each
backend/profile target. Native Go tests independently regenerate and execute
the same checked-in corpus bytes.

Before tagging, compile a temporary external module against the candidate.
Build the release assets twice under different ambient Go environments and
umasks and require byte-identical output. Record the exact tagged commit, final
CI result, validation results, and published asset checksums in the GitHub
release.

Published Release Evidence

• Source commit: 53b5a18b5f4d5df823b7fc5be959014b2a928887
• Pull request: #194
• Go and CodeQL gates: successful run
• Two isolated release builds with different ambient environments and umasks were byte-identical.
• Adversarial validation rejected 7 self-consistent but non-canonical archives.

Exact uploaded SHA-256 values:

• SHA256SUMS: 26c9a714119a11be9e7acf299f2e94e4599f451d983c7466d11129235f89374f
• Verifier archive: 4b70f35ef7c57ca7fefd37de8ff6fed1efb4c2d5cacf02b841a721b9eb765b96
• Writer archive: d245c7bd4b3c5f9e68033773bca4b5d22b10d8e34444cfc723a91f1e201e71e9
• WASM release manifest: bb06df9a4cbb70dfcc5bdafa4d6fde10abfbcd418ffe2752308232d4ce6da2c4