Proof-of-Work Mechanics
The three types of traversal proofs in Cyberspace: Cantor hop, Merkle sidestep, and Hyperspace traversal
Proof-of-Work Mechanics
Cyberspace has three distinct proof-of-work mechanisms, each designed for different scales of traversal. Understanding when to use each is essential for efficient navigation.
The Three Proof Types
Movement in cyberspace requires computational work, but the type of work depends on the distance and nature of traversal:
1. Cantor Root (Hop)
Use: Standard movement within a sector
Height 0-33 (feasible range)
Time: Milliseconds to 15 minutes
Cost: $0.0001 to $0.09
2. Merkle Root (Sidestep)
Use: Crossing infeasible LCA boundaries
Height 35-40+ (storage-infeasible)
Time: Hours to days (streaming)
Cost: $10-100 (cloud batch)
3. Hyperspace Traversal
Use: Long-distance travel via Bitcoin blocks
Entry: Height approximately 33
Travel: ~200ns per block
Cost: Negligible per jump
Why Three Mechanisms?
Cantor proofs provide structured work with spatial meaning but become infeasible at great distances. Merkle proofs handle any distance but require streaming computation. Hyperspace leverages Bitcoin's existing proof-of-work for long-distance travel. Each serves a different scale of the topography.
Cantor Proofs: Standard Movement
Cantor pairing trees are the default proof mechanism for cyberspace traversal. They compute the actual mathematical fabric connecting two coordinates.
The Temporal Axis
Every Cantor proof begins with a temporal seed derived from the previous movement event. This is critical:
- ▸ The temporal seed is computed from the previous event ID
- ▸ The seed is not known until the previous hop completes
- ▸ This prevents precomputation and replay attacks
- ▸ Every hop costs fresh work, maintaining thermodynamic continuity
Show: Temporal seed computation
def compute_temporal_seed(prev_event_id: bytes) -> int:
"""Derive temporal seed from previous movement event."""
return int.from_bytes(
sha256(prev_event_id),
"big"
) % (2**256)
# The seed becomes the first leaf in the Cantor tree
# This binds the proof to this specific position in the chain Hop Action Details
The hop action (kind 3333, A=hop) is used for local movement within a sector:
Per-Axis Trees
Movement proofs are computed independently for each axis (X, Y, Z), then combined. This preserves axis symmetry:
- Compute Cantor tree for X axis traversal
- Compute Cantor tree for Y axis traversal
- Compute Cantor tree for Z axis traversal
- Combine three axis roots with temporal seed
- Final root is the proof published in Nostr event
LCA Height
Determined by coordinate distance
Typical: 0 to 25 within sector
Compute Time
Milliseconds to seconds
Consumer hardware
Proof Size
Single 256-bit integer
Fits in Nostr tag
Merkle Proofs: Sidestepping
When LCA height exceeds approximately 33, Cantor proofs become storage-infeasible. The sidestep action uses Merkle proofs to cross these boundaries.
When to Sidestep
Sidestep is used when:
- Crossing major sector boundaries (height 35+)
- Traveling between distant regions without Hyperspace access
- The direct Cantor proof would require more memory than available
Merkle proofs work by streaming the tree computation. Instead of storing the entire Cantor tree (which would be terabytes for height 40), the proof is generated and verified incrementally.
Show: Merkle vs Cantor comparison
| Property | Cantor | Merkle |
|---|---|---|
| Max Height | ~33 (feasible) | Any (streaming) |
| Memory | Kilobytes | Streaming (minimal) |
| Time | Milliseconds to minutes | Hours to days |
| Use Case | Standard movement | Boundary crossing |
Action Type
kind 3333, A=sidestep
Proof Type
Merkle root of path
Hyperspace Proofs
Hyperspace traversal uses a specialized form of Cantor proof optimized for traveling along the Bitcoin block chain. This mechanism is covered in depth in the Hyperspace documentation, but the key points are:
Two-Phase Process
- Entry: Publish
enter-hyperspaceaction (kind 3333, A=enter-hyperspace) with Cantor proof to reach sector plane (height approximately 33) - Traversal: Publish
hyperjumpactions (kind 3333, A=hyperjump) with incremental Cantor tree over block heights
The hyperspace proof is unique because it encodes a temporal path (block heights in order) rather than a spatial path (coordinates in order). The temporal leaf derived from the previous event prevents replay and ensures fresh work for each jump.
Entry Cost
Height approximately 33
15 minutes, $0.09
Travel Speed
~200ns per block
Negligible cost
Best For
Long-distance travel
Cross-cliff traversal
Summary: All Actions Use Kind 3333
Every Cyberspace movement action uses Nostr event kind 3333. The action type is specified in the A tag:
| Action | A Tag | Proof Type | Use Case |
|---|---|---|---|
| Hop | hop | Cantor tree | Local movement (within sector) |
| Sidestep | sidestep | Merkle tree | Cross infeasible boundaries |
| Enter Hyperspace | enter-hyperspace | Cantor to plane | Board Hyperspace network |
| Hyperjump | hyperjump | Cantor over path | Travel between Hyperjumps |
Critical Protocol Pattern
All actions use kind 3333, differentiated by the A tag. This is a critical protocol pattern that ensures all movement is validated uniformly by relays and enables future extensions without requiring new kind numbers.