SOST Protocol — Technology

OVERVIEW

Architecture Pipeline

Layer 01

ConvergenceX PoW

Gradient-descent work
+ stability basin proof

Layer 02

cASERT bitsQ

Per-block difficulty
Q16.16 adjustment

Layer 03

cASERT Equalizer

Structural correction
Adaptive mode control

Layer 04

SOSTCompact

Q16.16 difficulty
encoding (nBits)

Layer 05

MTP Validation

Median Time Past
timestamp discipline

The consensus stack is vertically integrated: ConvergenceX produces the proof-of-work, cASERT controls difficulty via three layers — bitsQ primary controller adjusts every block in continuous Q16.16 log-space, the equalizer applies structural correction via ConvergenceX stability profiles, and anti-stall ensures liveness — while MTP anchors all timing decisions to validated chain history. Every layer is integer-only and bit-for-bit reproducible across all implementations.

PROOF OF WORK

ConvergenceX PoW

convergencex_attempt()

CONSENSUS-CRITICAL

Instead of brute-force hash collision, ConvergenceX requires miners to produce verifiable convergence certificates using Transcript V2. Each attempt solves a tip-bound linear system via deterministic gradient descent, mixed with memory-hard scratchpad reads, and proves the solution lies in a stable convergence basin. Transcript V2 adds segment commitments and sampled round witnesses, enabling 11-phase verification at ~0.2ms (vs ~1ms in V1). Dataset v2 (SplitMix64) and Scratchpad v2 (SHA256-indexed) are independently indexable at O(1).

// 1. Derive challenge from chain tip (anti-grinding)
block_key  = SHA256( prev_hash || "BLOCK_KEY" )
seed       = SHA256( MAGIC || "SEED" || header_core || block_key || nonce || extra_nonce )

// 2. Derive linear system M, b from block_key (deterministic per tip)
(M, b, λ)  = derive_M_and_b( block_key, N=32, λ=100 )

// 3. Gradient descent with scratchpad mixing (memory-hard)
for r in 1..100,000:
    x[i] -= ( A(x)[i] - b[i] ) >> lr_shift          // gradient step
    x[j] ^= mix_from_scratch( scratchpad, idx )   // ASIC resistance
    state  = SHA256( state || mix_data || round )   // state chain

// 4. Verify stability basin (k perturbation probes)
(is_stable, metric) = verify_convergence_stability_basin( x_final, M, b, ... )

// 5. Compute commitment
commit = SHA256( MAGIC || "COMMIT" || header_core || seed || state || x || segments_root || cp_root || metric )
require  commit <= target   AND   is_stable == true
        

CX_SCRATCH_MB	`4096` // 4 GB memory-hard scratchpad (+ 4 GB dataset = 8 GB total mining memory)
CX_N	`32` // linear system dimension
CX_ROUNDS	`100,000` // sequential gradient iterations
CX_LR_SHIFT	`18` // learning rate = 1/(2^18)
CX_LAM	`100` // regularization parameter (λ)
CX_CHECKPOINT_INTERVAL	`6,250` // rounds/16, Merkle-committed
CX_STABILITY_K	`4` // perturbation probes per attempt
CX_STABILITY_GRADIENT_STEPS	`3` // refinement steps per probe
Scratchpad derivation	Sequential SHA-256 chain // epoch-keyed, mmap-friendly
Verification	Two-stage pipeline // cheap header check → full recompute

Stability Basin Verification

CONSENSUS-CRITICAL

A valid ConvergenceX proof must demonstrate that the solution x_final resides in a stable attractor basin. The verifier applies k deterministic perturbation probes and checks two acceptance rules per probe:

Local non-explosion	`d(t+1) <= d(t) + margin_eff` // per gradient step
Global contraction	`d_final * c_den <= d0 * c_num + margin_eff` // for large perturbations
Contraction ratio	`7/10` // epoch-invariant V1
Perturbation scale	`3` // uniform in [-scale, +scale]
Stability LR shift	`20` // lr_shift + 2 (more conservative)

DIFFICULTY ADJUSTMENT

cASERT bitsQ Retargeting

casert_next_difficulty()

CONSENSUS-CRITICAL

SOST implements cASERT bitsQ as the primary hardness regulator within the unified cASERT consensus-rate control system. Inspired by BCH's ASERT, the bitsQ controller performs per-block exponential difficulty adjustment in continuous Q16.16 log-space. Unlike legacy epoch-based retarget systems that wait for large windows, bitsQ corrects difficulty every single block with a 12-hour half-life and a per-block relative delta cap of 6.25% (1/16), producing smooth transitions and faster convergence to the target interval.

// Compute expected parent time from epoch anchor
expected_pt = anchor_time + (parent_idx - anchor_idx) * 600
td          = prev_time - expected_pt

// Exponential cASERT bitsQ: next_bitsq = anchor_bitsq * 2^(-td / halflife)
exponent = (-td * Q16_ONE) / CASERT_HALF_LIFE
shifts   = exponent >> 16        // integer part
frac     = exponent & 0xFFFF     // fractional part

// 2^frac via cubic polynomial (Horner's form, Q0.16)
factor   = Q16_ONE + polynomial_approx(frac)
result   = (anchor_bitsq * factor) >> 16
result   = result << shifts       // apply integer power-of-two

// Per-block relative delta cap: 6.25% (1/16)
new_powDiffQ = clamp( result, MIN_BITSQ, MAX_BITSQ )
        

TARGET_SPACING	`600` seconds // 10-minute target block time
bitsQ Half-Life	`43,200` seconds // 12 hours
MIN_BITSQ	`65,536` // Q16_ONE — minimum difficulty
MAX_BITSQ	`16,711,680` // 255 × Q16_ONE — maximum difficulty
Anchor rotation	Per-epoch // resets at epoch boundary blocks
Encoding	SOSTCompact Q16.16 // finer granularity than Bitcoin nBits
Arithmetic	Integer-only // no floating point, no consensus drift

EQUALIZER

cASERT Controller

casert_mode_from_chain()

EQUALIZER LAYER

cASERT (Contextual Adaptive Stability & Emission Rate Targeting) is the unified consensus-rate control system. Its equalizer layer adapts ConvergenceX's stability verification parameters based on how far ahead the chain is running vs the ideal schedule (genesis + height × 600s). Unidirectional: only hardens when chain is ahead of schedule. When behind, cASERT bitsQ handles difficulty without equalizer overlay.

// Lag: positive = behind, negative = ahead
elapsed   = latest_time - GENESIS_TIME
expected  = elapsed / 600
lag       = expected - (next_height - 1)
ahead     = (lag < 0) ? -lag : 0

// Level from blocks ahead (fixed bands L1-L5, unbounded L6+)
if ahead <   5 → L1 (neutral, scale=1)
if ahead <  26 → L2 (scale=2)
if ahead <  51 → L3 (scale=3)
if ahead <  76 → L4 (scale=4)
if ahead < 101 → L5 (scale=5)
else          → L6+ (scale = 6 + floor((ahead-101)/50))  // unbounded
        

L1 NEUTRAL

0–4 blocks ahead · scale=1
cASERT bitsQ handles difficulty. No equalizer overlay.

L2

5–25 blocks ahead · scale=2
Light hardening. k=4 · margin=180 · steps=4

L3

26–50 blocks ahead · scale=3
Moderate hardening.

L4–L5

51–100 blocks ahead · scale=4–5
Strong/severe hardening.

L6+ UNBOUNDED

101+ blocks ahead · scale grows every 50 blocks
No ceiling. The faster the attack, the harder the brake.

// Activation: max(ahead 00D7 600s, 7200s) 2014 proportional, no ceiling
// Mining only — validation uses raw level
stall_time = now - last_block_time - activation  // max(ahead00D7600, 7200)

while effective_level > 1 and stall_time > 0:
    if level >= 8: cost = 600s   // L8+: 10 min/level (fast)
    elif level >= 4: cost = 1200s  // L4-L7: 20 min/level (medium)
    else:           cost = 1800s  // L2-L3: 30 min/level (cautious)
    effective_level -= 1
    stall_time -= cost
        

Worked Example — L10 (450 ahead):
Activation: max(450×600, 7200) = 270,000s (75h)
L10→L8: FAST (10min/level) = 30min · L7→L4: MEDIUM (20min/level) = 80min · L3→L1: SLOW (30min/level) = 60min
Total decay: 170min (2h 50m) · Total from start: ~78 hours

CASERT_L2_BLOCKS	`5` // blocks ahead to enter L2
CASERT_L3_BLOCKS	`26` // blocks ahead to enter L3
CASERT_L4_BLOCKS	`51` // blocks ahead to enter L4
CASERT_L5_BLOCKS	`76` // blocks ahead to enter L5
CASERT_L6_BLOCKS	`101` // L6+ unbounded starts here
DECAY_ACTIVATION	`max(ahead00D7600, 7200)` // dynamic, proportional, floor 2h
Directionality	Unidirectional // only hardens when chain is ahead

ENCODING & VALIDATION

SOSTCompact & MTP

SOSTCompact Q16.16

CONSENSUS

Difficulty is encoded as a Q16.16 fixed-point value in block headers, providing finer granularity than Bitcoin's nBits compact format. Deterministic bidirectional conversion between compact and full 256-bit target ensures consensus-safe retarget math and bit-for-bit reproducibility.

Format	Q16.16 fixed-point // uint32
GENESIS_BITSQ	`765,730` (11.6841 in Q16.16, calibrated)
MIN_BITSQ	Easiest allowed target
MAX_BITSQ	Hardest allowed target

Timestamp Discipline

CONSENSUS

Block timestamps are validated against Median Time Past (MTP) to prevent manipulation affecting difficulty. Combined with cASERT anchoring, this creates stable timing even under individually noisy blocks.

MTP_WINDOW	`11` blocks
MAX_FUTURE_DRIFT	`600` seconds
Rule: ts > MTP	Strict monotonicity
Rule: ts ≤ now + drift	Bounded acceptance

CHAIN PARAMETERS

Consensus Constants

Network Configuration

IMMUTABLE

MAINNET_GENESIS_UTC	`1773597600` // 2026-03-15 18:00:00 UTC
BLOCKS_PER_EPOCH	`131,553` // ≈2.5 years (Feigenbaum α)
TARGET_SPACING	`600` seconds // 10-minute blocks
MAGIC	`CXPOW3` + `NETWORK_ID` // unique wire identifier
NETWORK_ID	`SHA256("SOST/CONVERGENCEX/mainnet")[:4]`
Block header	`MAGIC + "HDR2" + core(72B) + cp_root(32B) + nonce(4B) + extra(4B)`
Block ID	`SHA256( header \|\| "ID" \|\| commit )`
Block key (anti-grind)	`SHA256( prev_hash \|\| "BLOCK_KEY" )` // tip-bound only
Chainwork	Bitcoin-style: `(2^256 - 1) / (target + 1) + 1`

DESIGN

Core Principles

DETERMINISTIC

Zero floating point in consensus. Integer-only arithmetic guarantees identical results on every architecture. Same input → same output, unconditionally.

CPU-ORIENTED

8 GB total mining memory (4 GB scratchpad + 4 GB dataset) with 100,000 sequential iterations. Node validation requires only ~500 MB. Throughput is bounded by memory bandwidth and latency, not raw compute — making ASIC development economically impractical.

ADAPTIVE

Per-block cASERT retargeting with bitsQ + equalizer. The chain converges to its target interval within hours, not days. No retarget whiplash.

LAUNCH-SAFE

cASERT degrades stability requirements under thin hashrate, ensuring the chain remains mineable and stable from genesis. Security grows with the network.

VERIFIABLE

Transcript V2 verification: cheap header/target checks for fast sync, 11-phase segment + round witness verification (~0.2ms) for standard validation, full ConvergenceX recomputation for deep validation. Merkle-committed segments and checkpoints enable SPV-friendly proof structures.

ANTI-GRINDING

Block key derives from chain tip only. All miners solve the same linear system for a given tip — per-attempt uniqueness comes from nonce/extra_nonce, not from the challenge itself.

PoW COMPARISON

Bitcoin vs Monero vs SOST

Proof-of-Work Architecture Comparison

Property	Bitcoin (SHA-256d)	Monero (RandomX)	SOST (ConvergenceX)
PoW verify cost	~1μs	~50ms	~5–30s
Memory (mining)	Negligible	256MB–2GB	8GB (4GB scratchpad + 4GB dataset)
Memory (node)	Negligible	~256MB	~500MB (no scratchpad/dataset)
ASIC resistance	None	High	Very high
Full sync time	~hours	~days	~weeks
Fast sync time	~minutes	~hours	~minutes
Verification layers	4	4	8
Difficulty adjust	Every 2016 blocks	Every block (LWMA)	Every block (cASERT exp.)
Block time	600s	120s	600s
Anti-stall	None	LWMA	cASERT Decay (2h→tiered)
Anti-acceleration	None	LWMA	cASERT L1–L6+ unbounded
Emission	Halving / 210K blocks	Tail emission	Smooth exp. decay (q=e^-¼)
Max supply	21M BTC	Infinite	~4,669,201 SOST
Constitutional reserve	None	None	25% gold + 25% PoPC

ConvergenceX Consensus Engine

Architecture Pipeline

ConvergenceX PoW

cASERT bitsQ Retargeting

cASERT Controller

SOSTCompact & MTP

Consensus Constants

Core Principles

Bitcoin vs Monero vs SOST

ConvergenceX
Consensus Engine