Hyperspace and Hyperjumps

Bitcoin-backed teleport network for cyberspace traversal

Hyperspace and Hyperjumps

Hyperspace is a 1-dimensional transit network through cyberspace, formed by Bitcoin block Merkle roots in block height order. Each Bitcoin block is a Hyperjump . a thermodynamically "paid for" coordinate that enables long-distance traversal at consumer-feasible cost.

The Key Insight

Bitcoin blocks cost real energy to produce. By treating each block's Merkle root as a coordinate in cyberspace, the entire Bitcoin network becomes a precomputed set of waypoints . a subway system through the vastness of digital space. Every 10 minutes, a new station opens at an unpredictable location.

The Bootstrap Problem

Cyberspace is vast. A newly spawned identity at coordinate (0, 0, 0) wanting to reach a distant point of interest faces a fundamental challenge: the computational cost of traversal.

The Math

To reach an exact coordinate at typical inter-sector distances:

  • LCA height required: approximately 84
  • Computational cost: 2 to the power of 84 operations
  • Time estimate: approximately 10 to the power of 11 years
  • Status: Categorically infeasible

This is the bootstrap problem: how can a newly spawned identity reach any point of interest without requiring more computation than the age of the universe?

Solution: Sector-Based Entry

Instead of requiring navigation to an exact 3D point, Hyperspace entry accepts any coordinate within a sector entry plane. This reduces the required LCA height from approximately 84 to approximately 33, which takes about 15 minutes and costs around $0.09 on cloud compute.

Sector Entry Planes

Each Hyperjump has three entry planes, one per spatial axis. An entry plane is the set of all coordinates sharing the same 55-bit sector as the Hyperjump on that axis.

Definition

For a Hyperjump at coordinate H = (Hx, Hy, Hz):

  • X-plane: All coordinates where sector(X) = sector(Hx)
  • Y-plane: All coordinates where sector(Y) = sector(Hy)
  • Z-plane: All coordinates where sector(Z) = sector(Hz)

Each plane is 1 sector thick (2 to the power of 30 Gibsons, about 1 billion positions). The plane bit (P) is inherited from the Hyperjump coordinate.

To extract a sector from an axis value, use the high 55 bits of the 85-bit axis:

Show Python: Extract sector from axis 
def sector(axis_value: int) -> int:
    """Extract 55-bit sector from 85-bit axis value."""
    return axis_value >> 30  # High 55 bits

Why 55 Bits?

The 55-bit sector was chosen to balance entry feasibility with spatial specificity. A 55-bit match reduces the search space from 2 to the power of 85 to 2 to the power of 30 Gibsons. This is a volume large enough to be reachable, small enough to be meaningful.

Enter-Hyperspace Action

Once positioned on a sector entry plane, publish an enter-hyperspace action to board the Hyperspace network.

Event Structure

Kind: 3333 (all Cyberspace actions)

A tag: enter-hyperspace

Required tags:

  • e . Genesis event ID
  • e . Previous event ID
  • c . Previous coordinate
  • C . Current coordinate (on entry plane)
  • M . Hyperjump Merkle root
  • B . Bitcoin block height
  • axis . Entry axis (X, Y, or Z)
  • proof . Cantor proof to reach the plane
  • X, Y, Z . Hyperjump coordinate components
  • S . Sector value
Show Python: Enter-hyperspace example 
# Enter Hyperspace: Python Example

from cyberspace_core.cantor import compute_temporal_seed, build_hyperspace_proof
from cyberspace_core.sector import coord_matches_hyperjump_plane

# 1. Validate you're on a sector entry plane
coord_int = int.from_bytes(bytes.fromhex(my_coord), "big")
if not coord_matches_hyperjump_plane(coord_int, merkle_root, "Y"):
    raise ValueError("Not on Y-plane")

# 2. Compute Cantor proof to reach the plane
# (same as standard hop proof)
temporal_seed = compute_temporal_seed(bytes.fromhex(prev_event_id))
leaves = [temporal_seed, from_height, to_height]
proof_root = build_hyperspace_proof(leaves)

# 3. Create enter-hyperspace event
from cyberspace_cli.nostr_event import make_enter_hyperspace_event

event = make_enter_hyperspace_event(
    pubkey_hex=pubkey,
    created_at=created_at,
    genesis_event_id=genesis_id,
    previous_event_id=prev_id,
    prev_coord_hex=prev_coord,
    coord_hex=my_coord,
    merkle_root_hex=merkle_root,
    block_height=block_height,
    axis="Y",
    proof_hex=format(proof_root, 'x'),
)

LCA Height

Approximately 33 (to reach sector plane)

Compute Time

Approximately 15 minutes

Cloud Cost

Approximately $0.09

Hyperjump Traversal

Once in Hyperspace, travel between Hyperjumps uses the hyperjump action with an incremental Cantor tree proof.

The Hyperspace Proof

The proof encodes the path through Hyperspace as a Cantor tree over block heights:

  1. Temporal seed: Derived from previous event ID (prevents replay)
  2. Leaves: [temporal_seed, B_from, B_from+1, ..., B_to]
  3. Root: Cantor tree over all leaves

Cost: O(path_length) Cantor pairings, about 200 nanoseconds per block

Show Python: Hyperjump traversal example 
# Hyperjump Traversal: Python Example

from cyberspace_core.cantor import compute_temporal_seed, build_hyperspace_proof
from cyberspace_cli.nostr_event import make_hyperjump_event

# 1. Compute temporal seed from previous event
temporal_seed = compute_temporal_seed(bytes.fromhex(prev_event_id))

# 2. Build leaves: [temporal_seed, B_from, B_from+1, .., B_to]
# For a jump from block 850000 to 850005:
leaves = [temporal_seed, 850000, 850001, 850002, 850003, 850004, 850005]

# 3. Build Cantor tree over all leaves
proof_root = build_hyperspace_proof(leaves)

# 4. Create hyperjump event with DECK-0001 tags
event = make_hyperjump_event(
    pubkey_hex=pubkey,
    created_at=created_at,
    genesis_event_id=genesis_id,
    previous_event_id=prev_id,
    prev_coord_hex=prev_coord,
    coord_hex=new_coord,
    from_height=850000,      # DECK-0001
    to_height=850005,        # DECK-0001
    from_hj_hex=from_hj_merkle,  # DECK-0001
    proof_hex=format(proof_root, 'x'),
)

DECK-0001 Tags

The hyperjump action includes optional DECK-0001 tags for explicit path encoding:

  • from_height . Starting block height
  • to_height . Destination block height
  • from_hj_hex . Source Hyperjump Merkle root
  • proof_hex . Cantor tree proof over path

These tags are optional for backward compatibility but recommended for clarity.

1-Block Jump

Approximately 200 nanoseconds

Cost: negligible

1000-Block Jump

Approximately 1 microsecond

Cost: negligible

Entry vs Traversal: Key Distinctions

It is critical to distinguish between entering Hyperspace and traveling through Hyperspace. These are different actions with different proofs.

Aspect Entry Traversal
Purpose Board the HJ network Travel between HJs
Action enter-hyperspace hyperjump
Proof Cantor to plane (h approximately 33) Cantor tree over path
Non-reuse Chain position binding Temporal leaf binding
Spec DECK-0001 Section I DECK-0001 Sections 7-8

Exit Mechanism

Exiting Hyperspace at a destination Hyperjump is automatic . the identity arrives at the exact 3D coordinate (Hx, Hy, Hz) of the destination Hyperjump.

Preserving Spatial Meaning

The exit mechanism ensures that Hyperspace travel preserves the spatial meaning of coordinates. You cannot "free teleport around" . you arrive exactly where the Hyperjump coordinate says you arrive. This maintains the integrity of distance and location in cyberspace.

Naming Convention

The Hyperspace terminology follows a precise convention:

  • Hyperspace (noun, capitalized) . The 1-dimensional transit network formed by Bitcoin block Merkle roots
  • Hyperjump (noun, capitalized) . A Bitcoin block's Merkle root interpreted as a coordinate in cyberspace; an object or location in Hyperspace
  • hyperjump (verb, lowercase) . The action of traveling between Hyperjumps within Hyperspace
  • enter-hyperspace (action) . The action of boarding the Hyperspace network via a sector entry plane

Avoid These Mistakes

  • Do not use "hyperspace" (lowercase) when referring to the network
  • Do not use "hyper jump" (two words) . always one word
  • Do not use "jump" alone . use "hyperjump" for the noun, "hyperjump" for the verb
  • Do not use "enter" without context . use "enter-hyperspace" for the action

Next Steps

→ Proof-of-Work Mechanics

Deep dive into hyperspace proof construction and verification.

→ Cantor Pairing

Understand the mathematical foundation of traversal proofs.

→ DECK-0001 Specification

Read the full Hyperspace specification on GitHub.

← Coordinate System

Review the 256-bit interleaved coordinate structure.