Skip to content
Open app

How it worksThe Log

The Log

Every message in order as the chain holds it, what one entry carries, and how the indexer serves it.

The Log is every post transaction the Talaria program has accepted, in the order the chain confirmed them. Each one is a Log entry. Nothing else is stored for a message: no account names its writer, and no account names its reader.

One message as its reader sees it and as the chain holds it.

What a Log entry holds#

A post transaction carries these fields, in this order:

FieldWhat it is
ProofGroth16, 256 bytes
Rootthe recent pool root the proof is made under
Daythe day the proof is valid for
Nullifierone per message, per pass, per day
Key slotstwo: one opens it for the reader, one for the writer
CiphertextXChaCha20-Poly1305
Relaythe only signature on the transaction

The root is the pool root the proof was made against. The proof, the root, the day and the nullifier are the instruction's arguments; the key slots and the ciphertext are its payload, which stays in instruction data. The relay is the post instruction's relay account, the signer the Vault pays; the indexer names the entry's relay from that account. A relay sends the transaction with itself as fee payer and only signer. Log entry format gives every byte.

The accounts a post touches are the relay, Config, Pool, Vault, the new Nullifier and the system program. The Nullifier address is derived from the day and the nullifier alone. Program accounts gives each one.

What a Log entry does not hold#

  • No writer: not the wallet, not its inbox key, not the pass. The writer's wallet and inbox key are inside the ciphertext, readable only by whoever opens a key slot.
  • No reader: each key slot holds a one-time ephemeral key and a one-byte view tag, both made fresh for this message. Cryptography covers how they are formed.
  • No pass index, leaf or counter. The proof says only that some unexpired pass in the pool sent it within its daily limit. The proof covers what it states.
  • No link between two messages of the same pass. Each message has its own nullifier, and nothing in one nullifier points to another.

Log positions#

The indexer gives every entry a Log position: its index, counted from 0 in the order the entries landed (by slot, then by place within the block). Positions never change once given. A client that has read up to position n resumes from n + 1, and scan takes a starting position for a restore.

How the indexer serves the Log#

Every client reads the whole Log and tries each entry with its own keys. Asking the indexer for one entry by anything other than its signature would tell it which entries belong to the asker, so the API serves the Log in pieces every client downloads alike.

PieceWhat it holdsEndpoint
Sealed segmentsRuns of 256 entries each. Segment n holds positions n × 256 to n × 256 + 255. A sealed segment never changes and is served as immutable, cacheable for a year.GET /log/segments/:n
The headThe entry count, the number of sealed segments, the segment size, and the tail: every entry after the last sealed segment. Also the last position, the last signature and its slot.GET /log/head
The live streamServer-sent events: ready with the head when the stream opens, entry for each new entry, and resync when the client has fallen behind or reconnected.GET /log/stream
One entryThe entry a signature names, once it is indexed.GET /log/entries/:signature

To read the whole Log, fetch the head, download segments 0 to segmentCount − 1, take the tail, then follow the stream. A resync event means fetch the head again and fill the gap from it.

An entry served by the API holds the chain's fields plus what the indexer read beside them: the signature, the slot, the block time (UTC), the Log position, the decoded payload (both key slots and the ciphertext with its length), the five public inputs and the six field elements the verifier saw, and a verification record. A landed post has already been verified by the program, so a confirmed entry reads verified.

An entry that has landed and is not yet indexed answers LOG_ENTRY_NOT_INDEXED, which is retryable. Errors lists every code.

The Log on the site#

/log is the Log as the chain sees it. It streams entries as they land, each row with its time (UTC), relay, size in bytes and nullifier, and can be paused and resumed and filtered by relay and by day. Beside the stream it shows the figures: passes in the pool, messages today and all time, entries per relay and per minute, and the balance of the fee account.

/log/<signature> is one entry in full: every field with all its bytes, the public inputs of its proof, the verification result, and a link to the transaction on an explorer.

The On chain panel#

In the app, On chain on any message opens what the chain holds for it: signature, slot, time, relay, day, nullifier, proof bytes, both key slots with their view tags, and the ciphertext's size and bytes. It ends on one line: of this, what identifies the writer or the reader is nothing.

A message sent in several parts has one entry per part, and the panel shows each part in turn. A message whose transaction has landed but is not yet indexed shows Not yet indexed with Read again. From the panel, Open this entry in the Log goes to its /log/<signature> page.