Zero Layer - Primitives

Routing and selection

Developers can pick a channel explicitly or let the network auto-select one that meets their requirements.

Direct: send(channelId, payload, opts) — you name the channel, it delivers.
SLA-first: sendWith(require, prefer, payload, opts) — you declare what’s non-negotiable (require) and what’s nice-to-have (prefer). The network finds the best fit.

A thin, verifiable rail for moving data and value across chains with atomic, auditable finality.

What it is

Zero Layer is the network’s transport + clearing layer. It carries packets between primitives and chains, then anchors their results into the Master Chain so everyone lands on the same outcome.

What you get

Deterministic finality: per-primitive checkpoints (PCkpt) re-validated into the Master Chain’s global checkpoint (GCkpt).
Atomicity: multi-step, multi-primitive actions settle all-or-nothing.
Configurable delivery: open couriers for permissionless reach, operators for predictable SLAs, or hybrid for both.
Operational reliability: tight latency and availability targets, observed by channels and operators.

How it works

Prepare: a source primitive emits an intent (message/claim/transfer) with a channel and nonce.
Transport: couriers and/or operators deliver to the destination under channel rules.
Apply & credit: the destination applies the packet; if instant UX is needed, a Vault can front provisional credit.
Clear: the primitive committee signs a PCkpt over recent deliveries and object roots; the Master Chain re-validates it into the GCkpt. Credits reconcile, and bundles that don’t fully appear roll back.

Concepts

Channel (shared): a named route with user-facing guarantees, not low-level mechanics.
Vault (shared): prefunded liquidity for immediate credits; reconciled on GCkpt.
DeliveryBatch (immutable): ordered set of deliveries for a primitive epoch.
PCkpt: threshold-signed commitment for one primitive.
GCkpt: globally ordered stream of re-validated PCkpts on the Master Chain.

Channel properties

Each channel publishes a signed manifest anchored in checkpoints. A manifest sets:

Latency targets: p50 and p95 from apply → GCkpt, plus max GCkpt lag.
Availability target: transport uptime target over a rolling window.
Throughput limits: packets per second, burst size, payload size.
Fee model: base fee, per-byte fee, surcharges, rebates.
Delivery mode: open courier, operator-only, or hybrid.
Operator set: membership, attestations, bonds/insurance, escalation path.
Committee & cadence: signer thresholds and PCkpt schedule.
Vault coverage: prefund ratio and redemption rules.
Jurisdiction & compliance: KYC/allowlist requirements, residency notes.
Supported payloads: tokens, message types, size classes.
Security controls: replay windows, rate limits, caps, spam protection.
Observability: metrics, proofs, public dashboards, and audit exports.
Version & upgrades: notice period, compatibility windows, changelog.

Channel properties evolve via governance. Every change updates the signed manifest and shows up in subsequent checkpoints.

Routing and selection

Developers can pick a channel explicitly or let the network auto-select one that meets their requirements.

Direct: send(channelId, payload, opts) you name the channel, it delivers.
SLA-first: sendWith(require, prefer, payload, opts) you declare what’s non-negotiable (require) and what’s nice-to-have (prefer). The network finds the best fit.

Example requirements:

require: {
  latency_p95_ms <= 1500,
  availability >= 99.99,
  delivery_mode in [operator_only, hybrid],
  jurisdiction in [US, EU]
}
prefer: { fee_total: low }

Every receipt includes the selected channelId so audits and proofs can reference the exact manifest that was in force at send time.

Proof of SLA

Every delivery comes with a receipt that ties back to three anchors:

The channel manifest hash in effect at the time of send.
The PCkpt (Primitive Checkpoint) that includes the delivery.
The GCkpt (Global Checkpoint) height where that PCkpt was accepted.

With these three items, users can verify whether the channel actually delivered inside its declared envelope or catch a breach and trigger remediation.

Roles

Courier (permissionless): anyone can pick up a packet and deliver it. Best-effort, variable speed, earns fees or tips per delivery.
Operator (permissioned): delivery with guarantees. Operators back promises with bonds, accrue reputation, and meet SLA targets.
Primitive committee: signs the PCkpt for its primitive, anchoring deliveries into the checkpoint stream.
Master Chain: re-validates PCkpts into the GCkpt, providing network-wide finality everyone can point to.

Delivery modes

Open courier: maximum openness; variable latency, no guarantees.
Operator-only: restricted to vetted operators with documented SLAs.
Hybrid: (the best of both) operators provide guaranteed lanes, while couriers extend reach and resilience.

Modes are configured per channel/primitive and can change via governance.

Security

Checkpointed correctness: a delivery only counts once it’s in a committee-signed PCkpt and anchored in the GCkpt. No signature, no settlement.
Atomic bundles: cross-primitive workflows finalize only when all referenced PCkpts appear in the GCkpt. Partial execution isn’t an option.
Replay protection: per-channel nonces and idempotent apply logic make duplicates harmless.
Rate & route controls: configurable caps prevent spam, overloads, and route abuse.
Liveness: operator rotation, heartbeats, and multi-path courier delivery keep packets moving even under faults.

Performance (targets)

Single-primitive: usually under a second from apply → GCkpt.
Cross-primitive: a few seconds end-to-end, limited only by the slowest leg in the bundle.
Availability: transport aims for 99.99% uptime across channels.

Exact targets are published per operator and channel.

Economics

Fees : Senders or channels pay per delivery; optional tips for faster pickup.
Operator rewards : SLA‑meeting operators earn fees and reputation; repeat failures reduce routes and rewards via governance.
Vault yield : Liquidity providers earn a share of fees for enabling instant credits.

Developer surface

Zero Layer exposes a small, chain-agnostic API — also available as drag-and-drop blocks in the builder:

send(channel, payload, opts) → returns a deliveryId.
receive(deliveryId) → check delivery status.
getCheckpoint(primitive, height|hash) → fetch a PCkpt.
openChannel(params) / updateChannel(params) → create or modify channels.
configureOperators(list, slaProfile) → set operator permissions and SLA profile.
depositVault(asset, amount) / withdrawVault(asset, amount) → manage prefunded liquidity.
Events: subscribe to PacketSent, PacketReceived, PCkptCommitted, GCkptIngested, VaultReconciled.

Observability

Per-channel metrics: track latency, success rates, drops, and retries in real time.
Checkpoint explorer: browse PCkpts and GCkpts, follow bundle dependencies, and inspect proofs.
Audit trails: full end-to-end trace from original intent to GCkpt inclusion, stitched together with consistent IDs.

Upgrades & Governance

Committee rotation: committee membership, thresholds, and epochs update under continuity rules so progress never stalls.
Channel changes: fees, limits, and operator sets can be updated via governance, with every change anchored in checkpoints.
Versioning: PCkpt/GCkpt formats carry version tags so old and new can run side by side during upgrades.

Not

Not a monolithic bridge: Zero Layer is a thin, verifiable rail that primitives use for transport and clearing.
Not a single trust anchor: finality comes from the Master Chain’s GCkpt, built from many independent committees, no single point of failure, no central chokepoint.

TL;DR

Move messages and value across chains with atomicity, deterministic finality, and configurable delivery, optimized for real users and real money.