# How it works

Three pieces, and which one does what, because somebody deciding whether to build on this needs the mechanism rather than the pitch.

## How it works

Your app encrypts locally with batched threshold encryption (BTE) and sends a ciphertext. The coordinator stores it and holds no key that opens it. When the moment arrives, three of the five operators each publish a decryption share, the whole batch opens at once, and everyone reads the same result.

Encryption happens in your process. Nothing between it and the deadline can read the payload, and opening it takes three operators acting together.

open

Anyone can seal. Nothing is readable, including the count of what is inside.

closing

The deadline passed. The batch is frozen and padded; operators are producing shares.

opened

Every payload is public in the same instant, with a merkle root over the set.

A round can also say what it is, so somebody deciding whether to take part can see it before anything opens. That part is public from the moment the round exists, which is exactly the opposite of the payloads sealed to it:

image\_url

Signed tour poster open

One of a kind, ships worldwide.

`opens_at` 2027-01-15T18:00:00Z · `seals` null until it opens · `tag` my-app

Three details worth knowing. **How many sealed is not published while a round is open.** `seals` and `slots_including_decoys` come back `null` until it opens, and the list of seal ids with them, because a live count is the number a competitor in a sealed auction most wants and the deadline is exactly when it is worth something. You read your own back with `GET /v1/seals/{id}`, using the id your own submission returned.

Then every batch is padded to 64 with decoys the coordinator seals to itself, so once a round has opened, a round with three submissions still does not announce that it had three; decoys come back flagged `is_dummy`. And slot positions are derived from the ciphertext hashes rather than arrival order, so a batch cannot be reordered after the fact.

## What a seal's proof proves

`GET /v1/seals/{id}/proof` returns the checkable facts and nothing else. The load-bearing one is `ordering_committed_at`: the coordinator writes the batch's ordering root at freeze, before any operator is handed work, so a commitment timestamp earlier than the reveal is evidence that the set and its order were fixed before anybody could open it. Before the round opens, the reveal fields are `null` rather than `false`, because "not yet" and "no" are different answers.

```
{
  "seal_id":       "4f858dc3…",   // sha256 of the ciphertext: recompute it yourself
  "position":      3,             // from the hashes, not arrival order
  "ordering_root": "0x…",
  "ordering_committed_at": 1788490917,
  "merkle_root":   "0x…",
  "revealed_at":   1788494517,
  "commitment_precedes_reveal": true
}
```

**There is no field that takes a plaintext.** Encrypting on our side would move the encryption to the wrong end of the network and delete the only property this has. A payload is a ciphertext or it is not accepted.

## Why Peal, not drand tlock

If you know timelock encryption you know [drand tlock](https://docs.drand.love/docs/timelock-encryption/), and you should ask this before reading further. tlock is free, the drand beacon it rides on has run since 2020, and its own docs list the same applications this site does: sealed-bid auctions, MEV prevention, voting, responsible vulnerability disclosure. It is also the same primitive family as Peal, threshold BLS over BLS12-381, run by the League of Entropy: Cloudflare, EPFL, Protocol Labs, Kudelski Security and around twenty other named organisations. If a public unlock at a wall-clock time is all you need, use tlock.

drand tlock

peal

what opens it

the beacon's BLS signature for a round number: a point in wall-clock time, every 3 s (quicknet) or 30 s (default)

a condition you define: a deadline, or a block height on a chain you name

the unit

one ciphertext; each opens on its own, for everyone, once the round signature is public

a round of up to 64 payloads; one 48-byte share per operator opens the whole batch at once

what an observer learns before the cue

how many ciphertexts were encrypted to that round, if they can see them

nothing about the count: the batch is padded with decoys, and the count stays padded after it opens

committee traffic per reveal

one signature per round, shared by every ciphertext aimed at it

one 48-byte share per operator per batch, constant while the batch fills

a chain

none needed

none needed; three HTTP calls, and a chain only if you anchor a root to one

who holds the keys today

the League of Entropy, around two dozen named organisations

key shares distributed among five operators, Meridian Assay, Halcyon Registry, Northwind Trust, Ardent Notary and Vantage Archive, run by Peal during testnet; distributed key generation in v1

post-quantum

no, and drand says so

no; the same pairings

Two honest notes. Batching buys coordination and bandwidth, not pairings: the paper behind Peal is explicit that decryption costs a few pairings per ciphertext in every scheme, its own included, so do not read the table as a compute win. And drand's beacon key already comes from a distributed key generation, which Peal adds in v1.

Sources: [drand, timelock encryption](https://docs.drand.love/docs/timelock-encryption/) · [drand/tlock](https://github.com/drand/tlock) · [drand, about](https://drand.love/about/) · [Policharla, A Simple Batched Threshold Encryption Scheme, ePrint 2026/760](https://eprint.iacr.org/2026/760).

---
Source: https://peal.network/developers/howitworks
