Abstract

Money moves faster every year, but the pipes underneath still look like patchwork plumbing from the 90s. Digital finance has grown into a sprawling ecosystem of chains, ledgers, and APIs; yet the coordination layer that ties them together is brittle, contradictory, and slow. Bridges, price feeds, compliance checks, and settlement rails each swear they know the truth, but they disagree on when it’s true, or if it’s final at all. The outcome is quite predictable: fragmented systems, idle capital, and endless dashboards that look busy while nothing really settles.

Symptoms we target

Fragmented trust and finality: Cross-chain flows mash together L1 finality, L2 checkpoints, off-chain approvals, and app-level retries into a messy soup. Everyone claims they know when something “settled,” but no one has a single, auditable source of truth.
Concurrency and contention: Everything gets shoved through the same traffic light, even when most cars have their own lane. Shared state like vaults or registries forces global ordering, while simple one-user actions could have flown by in parallel. Today’s stacks mix these paths together and pay the price in latency.
Data fragility: Price manipulation, stale feeds, and opaque aggregation bleed into margin calls, exposure caps, and payouts. Auditors call. Screenshots appear. No one is happy.
Compliance evidence gaps: Most systems can only say “trust us, we checked.” Proving that policies actually ran, with machine-readable evidence, not screenshots… is still hard. Regulators don’t want vibes, they want receipts.
Developer drag: Every team ends up reinventing the same plumbing: messaging, settlement, policy checks, monitoring. Visual tools are scarce, so it’s copy-paste ChatGPT (🤞) or bust. Integration bugs sneak in, chew through roadmaps, and leave teams shipping slides instead of products.

What good looks like

A single, object-centric model with owned, shared, and immutable state so things can run in parallel without stepping on each other’s toes.
Per-primitive checkpoints that capture local truth, rolled up by a Master Chain into one auditable Global Checkpoint stream everyone can actually point at.
A reliable data plane with aggregation you can trust and SLAs that mean something more than “we’ll try our best.”
A visual, web-based drag-and-drop IDE (powered by Rete.js) where well-typed blocks snap together into real contracts and flows. No glue code, no duct tape.

What We Are Building

A modular platform stitched together by the Master Chain, with three planes that each do their job and don’t trip over over each other:

Zero Layer (Transport & Clearing): The omnichain messaging and execution bus. It moves packets, runs secure checkpoints, and clears value atomically. Delivery can be open to permissionless couriers or locked down with permissioned operators: pick your lane, pick your SLA.
Oracle Network (Data Plane): The source of truth that doesn’t flake out. Prices, protocol state, compliance signals, randomness, fair sequencing… even your own custom feeds (via our visual drag-and-drop interface and SDKs) if you want to play Gordon Ramsey. Every update ships with a quorum signature, timestamp, and freshness bounds, so you stop guessing and start trusting.
Programmable Settlement (Execution Plane): A visual, drag-and-drop builder and SDK that compiles graphs into transactions over our object model. It’s got simulation, safety checks, and one-click deploy, so you spend less time debugging glue code and more time shipping flows.

Each primitive emits a Primitive Checkpoint (PCkpt). The Master Chain re-validates them into a single Global Checkpoint (GCkpt) stream, local autonomy with global finality. Compliance and governance aren’t bolted on later, they’re baked in with policy oracles, typed capabilities, and time-locked upgrades.

The result: faster launches, lower risk, and no more spreadsheets of doom.

Architecture Highlights

Object-centric state

Owned objects: scoped to a single user or app. Think balances, positions, visual editor and SDK projects, or operator bonds. If you own it, you’re the only one who mutates it.
Shared objects: coordination points touched by many parties at once: channels, vaults, feeds, registries. These require consensus to update safely.
Immutable objects: the stuff carved in stone: templates, node definitions, verified artifacts. They never change.

(Note: all objects are available across all primitives, but “shared” specifically means many distinct actors can change the same state at the same time.)

Per-primitive checkpoints

Each primitive maintains a ledger of object updates and emits a PCkpt(k) that commits a hash of touched objects and versions, an ordered transaction list, and a threshold signature from that primitive’s committee.
The Master Chain re-validates PCkpts and appends them to the GCkpt stream. Local control plus a single, audited final ledger everyone can agree on.

Concurrency paths

Fast path: transactions that only touch independent owned objects, no bottlenecks, just go.
Consensus path: transactions that modify shared objects, ordered by a committee to keep everyone honest.

Cross-primitive atomicity

Multi-primitive flows are wrapped in a bundle that references PCkpt roots. The Master Chain finalizes the bundle only when all referenced roots exist and signatures check out.

Developer mapping with Rete.js

Each node declares the object types it reads or writes. The compiler enforces version constraints, ownership and capability checks, and checkpoint boundaries. Templates compile into immutable objects. Deployments target shared or owned objects as needed.

Core Primitives

Zero Layer (Transport and Clearing)

The network’s messaging and execution bus. It connects blockchains, apps, and financial systems and runs clearing so value and instructions always move together. No pooled bridge liquidity, no middlemen skimming in the shadows.

Transport

Authenticated routing for tokens and instructions across networks. Other primitives plug into it for coordination.

Clearing on Zero Layer

Secure checkpoint: every transaction gets confirmed by independent parties before moving forward. You can dial confirmations up for safety or down for speed.
Atomic transfers: value moves all-or-nothing. No half-settled limbo states.
Delivery modes:
Prefunded liquidity vaults: stablecoins or volatile tokens can be redeemed for instant cash value, backed by auditable settlement.

Object model and checkpoints

Channel (shared): routes messages and holds policy and liveness.
Vault (shared): prefunded assets and clearing logic.
Operator or Courier (owned): stake, reputation, SLA stats.
DeliveryBatch (immutable): record of delivered packets.
ZL PCkpt[k]: summarizes delivered batches and state changes, then ships them to the Master Chain for inclusion in GCkpt.

Platform-wide use

Oracles broadcast their updates over Zero Layer.
Programmable Settlement consumes clearing results to trigger payouts and netting.
Governance & Engagement (GES) distributes decisions and rewards on the same bus.

Oracle Network (Data Plane)

The platform’s data plane — fresh facts with receipts. It delivers auditable, low-latency data and coordination signals that Zero Layer and Programmable Settlement run on. The goal is simple: the right fact, at the right time, with the right assurance.

Data products

Prices and rates: spot, per venue, median, trimmed mean, TWAP/VWAP, FX, benchmarks, RWA NAVs, cross-chain consistency.
Protocol state: reserves, collateral ratios, funding/interest, safety switches, “oracle of oracles” cross-checks.
Compliance signals: sanctions lists, address risk scores, Travel Rule proofs; all hash-based so no PII leaks.
Randomness: verifiable randomness for games and fair allocation.
Fair sequencing signals: ordering beacons that limit extractive behavior across venues.
Events: custody confirmations, bank rail status, and other off-chain proofs that matter on-chain.

Architecture Highlights

Reporter set and sourcing: diverse reporters pull from exchanges, custodians, banks, RWA issuers, and public feeds. Every report carries freshness, variance, and drift metrics.
Aggregation: commit-then-reveal rounds with threshold attestations and robust stats, no “last look” manipulation.
Attestation and proofs: every update is signed by a quorum; signatures and metadata go on-chain and relay cross-chain via Zero Layer.
Liveness and fallbacks: heartbeats, timeouts, prioritized failover. Consumers set staleness bounds and grace windows.
Security and incentives: staking, slashing, and dispute windows keep reporters honest.
Delivery modes: push on-chain, pull via SDK or webhooks, or fan out cross-chain.
Developer UX: typed SDKs, registries, testnet mirrors, and local verifiers. Payloads come with value, confidence interval, round ID, timestamp, quorum bitmap, and signature set.

Object model and checkpoints

Feed (shared): a named stream like “ETH/USD median.”
Round (immutable): a single update with value, confidence, timestamp, reporters, and signatures.
Reporter (owned): identity-attested, staked, and tracked.
ORA PCkpt[k]: a batch of new rounds signed and committed, then rolled into GCkpt on the Master Chain.

Service tiers and SLAs

Latency tiers: per block, sub-second where possible, or scheduled intervals (1, 5, 15 minutes).
Assurance tiers: configurable quorum size and diversity rules.
Availability: four-nines target for core price feeds with regional failover.

Programmable Settlement

Programmable Settlement (PS) is the app-building layer of the protocol. Think of it as a drag-and-drop builder with a compiler under the hood. Teams sketch flows like diagrams, and PS turns them into chain-specific contracts and orchestrated actions. It plugs into Zero Layer (for atomic cross-chain transport) and the Oracle Network (for fresh, auditable data). Every run leaves a signed checkpoint in a global audit log, so you always have receipts.

Builder experience

Drag-and-drop flows: snap together nodes like Transfer, Swap, Mint/Burn, Upgrade, Policy Check, and Route. No code needed.
Code when you want it: crack open any node in code view to extend or replace the template.
Compile & deploy: one click emits chain-specific artifacts for EVM, Sui, Solana, or Cosmos.
Simulation: dry-run flows, step through state changes, preview fees/finality before you hit deploy.
Type-safe parameters: guardrails and safe defaults keep the foot-guns holstered.
Objects & checkpoints: each flow generates step-by-step artifacts and rolls into a global checkpoint for audit and analytics.

Orchestration & safety (baked in)

Timelocks & staged rollouts for upgrades and sensitive actions.
Circuit breakers for proposals, voting, and distributions.
Parameter guards for caps, rate limits, and bounded deltas per epoch.
Rollback/abort nodes for controlled reversions when things go sideways.

Interoperability & delivery

Route nodes (connectors): aim flows at EVM, Sui, Solana, Cosmos, or even off-chain endpoints.
Zero Layer: handles cross-chain messaging and settlement outcomes with atomic clearing.
Future-proofing: a native VM can sit behind the same graphs; apps pick EVM-compatible or specialized execution as needed.

Governance & Engagement Services (GES)

Proposals & voting: Propose → Queue → Execute with timelocks, policy checks, and flexible voting (token-weighted, rep-weighted, one-person-one-vote, quadratic).
Rewards coin: programmable epoch emissions with weights/caps, vesting/clawback — incentives for oracle uptime, settlement reliability, liquidity, or app milestones.
Reputation: non-transferable scores scoped to an app; they decay, slash, or boost rewards, and can gate roles.
Compliance guards: KYC, allowlists, attestations enforced as policy oracles gating proposals, votes, and distributions.

Developer services

SDKs & APIs: TypeScript and Rust SDKs, plus GraphQL/gRPC for when you need server muscle.
CLI & CI recipes: scaffold projects, validate graphs, and ship straight from your pipeline.
Templates & examples: pre-baked flows for grants, quests, quadratic rounds, liquidity mining, fee rebates — copy, tweak, done.
Docs & snippets: cut-and-paste recipes for common patterns so you don’t reinvent the wheel.
Webhooks & events: subscribe to checkpoints and outcomes for real-time monitoring and analytics.

Reliability & performance

Oracle SLAs: freshness and availability guarantees backed by threshold attestations.
Delivery/settlement SLOs: optional end-to-end objectives across Zero Layer and target chains.
High availability: redundant routes, health checks, and automatic failover where it matters.
Rate limits & backpressure: built-in guardrails to keep bursty loads or downstream hiccups from blowing up your app.

Platform Features

Network roles and trust model

Master Chain validators re-validate Primitive Checkpoints (PCkpts) into a Global Checkpoint (GCkpt) stream and finalize ordering across primitives. Primitive committees sign PCkpts. Safety comes from threshold signatures and independent re-validation. Committees rotate, are stake-weighted, and collectively provide the audited finality that even lawyers can point to.

Data availability and storage

Checkpoint headers, committee bitmaps, signatures, and object digests live on-chain. Full bodies live in a near-chain data layer with sampling proofs. An analytics lake consumes GCkpt exports for queries and dashboards. Light clients verify inclusion proofs without downloading everything.

Performance targets

PCkpt cadence is tunable per primitive. GCkpt batches every few seconds. Cross-primitive bundles typically finish within two PCkpt windows plus one GCkpt window. The system scales by sharding object namespaces and committees.

Security and threat model

Oracles: protected by reporter diversity, robust stats, commit-reveal, and slashing.
Transport & clearing: secured by atomic delivery, replay protection, and route caps.
Cross-primitive flows: consistency enforced at the Master Chain.
Keys & auth: governed by smart account policies.
Liveness: maintained with heartbeats and leader rotation.

Developer experience

The Rete.js IDE provides typed nodes, local simulation, scenario testing, CI gates, and a plugin SDK. Build flows once, and the compiler targets the right primitives and object paths. What you draw is what you deploy.

Observability and audit

Every transaction carries a PCkpt ID and GCkpt ID. Metrics track latency and freshness. Traces link flow IDs and object IDs. Auditors receive bundles with headers and proofs. Dashboards and alerts monitor SLAs and variance bounds.

Compliance and policy controls

Policy oracles publish KYC/AML, geo, and sanction flags. Flows consume them as first-class nodes. Evidence packs are machine-readable and signed. Both permissionless and permissioned modes use the same checkpoint format.

Economic model

Fees = base per primitive + compute/byte multipliers. Bundles that co-locate object access get discounts. Rewards follow measurable, provable work. Vote escrow can boost rewards and grant parameter control.

Upgrade and versioning

Changes flow proposal → testnet → guarded mainnet rollout. Parameters have fast, medium, or slow tiers. Emergency controls are narrow, time-limited, and reviewed on-chain.

Reliability and incident response

The system degrades gracefully:

If oracles go stale, freeze dependent actions and allow safe cash-out.
If Zero Layer congests, prioritize settlement-critical routes.
If a committee fails, rotate to a standby set.

Interoperability

Zero Layer provides message passing without pooled liquidity. Assets use canonical shared objects. Connectors exist for EVM, Sui, Solana, and Cosmos. Off-chain endpoints integrate via signed webhooks and a light client SDK.

Custody, keys, and accounts

Smart accounts support session keys, rate limits, spending policies, and social recovery. Enterprises get role separation and dual control. No more seed phrases scribbled on Post-its.

Integrated experience

One surface for transfers, trades, payouts, and program creation. PCkpt and GCkpt status is visible for every action. Templates include escrow, DvP, RFQ, streaming payroll, and proof of reserves. Tutorials teach by doing.

Roadmap

Alpha: Oracle Network and Zero Layer MVP, Rete.js IDE preview, GCkpt light client.
Beta: Master Chain v0, PCkpt to GCkpt bridge, programmable settlement for selected templates, first compliance oracles.
Mainnet: rotating committees, slashing, permissioned overlays, retroactive builder rewards.
v1.x: more connectors, stronger data availability, privacy options with TEEs or MPC.

Privacy options

Selective disclosure gives proofs without PII. Confidential compute is available for sensitive actions with proofs anchored in PCkpt headers. MPC controls high value vaults with metadata references.

Reference schemas (sketch)

PCkptHeader

{ primitive_id, epoch, seq, object_roots[], event_root, committee_bitmap, threshold_sig, time_bounds, prev_hash }

GCkptHeader

{ height, pc_refs[], global_order_root, validator_bitmap, threshold_sig, prev_hash }

AttestationBundle

{ gc_header, pc_headers[], merkle_proofs[], param_versions }