Node Overview

An SCL node is the foundation of the network. It's where contracts get executed, histories are stored, and verification happens.

Running a node gives you:

• Independence. You validate every contract transition yourself.
• Anchoring. All truth comes from Bitcoin transactions and block context.
• Resilience. You store history and serve it to others. If peers diverge, your replay exposes it.

Nodes are not miners. They don't mine blocks or join consensus. Instead, they watch Bitcoin for protocol stamps and replay the committed calls deterministically. Given the same payload, contract commitment, and Bitcoin context, every honest node computes the same result, and the same per-block state root.

This model means:

• You can always check contract state without permission.
• History is provable, because every step is tied back to Bitcoin.
• Invalid payloads fail deterministically, without voting or leader election.
• Divergence is detectable at a glance: compare state roots at any block height.

Your node also enforces strict execution ceilings:

• 100k max instructions per call, shared across nested cross-contract calls
• 1024 stack depth
• 64 call depth
• 64 KB persistent storage per contract
• 64 KB max payload size

These bounds guarantee that verification is predictable, safe, and scalable.

How a node works in practice:

1. Ingest payloads from clients and peers, validating each envelope's anchor binding at intake.
2. Watch Bitcoin (via Esplora) for confirmed protocol stamps.
3. Re-validate the anchor binding at confirmation; this check is consensus-critical.
4. Derive execution context (block height, sender, anchor transaction inputs and outputs).
5. Replay the call in the VM and commit the write-set with undo data.
6. Publish the block's state root; roll back automatically if Bitcoin reorgs.