Nodes

A node is any computer running Pearl’s rules and talking to other nodes. It keeps its own copy of the blockchain, checks every new block and transaction against the rules, and passes on what passes.

Nobody tells a node what’s valid. That’s the whole point: each one checks for itself, so a block that breaks a rule is simply ignored, however many miners or companies stand behind it.

Most Pearl nodes run pearld, the reference node from Pearl Research Labs. It is written in Go and derived from btcd, a Bitcoin node, so much of what it does will look familiar. What’s new is mostly about the certificate.

Try it

Edit a field of a real header and watch the block hash change. A node recomputes this hash, and much more, for every block it receives.

What does a full node check?

Everything, for every block. Here are the checks grouped by topic, not in strict order: pearld runs cheap ones, such as the Merkle root and the coinbase layout, before the expensive proof check, because “certificate verification is compute intensive”. Any failure ends the check, and the block is thrown away:

1. Certificate and proof of work

   The target in the header’s bits must be positive and within Pearl’s limit. The certificate must be at most 65,000 bytes and must name this exact block: its block hash equals the header’s, and the header’s proof commitment equals SHA256d of the certificate’s version and public data. Then the zero-knowledge proof is verified, which includes checking the ticket against the target times the tile’s work. See certificate.

2. Time

   The timestamp may be at most 5 minutes past the node’s network-adjusted time, and at least 1 second after the parent’s. See timestamps.

3. Place in the chain

   The header must link to a known parent, its bits must equal what WTEMA computes from the parent, it must match any checkpoint at its height, and it may not fork the chain below the latest checkpoint.

4. Rules for this height

   The certificate version must be the one this height requires (V1, V2 or V3), dense-only and the rank penalty apply where they’re active. See forks and upgrades.

5. The block body

   At most 1,000,000 vbytes (header and transactions; the certificate doesn’t count). The first transaction, and only the first, is a coinbase that starts with the height. The Merkle root and witness commitment match.

6. Every transaction

   Only Taproot, P2MR and OP_RETURN outputs; every input exists, isn’t spent twice and has a valid signature or script; coinbase outputs are at least 100 blocks old when spent; and the coinbase claims no more than subsidy plus fees. See transactions.

What does a node store?

Full blocks, laid out as they travel: certificate first, then the 108-byte header, then the transactions. pearld writes them into block files on disk, each record starting with the network’s magic bytes: one of the few places “PRLM” appears at all.

Certificates add up. Each is about 59,768 bytes today, so 130,827 blocks carry roughly 7.8 GB of certificates before counting a single transaction. Many blocks are almost nothing else: in a 200-block scan ending on 20 October 2026, 53% held only the coinbase.

That’s why sizes disagree. Block 130,827 is 64,379 bytes on disk and on explorers, but its consensus size is only 2,795 vbytes, because the 1,000,000-vbyte limit leaves the certificate out.

Besides blocks, a node keeps the set of unspent outputs, so it can check spends quickly, and a waiting room, the mempool, for valid transactions not yet in a block.

Full, pruned and light: what’s the difference?

A pruned node is still a full validator. It just can’t hand old blocks to newcomers. A light client trusts that the most-work chain of valid headers holds valid transactions; it’s covered on light clients.

How does a node say what it offers?

With service flags, a number in its version message where each bit is a promise. pearld’s default is 0xc4d:

1 + 4 + 8 + 64 + 1,024 + 2,048 = 3,149 = 0xc4d. Operators can switch off bloom filters and compact filters, and pruning clears NODE_NETWORK.

What else runs next to pearld?

• Oyster, the wallet daemon, is a separate program that talks to a node. Its RPC port is 44207.
• pearld’s own RPC listens on 44107 for local commands like getblock and getdifficulty.
• The light client lives in the same repository, in spv/, derived from the Neutrino light client.

pearld 1.5.2 introduces itself to peers as /pearlwire:0.5.0/pearld:1.5.2/.

target := CompactToBig(header.Bits)
if target.Sign() <= 0 {
	return ruleError(ErrUnexpectedDifficulty, str)
}
if target.Cmp(powLimit) > 0 {
	return ruleError(ErrUnexpectedDifficulty, str)
}
if cert == nil {
	return ruleError(ErrCertificateMissing, "certificate is missing")
}
// The block hash must be less than the claimed target unless the flag
// to avoid proof of work checks is set.
if flags&BFNoPoWCheck != BFNoPoWCheck {
	if err := zkpow.VerifyCertificate(header, cert); err != nil {
		return ruleError(ErrHighHash, fmt.Sprintf("certificate verification failed: %v", err))
	}
}