Bytes

A byte is a group of eight bits. It can hold one whole number from 0 to 255.

That’s the basic unit of everything in Pearl. A private key is 32 bytes. A signature is 64. A block header is 108. Even the matrices miners multiply are stored as long rows of bytes.

What can one byte hold?

Each of the eight bits is a 0 or a 1, and each is worth twice the one to its right. Add up the bits that are on and you get the byte’s value.

All eight bits off is 0. All eight on is 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 255. That gives 256 possible values, which is exactly two hex characters’ worth.

How do bytes make bigger numbers?

By working in teams. Two bytes side by side act like a two-digit number in base 256.

Which byte of the team comes first is a real question with a surprising answer. It has its own page: byte order.

How big are Pearl’s pieces?

Most things in Pearl have a fixed size, which is what makes raw data readable at all. If you know a hash is 32 bytes, you know exactly where the next field starts.

Block header

108 bytes

Bitcoin: 80

Hash

32 bytes

block hash, txid, Merkle root

Public key

32 bytes

x-only, as in Taproot

Schnorr signature

64 bytes

65 with a sighash byte

Amount

8 bytes

a whole number of grains

Certificate

59,768 bytes

in front of every block today

Public data

164 bytes

what the proof is about

XMSS signature

2,340 bytes

optional, post-quantum

Matrix entry

1 byte

a whole number in [−64, 64]

Things that vary in length, like a list of inputs or a script, get a small length prefix in front. That prefix is a CompactSize.

How big is a kilobyte here?

This site uses KB for 1,000 bytes: the certificate in front of every block is about 59.8 KB. A few places use powers of two instead, written KiB (1,024 bytes) and GiB (2³⁰ bytes):

• BLAKE3 hashes data in 1 KiB chunks, and Pearl pads mining matrices to a multiple of 1,024 bytes before fingerprinting them.
• A matrix of 131,072 × 8,192 one-byte entries, the size of matrix A in block 130,825’s certificate, is exactly 1 GiB.

Block size is counted differently again, in vbytes: at most 1,000,000 per block, with the certificate not counted at all.

How are negative numbers stored?

A byte only holds 0 to 255, but sometimes you need negatives. The standard trick is two’s complement: the top half of the range stands for negative numbers.

The rule: to store −x, take 256 − x. So −1 becomes 255 (ff) and −64 becomes 192 (c0). The clever part is that ordinary addition still works. Add 1 to ff and it wraps around to 00, just as −1 + 1 = 0.

Pearl’s mining uses this directly. Every entry of a miner’s matrices is a small whole number between −64 and 64, stored as one signed byte. Here is the first row of the toy matrix A from Pearl’s toy mining example, and the 16 bytes that represent it:

The integers page explains why Pearl picks the range −64 to 64, and why the sums use 4-byte numbers.

How is text stored?

With a lookup table. ASCII gives every common character a number below 128, so each character fits in one byte.

Pearl’s mainnet network magic is the constant 0x50524C4D. Written out, its bytes are 50 52 4c 4d, and in ASCII that’s “P”, “R”, “L”, “M”. (Stored smallest byte first, it appears as 4d4c5250 in Pearl’s block files. Pearl’s peer-to-peer traffic is always encrypted, so it never shows up in the clear on the network.)

Text also appears inside real blocks. The coinbase of block 130,825 carries the bytes 2f706f6f6c2e6b7279707465782e636f6d2f, which read as “/pool.kryptex.com/”, the name of the pool that mined it.

What does a real transaction look like as bytes?

Here is a real Pearl payment, every byte colored by its field. Hover to name each one. It is one input, two outputs and one 64-byte signature.

Read it from left to right and you can see the sizes from the table above: 4 bytes of version, a 32-byte previous txid, 8-byte amounts, a 64-byte signature. The small one-byte fields between them (01, 02, 22, 40) are counts and lengths.

const signed = Int8Array.of(-3, 1, 4, 4);
new Uint8Array(signed.buffer);              // Uint8Array [253, 1, 4, 4], i.e. fd 01 04 04
new TextEncoder().encode('PRLM');            // Uint8Array [80, 82, 76, 77] = 50 52 4c 4d