28 Sep 2026
Identity
A typeface for the paper
Zettl Serif is a display face drawn for the project, with Computer Modern proportions and squircle bowls. The wordmark, headlines and numerals use it. Text is set in Latin Modern.
Working draft v0.5 · September 2026
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.
§ 1 — Problem
A total order is one queue every payment has to join.
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].
§ 2 — Design
Two payments conflict only if they spend the same thing.
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.
| Path | Handles | Final when | Consensus |
|---|---|---|---|
| Fast path | Claims on disjoint or commutative state | A certificate exists | None |
| Ordered lane | Conflicting claims, private payments in v0.5 | Its block is anchored | Required |
§ 3 — Lanes
The more work a lane asks of validators, the higher its fee.
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.
Lowest fee
Simple public payments. Final on a certificate, with no consensus round.
Standard fee
Ordinary EVM execution. Commutative transactions settle by certificate, conflicting ones are ordered.
Highest fee
Payments shielded by a zero-knowledge proof. Ordered only in v0.5, because proofs cost more to verify.
§ 4 — Verification
A proof on paper is the first rung of the ladder, not the last.
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.
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.
| Rung | Artifact | Status in v0.5 |
|---|---|---|
| 1 Paper proofs | Theorems on certificate safety and anchoring, in the academic paper. | Done |
| 2 Model | An executable model of the state-machine appendix, in TLA+ or an equivalent. | SpecifiedNot yet model checked. |
| 3 Mechanized proofs | Proofs in Lean 4 or Coq of certificate safety, replacement safety, anchoring liveness, and no double spend across epochs. | PlannedNone checked. |
| 4 Verified code | A Rust reference implementation checked with a Rust verifier, and a template compiler proven to preserve the checker’s meaning. | Planned |
| 5 Trace refinement | Implementation traces validated against the model in continuous integration. | Planned |
§ 5 — Properties
What the draft commits to, stated so it can be checked.
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.
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.
The Private lane uses transparent, hash-based proofs. Validator certificates keep BLS signatures in v0.5, with a post-quantum mode planned.
Solidity contracts and EIP-712 wallets work through an owner-suite adapter. x402 payments run on all three lanes.
J. RautWorking draft v0.5September 2026Unreviewed
We describe Zettl, a settlement layer for cross-border payments made by people, contracts and software agents. It is compatible with the EVM, so existing wallets and smart contracts work. Transactions whose effects commute, and which touch only state owned by their sender, are made final by validator certificates without consensus. Transactions that conflict are ordered by a consensus protocol and anchored in the same ledger. Payments that should be private are shielded with a zero-knowledge proof. Compliance and regulation are foundational to the design: a compliance step runs before validators sign, so jurisdiction-specific rules apply without changing the protocol. Three lanes, with fixed and separate prices, expose the network to users: Fast, Public and Private. This document is a working draft. It reports a design, not measurements.
A cross-border payment has to satisfy several parties at once: the sender, the receiver, and the rules of every place it touches. Zettl is designed to bring compliance, private payments and agentic payments together in one settlement system, instead of leaving each to a separate layer. Compliance modules run before validators sign, private payments are shielded with zero-knowledge proofs, and software agents can pay over x402.
Such a system also has to be fast. Total order is a strong tool used for a weak purpose in most payment traffic. Two transfers between disjoint pairs of accounts have the same outcome in either order, so ordering them adds latency and no safety. Prior work on broadcast-based settlement shows that such transfers can be finalized without consensus[1], and that a simple balance transfer needs less synchronization than a general state machine[2].
Zettl carries this idea to the EVM. The difficulty is that general contracts can read and write shared state. We handle that by making conflicts explicit and by sending only conflicting transactions to an ordered lane. Privacy comes from zero-knowledge proofs on a separate lane, and local rules come from compliance modules that run before validators sign. Compliance and regulation are foundational to this design, not added afterward.
State is a set of objects. Each transaction carries an access list naming the objects it touches and a mode for each: read, write, add or subtract. Two accesses to one object commute if both are adds or both are reads. Otherwise they conflict.
An object has an owner, which is a signing suite. The base suite is post-quantum-ready, and an adapter accepts secp256k1 signatures over EIP-712 messages so that existing wallets can sign claims.
The sender broadcasts a claim to validators. Each validator checks the signature, the owner’s balance and the compliance modules configured for the asset, and returns a signature if the claim is valid. The sender collects signatures into a certificate and broadcasts it. Validators apply the claim when they see the certificate.
Version 0.5 studies the unanimous variant, in which every validator must sign, in place of a two-thirds quorum. Unanimity simplifies the argument for finality without expiry and raises a liveness question that the draft treats as an open item.
Conflicting transactions are sent to a sequencing protocol from the Simplex family[3]. The ordered lane produces blocks that reference certificates from the fast path, so both paths write to one ledger and a light client can verify either. In version 0.5 the Private lane runs only here.
The Fast lane carries simple public payments. The Public lane carries ordinary EVM execution, with commutative transactions on the fast path and conflicting ones on the ordered lane. The Private lane carries shielded payments. Each lane has a fixed fee in a US dollar stablecoin. The Private fee is the highest because verifying a proof costs validators more than verifying a signature.
Parties to a cross-border payment often do not want amounts or counterparties visible to everyone who can read a public ledger. The Private lane hides amounts and parties with a zero-knowledge proof. Proofs are transparent and hash-based, so they need no trusted setup and are believed to resist quantum attackers. Only assets without a controller can be shielded in v0.5. Private payments over x402 are deferred to v0.6.
Compliance and regulation are foundational considerations in the design of Zettl. The protocol reserves a point before signing where a compliance module can approve or refuse a claim, so a jurisdiction's rules are applied where a claim enters the network and not after it settles. Modules sit outside the core, so different jurisdictions can apply different rules to the same ledger. This draft specifies where modules sit and what they may decide. It does not specify the rules of any jurisdiction.
Safety rests on two claims. First, two conflicting claims cannot both gather certificates. Second, a certificate is never revoked. The draft states both as properties of a state machine and gives the machine in an appendix so that they can be checked mechanically. Validator certificates use BLS signatures in v0.5. A post-quantum mode is planned and is not a blocker for the first release.
The path to stronger assurance has five stages: proofs on paper, an executable model, mechanized proofs, a verified implementation, and validation of the implementation’s traces against the model. Only the first is complete in this draft. The model is specified but has not been model checked, and the other three are planned, with nothing checked by a machine yet. The properties in scope are certificate safety, replacement safety, liveness of anchoring, and no double spend across epochs. 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 remain in the trusted base.
The reference list is abbreviated in this draft.
28 Sep 2026
Identity
Zettl Serif is a display face drawn for the project, with Computer Modern proportions and squircle bowls. The wordmark, headlines and numerals use it. Text is set in Latin Modern.
27 Sep 2026
Decision
The fast path is rebased on unanimous certificates in place of a two-thirds quorum. Liveness under a missing validator is carried as an open item.
23 Sep 2026
Spec
Adds post-quantum privacy proofs, state machines written for formal verification, and x402 payments on all three lanes.
Author
Founder. Writes the specification and the paper, and designs the protocol.
Colophon
Set in Zettl Serif, a display face drawn for the project, and Latin Modern for text and code. Every figure is drawn live in the browser with three.js. The glyph field uses characters from the typeface itself.