Zettl

Working draft v0.5 · September 2026

Zettl

Smart contract enabled, universal cross-border settlement for agentic and private payments.

Cross-border payments cross many systems and rulebooks. Zettl gives them one place to settle: in parallel, private when needed with zero-knowledge proofs, and checked against local rules before validators sign.

Abstract

Moving money across borders means crossing many systems and many rulebooks, and each crossing is a place to wait. Zettl is a settlement layer built to be one shared place to settle. It treats a payment as a claim against state that its sender owns. Claims that touch disjoint state are settled by validator certificates, without a consensus round, and claims that conflict are escalated to an ordered lane. Smart contracts run on the EVM, so existing wallets and applications work, and a payment can come from a person, a contract or a software agent over x402. Payments that should be private are shielded with a zero-knowledge proof, so a shared ledger can settle them without publishing who paid whom or how much. Compliance and regulation are foundational to the design, not added afterward: compliance modules run before a validator signs, so the rules of each jurisdiction plug in without changing the core. Zettl offers three lanes at three prices: Fast, Public and Private.

Author  J. Raut Status  Draft, unreviewed Keywords  cross-border settlement, EVM, zero-knowledge, agentic payments
Plate IZettl Serif, 0 images
Plate I. A field of claims, typeset. Every mark is a glyph from the typeface, chosen by how much ink it carries. Move the pointer to send a wave through it.

§ 1 — Problem

A total order is one queue every payment has to join.

Order everything, and everything waits.

A payment from A to B and a payment from C to D share nothing. Putting both in one total order makes the second wait for the first for no reason except that the chain has a single line.

Consensus is needed where two claims race for the same object, such as two spends of one balance. Everywhere else it is overhead. This observation is the basis of broadcast-based settlement[1,2].

Claims arrive Settled One global order
Settled 0Median wait 0.00 sWaiting 0
Fig. 1. Bursts of claims arrive at eight accounts. With one global order, a single gate passes one claim at a time. With order only for conflicts, independent claims settle as they arrive and the rare conflicting pair queues in its own lane. Simulation with invented rates; illustrative, not measured.

§ 2 — Design

Two payments conflict only if they spend the same thing.

Two paths, one ledger.

A transaction declares the state it reads and writes in an access list with add and subtract modes. Commutative writes, such as adding to a balance, do not conflict with each other.

If a transaction needs only commutative access to state it owns, validators sign it independently. Enough signatures form a certificate, and the transaction is final once the certificate exists. If two transactions conflict, both go to the ordered lane, which runs a partially synchronous consensus protocol[3] and anchors its blocks in the same ledger.

Definition 1 (Certificate). A set of validator signatures over a claim whose combined weight meets the fast path’s threshold. Version 0.5 studies the unanimous variant.
PathHandlesFinal whenConsensus
Fast pathClaims on disjoint or commutative stateA certificate existsNone
Ordered laneConflicting claims, private payments in v0.5Its block is anchoredRequired

§ 3 — Lanes

The more work a lane asks of validators, the higher its fee.

Three lanes, three prices.

Fees are fixed per lane and denominated in US dollar stablecoins, so a sender knows the price before signing. The more work a lane asks of validators, the higher its fee.

FastPublicPrivate

Lowest fee

Fast

Simple public payments. Final on a certificate, with no consensus round.

Standard fee

Public

Ordinary EVM execution. Commutative transactions settle by certificate, conflicting ones are ordered.

Highest fee

Private

Payments shielded by a zero-knowledge proof. Ordered only in v0.5, because proofs cost more to verify.

Fig. 2. Each lane drawn as a curve whose complexity follows its cost: a Lissajous figure, a three-petal rose, a hypotrochoid. Decorative; the curves carry no data.

§ 4 — Verification

A proof on paper is the first rung of the ladder, not the last.

Say what is checked, and how.

Safety in Zettl rests on two properties. Two conflicting claims cannot both gather certificates, and a certificate is never revoked. Formal verification means a machine checks a proof, or exhaustively searches a precise model, against properties like these. It is stronger than testing and stronger than a proof written on paper.

Some properties are meant to hold by construction instead. A write to shared state is typed so that a non-commutative effect cannot be expressed on the Fast lane, and the anchoring rules are designed so that a transaction cannot be anchored twice.

A · 0 B · 0 Nine validators, threshold six
Fig. 3. The property, drawn. Each validator signs at most one of two conflicting claims. With nine validators and a threshold of six, both claims cannot reach the threshold, because that would take twelve signatures. When neither does, the conflict goes to the ordered lane. Illustrative numbers, and not the output of a model checker.

Zettl’s plan is to climb a five-rung ladder, from proofs on paper to an implementation checked against the same model. The first rung is written. The rest are planned, and none has been run or checked. The table gives the status of each, so that a reader can tell what is proven, what is modelled and what is a promise.

Paper proofsModelMechanizedVerified codeTraces
DoneSpecifiedPlannedPlannedPlanned
Plate II. The verification ladder, typeset. Each numeral is built from glyphs of the typeface. Solid is done, half-tone is specified, faint is planned. A checker rises through all five rungs and only the first holds. Illustrative; the table below is the record.
RungArtifactStatus in v0.5
1 Paper proofsTheorems on certificate safety and anchoring, in the academic paper.Done
2 ModelAn executable model of the state-machine appendix, in TLA+ or an equivalent.SpecifiedNot yet model checked.
3 Mechanized proofsProofs in Lean 4 or Coq of certificate safety, replacement safety, anchoring liveness, and no double spend across epochs.PlannedNone checked.
4 Verified codeA Rust reference implementation checked with a Rust verifier, and a template compiler proven to preserve the checker’s meaning.Planned
5 Trace refinementImplementation traces validated against the model in continuous integration.Planned
Scope. The properties in scope are certificate safety, replacement safety, liveness of anchoring, and no double spend across epochs. The trusted base sits outside them and is listed in the draft: the template compiler, the shared-state write interceptor, the signature and proof verifiers, the soundness of the STARK prover, the hash function, the ordered-lane protocol and the epoch key commitment.

§ 5 — Properties

What the draft commits to, stated so it can be checked.

What the design commits to.

  • Compliance by design

    Compliance and regulation shape the design from the start. Modules run before a validator signs, so the rules of each jurisdiction plug in without changing the core. One ledger, local rules.

  • Correctness by construction

    Safety is stated as properties of a state machine, and the v0.5 draft gives the machine in an appendix. Formal verification is planned in stages, and only the first is done.

  • Post-quantum privacy

    The Private lane uses transparent, hash-based proofs. Validator certificates keep BLS signatures in v0.5, with a post-quantum mode planned.

  • EVM and x402

    Solidity contracts and EIP-712 wallets work through an owner-suite adapter. x402 payments run on all three lanes.