The programmable confidentiality layer for digital markets.

What Peal is

Peal is a programmable confidentiality layer for time-bound digital markets. Bids, offers, votes, commitments and agent intents arrive encrypted and remain unreadable until a predefined condition is met. When that moment arrives, the entire set is revealed together. The primitive underneath every one of those is batched threshold encryption (BTE): a payload is encrypted on the client to a committee, and only a threshold of its operators, acting after the condition fires, can open the batch.

Most products with a submission deadline have a hidden trust problem: the operator can see what participants submit before everyone else. They can promise not to look, but participants have no way to verify that promise.

This information asymmetry enables front running, selective disclosure and unfair price discovery. Traditional commit and reveal systems only move the problem: participants must return to reveal, allowing losing bidders to disappear strategically. Peal makes disclosure automatic and coordinated, without giving any single participant or operator early access.

What is actually hard about it

The encryption was never the hard part. It is that somebody has to hold the key until the deadline, and whoever holds it can peek, leak, or quietly decline to open it when the answer does not suit them.

Peal removes that person. No single party can open a batch early, and nobody has to come back to reveal, because the network does it on its own when the moment arrives.

What you add

Three HTTP calls. No signup, no API key, no wallet and no gas for the people submitting. The client is one file served from this domain, so there is nothing to install and no package to trust.

import { peal } from 'https://peal.network/peal.js';

const { id } = await peal.createRound({ opensIn: 3600, tag: 'my-app' });
await peal.seal(userSubmission, id);      // sealed from here on

await peal.waitForOpen(id);               // returns when the deadline passes
const payloads = await peal.getPayloads(id);   // all of them, at once

Two things this snippet is careful about. The options are camelCase (opensIn), while the HTTP body is snake_case (opens_in); passing the wrong one now throws rather than being ignored. And getPayloads reads whatever is readable right now, which before the deadline is nothing, so waitForOpen is what turns it into "at the close".

Where to go next

• Quickstart runs the three calls against the live network from the page, so you can see it work before writing anything.
• How it works is the mechanism: what the cue is, where the encryption happens, and what you can check afterwards.
• Sealed bid auctions is the thing most people build first, and it is a few calls rather than a project.
• API reference has every endpoint, the error codes and the rate limits.