Seal it now. Open it at a block you pick.

01 · SEAL · YOUR MESSAGE STAYS IN YOUR BROWSER · NOTHING IS SENT UNTIL YOU PRESS SEND

What should wait?

The page reads GET /status and GET /capsules once this section is on screen, then every twenty seconds while the tab is visible.

A capsule waits in blocks, not minutes. The devnet seals a block within a few seconds when something is posted and otherwise one every five minutes, so 100 blocks is anywhere from five minutes to eight hours. The page says what that looks like at the rate the devnet has been keeping, and at both extremes.

Reading the devnet…

Review the sealNothing is sent yet.

04 · HOW IT WORKS · AND WHAT IT IS NOT

A commit and a reveal.

1. 1

   You seal

   The page hashes your message with a random salt into one commitment and signs a seal_capsule transaction with your key. On chain go only the commitment, the channel, the block it may open at, and a short label for the wax seal. Not the message, and not the salt.

2. 2

   You keep the capsule file

   The message and the salt stay in a small file the page hands you. Without it the capsule never opens. With it, anyone can read the message early, and anyone can open the capsule once its block comes.

3. 3

   The block comes

   From the block you chose until the capsule lapses, anyone holding the file may open it. The devnet will not take an open before its block, so a message cannot be forced out early by the chain; but an open you send yourself too early would sit in the mempool in the clear, so the page refuses to send one.

4. 4

   It airs

   Opening stores the message and reveals the salt in a signed open_capsule transaction. The chain checks they hash to the commitment, and the post airs as its author’s, on the channel you chose. A capsule opens once, and then it is public.

What it is not

• It is not encryption. The chain does not hide your message with a key; it holds a commitment that cannot be matched to the message without the salt, and the salt is 32 random bytes. Whoever has the file has the message.
• It does not choose the moment. It chooses a block height, and the devnet decides how long a block takes.
• It does not make anyone open it. A capsule nobody opens before it lapses is never revealed, and the chain forgets it.
• It is not a promise. One server runs the devnet, it has no value, and it may reset. A reset is dated and recorded, and the capsules do not survive it.

05 · THE SAME STEPS, IN CODE

Seal and open from a terminal.

Keep the SDK (pointcast-chain.js) beside this file and run it with Node 22 or newer. Any 64-hex seed is a devnet account. The open checks that the capsule is due before it sends anything.

capsule.mjs · pins this devnet’s genesis

// capsule.mjs · Node 22+ · keep pointcast-chain.js (the SDK) beside this file
// usage: SEED=<64 hex> node capsule.mjs seal "a title" "the message" 20    (opens 20 blocks on)
//        SEED=<64 hex> node capsule.mjs open capsule.json
import { readFileSync, writeFileSync } from "node:fs";
import * as pcc from "./pointcast-chain.js";
const DEVNET = "https://pointcast-devnet.mhoydich.workers.dev", GENESIS = "a720735b473383057ee11e885b2d32e1565470612364f13c0265c1a1c66f4280"; // any ed25519 seed is a tz1 account
const key = await crypto.subtle.importKey("pkcs8", new Uint8Array([...pcc.hexToBytes("302e020100300506032b657004220420"), ...pcc.hexToBytes(process.env.SEED)]), { name: "Ed25519" }, true, ["sign"]);
const pub = { scheme: "ed25519", bytes: Buffer.from((await crypto.subtle.exportKey("jwk", key)).x, "base64url").toString("hex") };
const me = pcc.tezosAddress(pub), chain = await pcc.connect(DEVNET, { expect: { genesisHash: GENESIS } });
const post = (path, body) => fetch(DEVNET + path, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) }).then((r) => r.json());
const send = async (tx) => post("/tx", { tx, public_key: pub, signature: pcc.bytesToHex(new Uint8Array(await crypto.subtle.sign("Ed25519", key, pcc.hexToBytes(pcc.signingHash(tx, chain.domain))))) });
const [cmd, a, b, c] = process.argv.slice(2);
if (cmd === "seal") {
  const open_at = (await chain.status()).height + Number(c), cm = pcc.capsuleCommitment(chain.domain, { author: me, channel: "BOT", title: a, body_hash: pcc.bodyHash(b), media_uri: null });
  console.log("sealed:", (await send(pcc.buildTx("seal_capsule", { sender: me, nonce: await chain.nextNonce(me), channel: "BOT", commitment: cm.commitment, open_at, label: "sealed from a script" }))).tx_hash);
  writeFileSync("capsule.json", JSON.stringify({ capsule: cm.capsule, salt: cm.salt, title: a, body: b, open_at }, null, 2)); // keep it: without the salt it never opens
} else {
  const f = JSON.parse(readFileSync(a, "utf8")), row = (await (await fetch(DEVNET + "/capsules")).json()).capsules.find((x) => x.id === f.capsule);
  if (!row || !row.due) throw new Error("not open yet (or not listed): it opens at block " + f.open_at); // sending early would burn the salt
  await post("/body", { body: f.body });
  const tx = pcc.buildTx("open_capsule", { sender: me, nonce: await chain.nextNonce(me), capsule: f.capsule, salt: f.salt, title: f.title, body_hash: pcc.bodyHash(f.body) });
  console.log("opened:", (await send(tx)).tx_hash);
}