Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
25 changes: 2 additions & 23 deletions README.md
Original file line number Diff line number Diff line change
Expand Up @@ -3,7 +3,7 @@
Technical report on the Aggregation Layer of the Unicity Network: the
component that records spent token-state identifiers in a sharded Sparse
Merkle Tree (SMT) and produces Unicity Proofs: inclusion and non-inclusion proofs.
The paper details the security model, identifies the properties needed for
The paper details the security model, identifies the properties needed for
trustless operation
(*prior-state preservation*), and reports the design and measured
performance of a Plonky3 AIR implementation that proves it in Zero Knowledge.
Expand All @@ -19,28 +19,7 @@ This paper is also referred to as the **Unicity Bluepaper**.

## Abstract

Unicity is a novel blockchain protocol with the ambitious goal of
enabling token transactions to occur off-chain and, when necessary,
offline. This premise requires supporting infrastructure to guarantee
that there are no parallel states of assets, or more specifically, that
there is no double-spending; a property we term the *unicity*. It turns
out that the lack of globally shared state and ordering reduces the
blockchain overhead considerably. In designing this infrastructure, no
compromises were made regarding its trust assumptions. This paper
details the design of the Aggregation Layer, the component responsible
for producing Proofs of Inclusion and Non-inclusion to the users. We
analyze its design for efficiency and evaluate the robustness of its
trust and security model. We then identify a single critical property
that the Consensus Layer must verify on each round—*prior-state
preservation*—and observe that the remaining desirable properties
of the trustless key-value store (canonical tree shape, batch
incorporation, no phantom inserts, completeness) are not required by
the Unicity Aggregator's security model. This optimal statement is
implemented as an Algebraic Intermediate Representation (AIR) circuit
on top of the Plonky3 STARK toolkit. The implementation sustains a
proving throughput in excess of 10 000 insertions per second on
a single consumer-class CPU, with a succinct proof and tens of
milliseconds verification time, and no trusted setup.
Unicity is a novel blockchain protocol with the ambitious goal of enabling peer-to-peer token transactions to occur off-chain, without shared ordering and execution overhead. This premise requires supporting infrastructure to guarantee that there are no parallel states of assets, or more specifically, that there is no double-spending; a property we term the *unicity*. It turns out that the lack of globally shared state and ordering reduces the blockchain overhead considerably. In designing this infrastructure, no compromises were made regarding its trust assumptions. This paper details the design of the Aggregation Layer, the component responsible for producing Proofs of Inclusion and Non-inclusion to the users. We analyze its design for efficiency and evaluate the robustness of its trust and security model, and design optimal data structures and algorithms for this setup. We then identify the critical property that the Consensus Layer must verify on each round---*append-only consistency*, combining prior-state preservation with coherent placement of insertions---give it a formal definition, and prove that the RSMT consistency proof enforces it over the entire certified history, assuming only collision resistance of the hash function. The structural core of this statement is implemented as Algebraic Intermediate Representation (AIR) circuit on top of the Plonky3 STARK toolkit. The implementation sustains a proving throughput in excess of 10 000 insertions per second on a single consumer-class CPU, with a succinct proof and tens of milliseconds verification time, and no trusted setup. Finally, we describe how the per-round proofs of all shards, together with the Consensus Layer's state transitions, are folded into a single recursively aggregated STARK: a fixed-size certificate of the correctness of the system's entire operating history, verifiable against the genesis configuration alone, without trusting the validator set.

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

medium

The phrase implemented as Algebraic Intermediate Representation (AIR) circuit is missing the indefinite article an before Algebraic. Since circuit is a singular countable noun, it should be preceded by an.

Suggested change
Unicity is a novel blockchain protocol with the ambitious goal of enabling peer-to-peer token transactions to occur off-chain, without shared ordering and execution overhead. This premise requires supporting infrastructure to guarantee that there are no parallel states of assets, or more specifically, that there is no double-spending; a property we term the *unicity*. It turns out that the lack of globally shared state and ordering reduces the blockchain overhead considerably. In designing this infrastructure, no compromises were made regarding its trust assumptions. This paper details the design of the Aggregation Layer, the component responsible for producing Proofs of Inclusion and Non-inclusion to the users. We analyze its design for efficiency and evaluate the robustness of its trust and security model, and design optimal data structures and algorithms for this setup. We then identify the critical property that the Consensus Layer must verify on each round---*append-only consistency*, combining prior-state preservation with coherent placement of insertions---give it a formal definition, and prove that the RSMT consistency proof enforces it over the entire certified history, assuming only collision resistance of the hash function. The structural core of this statement is implemented as Algebraic Intermediate Representation (AIR) circuit on top of the Plonky3 STARK toolkit. The implementation sustains a proving throughput in excess of 10 000 insertions per second on a single consumer-class CPU, with a succinct proof and tens of milliseconds verification time, and no trusted setup. Finally, we describe how the per-round proofs of all shards, together with the Consensus Layer's state transitions, are folded into a single recursively aggregated STARK: a fixed-size certificate of the correctness of the system's entire operating history, verifiable against the genesis configuration alone, without trusting the validator set.
Unicity is a novel blockchain protocol with the ambitious goal of enabling peer-to-peer token transactions to occur off-chain, without shared ordering and execution overhead. This premise requires supporting infrastructure to guarantee that there are no parallel states of assets, or more specifically, that there is no double-spending; a property we term the *unicity*. It turns out that the lack of globally shared state and ordering reduces the blockchain overhead considerably. In designing this infrastructure, no compromises were made regarding its trust assumptions. This paper details the design of the Aggregation Layer, the component responsible for producing Proofs of Inclusion and Non-inclusion to the users. We analyze its design for efficiency and evaluate the robustness of its trust and security model, and design optimal data structures and algorithms for this setup. We then identify the critical property that the Consensus Layer must verify on each round---*append-only consistency*, combining prior-state preservation with coherent placement of insertions---give it a formal definition, and prove that the RSMT consistency proof enforces it over the entire certified history, assuming only collision resistance of the hash function. The structural core of this statement is implemented as an Algebraic Intermediate Representation (AIR) circuit on top of the Plonky3 STARK toolkit. The implementation sustains a proving throughput in excess of 10 000 insertions per second on a single consumer-class CPU, with a succinct proof and tens of milliseconds verification time, and no trusted setup. Finally, we describe how the per-round proofs of all shards, together with the Consensus Layer's state transitions, are folded into a single recursively aggregated STARK: a fixed-size certificate of the correctness of the system's entire operating history, verifiable against the genesis configuration alone, without trusting the validator set.


## Unicity Paper Map

Expand Down
19 changes: 13 additions & 6 deletions aggregation-layer.bib
Original file line number Diff line number Diff line change
Expand Up @@ -171,12 +171,19 @@ @misc{tornado
}

@misc{exemodel,
author = {{The Unicity Developers}},
title = {{Unicity} Execution Model},
year = {2025},
publisher = {{GitHub}},
journal = {{GitHub} repository},
howpublished = {\url{https://github.com/unicitynetwork/execution-model-tex}}
author = {Ahto Buldas and Dirk Draheim and Mike Gault and Risto Laanoja and Vladimir Rogojin and Ahto Truu},
title = {The {Unicity} Execution Layer},
year = {2026},
howpublished = {{arXiv} preprint {arXiv}:2606.02181},
url = {https://arxiv.org/abs/2606.02181}
}

@misc{predicates,
author = {Ahto Buldas and Dirk Draheim and Mike Gault and Risto Laanoja and Vladimir Rogojin and Ahto Truu},
title = {{Unicity}: Predicates and Atomic Swaps},
year = {2026},
howpublished = {{arXiv} preprint {arXiv}:2606.02192},
url = {https://arxiv.org/abs/2606.02192}
}

@misc{polygonzkevm,
Expand Down
Loading
Loading