Anchored to Bitcoin

The seal proves your prediction hasn't changed — if you trust aiternam's records. Anchoring removes that last "if." It commits your prediction's fingerprint to Bitcoin, so the proof that it existed, unaltered, no longer rests on our honesty at all.

Why this exists. "Trust us, we didn't backdate anything" is not a proof. The day aiternam — or anyone who compromised it — could insert a prediction with an earlier timestamp, the whole product would be a reputation system built on our own word. Anchoring takes us out of the trust equation. We don't ask you to believe our timestamp; we rent the most tamper-proof clock on Earth and hand you the receipt.

This is trusted timestamping, not "web3." There are no tokens, no smart contracts, no wallet. The only thing we need from Bitcoin is the one thing it does best: prove that a value existed no later than a certain block, in a way nobody can forge or backdate.

One fingerprint for a whole batch: the Merkle tree

Writing to Bitcoin costs a fee and takes time, so anchoring every prediction individually would be absurd. Instead we fold all the fingerprints from a time window into a single value using a Merkle tree, and commit only that one value — the root.

The idea is simple: hash the fingerprints together, two at a time, climbing until one value sits at the top.

                    ROOT   ← the only value committed to Bitcoin
                  /      \
               •            •
              / \          / \
            h0   h1      h2   h3     ← content_hash of each prediction

One Bitcoin commitment now covers the entire batch — millions of predictions if need be. And each prediction keeps a tiny inclusion proof: just the handful of neighboring hashes on the path from its leaf up to the root. With those, anyone can recompute the root and confirm "my prediction is in this batch" — without being shown anyone else's.

We build the tree with a published standard (RFC 6962, the one used by Certificate Transparency), frozen so any independent tool rebuilds the identical root. Its two operations are just:

leaf  = SHA256( 0x00 || your fingerprint )
node  = SHA256( 0x01 || left || right )

The 0x00 / 0x01 prefixes keep leaves and internal nodes in separate hash spaces, so no one can pass one off as the other. (The exact, reproducible rules live in Verify it yourself.)

Into Bitcoin, without a wallet: OpenTimestamps

To put the root into Bitcoin, aiternam holds no wallet, no private key, and pays no gas. We use OpenTimestamps, a public timestamping service purpose-built for proof-of-existence:

1. We send the root (a 32-byte value) to public calendar servers — an ordinary web request, no account.
2. Those calendars aggregate our root with thousands of others into their own tree, and they commit their root into Bitcoin — they pay the fee.
3. We get back a small .ots proof file that traces the path: our root → the calendar's tree → a Bitcoin transaction → a block.

The proof is a standard .ots file that any OpenTimestamps client can verify against Bitcoin — never against aiternam. That's the point: the guarantee doesn't depend on us being online.

Two steps: pending, then Bitcoin

There's an unavoidable delay, so anchoring happens in two phases — and the status you see on a prediction reflects which phase it's in:

unanchored  →  pending  →  bitcoin

• unanchored — sealed in our records, but the next batch hasn't run yet.
• pending — the root has been sent to the calendars, but Bitcoin hasn't mined it into a block yet. The block literally doesn't exist at this instant, so there's nothing to point to.
• bitcoin — a block has confirmed it. Now the prediction carries a real block, and its proof bundle links out to that block on a public explorer.

The batcher runs on a short cadence (hourly): each pass confirms the batches Bitcoin just mined, then seals the newest window.

We don't take the calendar's word for it

When a batch confirms, aiternam doesn't simply trust the calendar's claim that "Bitcoin attests this." It performs an independent check: it fetches the actual Bitcoin block and confirms that the block's own Merkle root matches the one the .ots proof commits to. Only then does the status flip to bitcoin, and only then do we store the confirmed block. So "anchored to Bitcoin" rests on Bitcoin itself — not on any middleman's say-so.

Honest caveats

The proof is strong, and it is not magic. We state its edges plainly, in one place, so the sharpest critic finds our caveats already written by us:

• The residual window. Between the moment you publish and the next batch anchor, immutability still rests on our records. Batches run frequently and resolution horizons are days to years — far longer than the wait — so this window is tiny, but it exists. The status label always tells you the truth about where a given prediction stands.
• Granularity is the block, not the second. Bitcoin proves your prediction existed no later than a particular block, which is looser than the precise timestamp in our records. For markets that is exactly what matters: the meaningful fact is that you committed before the outcome, and horizons dwarf the anchoring delay.
• Backfilled history is shown honestly. Predictions made before anchoring launched were anchored in one initial pass, so their anchor time is later than their creation time. Their fingerprint was still sealed at creation; only the Bitcoin attestation is retroactive — and the proof shows both dates, never hiding the gap.
• The block explorer is a convenience. The link we provide to inspect the block is a read-only third party. For a truly zero-trust check, verify the .ots against your own Bitcoin node.

Now do it yourself: Verify it yourself reproduces every step above from the published rules, with zero trust in aiternam. Or step back to Sealed in time.