Primitives

The platform is built from three composable building blocks: **Transport, Data, and Execution. **Each runs independently and emits its own Primitive Checkpoints (PCkpt). The Master Chain re-validates those PCkpts into a single Global Checkpoint (GCkpt) stream, giving every action local autonomy with global finality.

How they fit together (at a glance)

Object-centric model: three kinds of objects: owned, shared, immutable… keeping parallelism safe.
Per-primitive PCkpts → GCkpt: each primitive signs off on its own ordered transactions and object roots; the Master Chain stitches them into the GCkpt stream.
Cross-primitive bundles: multi-primitive flows finalize only when all referenced PCkpt roots exist and signatures check out.
System SLOs: single-primitive flows finalize in about a second; cross-primitive bundles usually settle within a few. Transport targets 99.99% availability, data and execution 99.9%. Every mutation carries PCkpt/GCkpt IDs for full auditability.

Zero Layer (Transport & Clearing)

What it is: The network’s omnichain messaging and execution bus. It routes instructions and value across chains and clears them together — no pooled bridge liquidity, no rent-seeking middlemen.

What it guarantees

Secure checkpointing: every transaction confirmed by independent parties before moving forward. Tune confirmations for speed or security.
Atomic delivery: value moves all-or-nothing. No half-settled limbo states.
Delivery modes: go open with permissionless couriers or closed with permissioned operators and predictable SLAs.

Key objects: Channel (shared), Vault (shared), Operator/Courier (owned), DeliveryBatch (immutable). Each Zero Layer PCkpt summarizes delivered batches and state diffs, then ships them to the Master Chain for finality.

Where it’s used: Oracles broadcast updates over Zero Layer. Programmable Settlement consumes clearing results to trigger payouts and netting. Even Governance & Engagement runs its decisions and rewards on the same bus.

Oracle Network (Data Plane)

What it is: The platform’s data plane — fresh, auditable facts with receipts. Prices, protocol state, compliance signals, randomness, fair sequencing — all shipped with threshold attestations and explicit freshness bounds. No vibes, just evidence.

Data products:

Prices & rates: venue medians, TWAP/VWAP, FX, RWA NAVs.
Protocol state: reserves, collateral ratios, funding and interest, safety switches.
Compliance signals: sanctions lists, address risk scores, Travel Rule proofs (hash-only, no PII leaks).
Randomness: verifiable randomness for games and fair allocation.
Fair sequencing: ordering beacons that reduce extraction across venues.
Events: custody confirmations, bank rail status, and other off-chain signals that matter on-chain.

How it works: A diverse set of reporters → commit–reveal aggregation → threshold signatures → on-chain publication and cross-chain relay via Zero Layer. Heartbeats, timeouts, and failovers maintain liveness. Staking, slashing, and dispute windows keep reporters accountable.

SLAs & objects:

Latency tiers: from per-block to scheduled intervals.
Assurance tiers: configurable quorum size and diversity rules.
Availability: ~four-nines for core price feeds.
Objects: Feed (shared), Round (immutable), Reporter (owned), ORA PCkpt[k].

Programmable Settlement (Execution Plane)

What it is: The platform’s execution layer, a visual, drag-and-drop builder with a compiler underneath. Sketch flows as diagrams, and it turns them into chain-specific contracts and orchestrated actions across EVM, Sui, Solana, and Cosmos. Every run emits checkpoints, so you always have an auditable trail.

Builder experience:

Snap together nodes like Transfer, Swap, Mint/Burn, Upgrade, Policy Check, and Route.
Simulate state changes and preview fees/finality before you deploy.
Type-safe parameters keep the foot-guns locked away.
Drop to code view any time you want to extend or override a template.

Built-in safety & delivery:

Timelocks & staged rollouts for sensitive upgrades.
Circuit breakers for proposals, voting, and distributions.
Parameter guards to cap rates and deltas per epoch.
Rollback/abort nodes for controlled reversions.
Cross-chain delivery handled by Zero Layer, so your flows clear atomically across networks.

Node packs (examples, not exhaustive):

Governance & Engagement: Propose → Queue → Execute, vote, timelock, epoch rewards, reputation updates.
Compliance & Policy: KYC/allowlist gates, attestations, policy checks before or after actions.
Treasury & Rewards: Emissions scheduling, vesting, clawback, streaming, grants.
Liquidity & Routing: Swap, bridge, mint/burn, route selection, slippage/fee guards.
Risk & Controls: Circuit breakers, guardrails, pause/abort, staged rollouts.
Observability & Ops: Webhooks, metrics/alerts, admin multisig, upgrade recipes.