Bitcoin Forum
April 19, 2026, 02:28:13 AM *
News: Latest Bitcoin Core release: 30.2 [Torrent]
 
   Home   Help Search Login Register More  
Pages: « 1 2 3 [4] 5 »  All
  Print  
Author Topic: [ANN] SOST — Native PoW Chain | ConvergenceX | CPU-Only | 8 GB | Gold Reserve  (Read 930 times)
oswaldzc
Newbie
*
Offline Offline

Activity: 13
Merit: 0


View Profile
April 12, 2026, 01:44:19 PM
 #61

Hello, Neob1844 Grin

are there any plans to optimize the miner program to display hashrate?

PS: mining is really difficult right now — is anyone willing to set up a mining pool?
Neob1844 (OP)
Newbie
*
Offline Offline

Activity: 28
Merit: 0


View Profile
April 13, 2026, 12:27:10 AM
Last edit: April 18, 2026, 09:58:51 AM by Welsh
 #62

Hi vostokzyf,

  If DNS resolution fails, connect by IP directly:

  
Code:
  ./sost-node --rpc-user vostok --rpc-pass vostok \
    --genesis genesis_block.json --chain chain.json \
    --connect 212.132.108.244:19333 \
    --profile mainnet --p2p-enc off
  

  Also please update — there is a V3.1 minor fix at block 4,200. Same process: git pull origin main, rebuild, restart.


 
 cASERT V3.1 — Minor Fix at Block 4,200
  

  

  SOST is a completely new proof-of-work protocol built from scratch — ConvergenceX, cASERT, the P2P layer, the economic model — none of it
  existed before 2026. A system of this complexity requires continuous refinement as it operates under real-world conditions for the first time.

  The core protocol is secure and stable. However, live operation with multiple miners at varying hashrates has revealed two edge cases in the
  cASERT equalizer that require correction:

  Fix 1 — Slew rate enforcement (consensus, block 4,200):
  The V3 equalizer recomputed the previous block's profile using raw PID output without applying the slew rate constraint. This allowed the
  profile to jump more than the intended ±3 levels in certain conditions. V3.1 uses the actual stored profile from the previous block, ensuring
  the ±3 limit is always respected.

  Fix 2 — Anti-stall threshold (policy, immediate):
  The anti-stall activation threshold scaled with block lag (lag × 600s), which at 67 blocks ahead resulted in an 11-hour delay before
  anti-stall could help. This is now fixed to always activate after 2 hours maximum, regardless of lag.

  Action required:
  
Code:
  cd /path/to/sost-core
  git pull origin main
  cd build && cmake .. -DCMAKE_BUILD_TYPE=Release && make -j$(nproc)
  # Restart node and miner
  

  If you already updated for V3 at block 4,100, this is the same process — just pull and rebuild.

  Timeline: V3.1 activates at block 4,200 (~98 blocks from block 4,102). The anti-stall fix is active immediately after update.

  Existing blocks are not affected. Blocks 4,100-4,199 remain valid under V3 rules. V3.1 applies only from block 4,200 onward.

  

  
NeoB — SOST Protocol
  sostcore.com · GitHub ·
  Explorer


Hi oswaldzc,

Hashrate display is now in the latest code. After you pull and rebuild, your miner will show something like:

[HASHRATE] 18.3 att/s | threads=4 | total=1200 | stable=87% | elapsed=65s

Mining pool, good idea for the future, but with 6 miners right now it's a bit early. Once we grow to 20-30+ miners it'll make a lot more sense. Happy to share integration specs if you want to build one.

About the difficulty, yeah, it's tough right now. The chain got ahead of schedule so the equalizer kicked in hard. It'll ease up as things normalize. Make sure you're on the latest code: git pull, rebuild, restart.

   ⚠ URGENT — cASERT V3.1 activation accelerated to block 4,110

  All nodes and miners: please update immediately.

  What happened:
  A bug in V3 causes the equalizer profile to oscillate between H3 and H12 in a single block — violating the ±3 slew rate limit. This makes
  mining very difficult with long periods at 0% stability.

  What changed:

  
FixProblemSolutionType
V3.1 slew rateProfile jumped H3→H12 in 1 block (9 levels). Raw PID recomputation ignored actual previous
  profile.
Uses stored profile_index from previous block. ±3 now enforced correctly.Consensus (block 4,110)
Anti-stall thresholdActivation scaled with lag (67 ahead = 11h wait). Mining impossible for hours.Fixed to always 2
  hours max, regardless of lag.
Policy (immediate)
Miner profile refreshMiner started at H12/0% stability and never checked if anti-stall decayed the
  profile.
Auto-detects profile change every 2 min and restarts with easier profile.Miner (immediate)
Hashrate displayNo way to see mining speed.Real-time [HASHRATE] X.X att/s output in miner logs.Miner
  (immediate)

  Activation accelerated from block 4,200 to block 4,110 due to severity of oscillation.
  Blocks 4,100-4,109 remain valid under V3 rules. Existing chain is not affected.

  You can update now. The consensus fix activates automatically at block 4,110, but the miner improvements (anti-stall detection,
  hashrate display) are active immediately after rebuild.

  To update:
  
Code:
  cd ~/sost-core
  git pull origin main
  cd build
  cmake .. -DCMAKE_BUILD_TYPE=Release
  make -j$(nproc)
  
 Restart node and miner. Same process as V3.

  Context: SOST is a completely new PoW protocol — ConvergenceX, cASERT, 17-profile equalizer, PID controller — built from scratch. The
  core design is sound. These are edge cases found under real multi-miner conditions, exactly what the pre-launch testing phase is for.

  
 
Rizki Maryanto
Newbie
*
Offline Offline

Activity: 14
Merit: 0


View Profile
April 13, 2026, 02:21:18 AM
 #63

Hi NeoB,

Updated to V3.1 and it's running smooth. The hashrate display is a great addition!

I’m currently peaking at 9.0 att/s on my setup. I’ve been mining for over 2 days now, but honestly, I haven't caught a single block yet. It's getting pretty discouraging for small miners like me, while the "whales" seem to be sweeping everything since the difficulty is so high.

Are there any concrete plans for a mining pool in the near future? Solo mining is basically a lottery right now where only the big players win. A pool would really help smaller contributors get a fair share and keep the network decentralized.

Thanks for the update!
Neob1844 (OP)
Newbie
*
Offline Offline

Activity: 28
Merit: 0


View Profile
April 13, 2026, 04:16:51 AM
Last edit: April 13, 2026, 04:27:26 AM by Neob1844
 #64

  Hi Rizki,

  Glad V3.1 is running smooth! At 9 att/s you're likely running with few threads. Here's how to check your system and optimize:

  Step 1: Check your hardware
  
Code:
  # How many CPU cores/threads available:
  nproc

  # CPU model and details:
  lscpu | grep -E "Model name|CPU\(s\)|Thread"

  # Total RAM and available:
  free -h

  # Example output:
  #   nproc → 8
  #   Model name: AMD Ryzen 7 5800H
  #   CPU(s): 16  (8 cores × 2 threads each)
  #   Mem: 31Gi total, 22Gi available
  

  Step 2: Calculate your optimal --threads

  The miner needs:
  - 8 GB for the shared scratchpad (fixed, shared by all threads)
  - ~1 GB for the OS and node
  - ~0.5 GB per mining thread

  Formula: threads = min(cores - 1, (total_RAM - 9) / 0.5)

  Examples:
  
Code:
  8 cores,  16 GB RAM → --threads 4   (limited by RAM)
  8 cores,  32 GB RAM → --threads 7   (limited by cores)
  12 cores, 32 GB RAM → --threads 11  (limited by cores)
  16 cores, 64 GB RAM → --threads 15  (limited by cores)
  4 cores,  16 GB RAM → --threads 3   (limited by cores)
  

  Step 3: Restart your miner
  
Code:
  pkill -9 -f sost-miner
  cd ~/sost-core/build
  git pull origin main
  make -j$(nproc) sost-miner
  ./sost-miner --address YOUR_ADDRESS \
    --rpc 127.0.0.1:18232 --rpc-user YOUR_USER --rpc-pass YOUR_PASS \
    --blocks 999999 --profile mainnet --threads N
  
 Replace N with your number from Step 2.

  Step 4: Verify
  After ~2 minutes you should see:
  
Code:
  [HASHRATE] 35.2 att/s | threads=6 | total=4200 | stable=87% | elapsed=120s
  
 Your hashrate should scale roughly linearly: 4 threads ≈ 4× single-thread speed.

  
  About mining pool: It's on the roadmap but premature with 6 miners. Building a pool requires stratum protocol, share management, and
  payout infrastructure. When we reach 20-30+ miners it will make sense. For now, optimizing your threads is the fastest path to finding blocks.

  The two dominant miners likely run 8-10+ threads on fast CPUs. With --threads 6-8 you close that gap significantly.

  Important: Don't set --threads too high. If you exceed your available RAM, your OS will kill the miner process ("Killed" message).
  Start with a conservative number from Step 2 and increase by 1 if stable. If you see "Killed" or "REJECTED", reduce by 1-2 threads.
oswaldzc
Newbie
*
Offline Offline

Activity: 13
Merit: 0


View Profile
April 13, 2026, 05:55:02 AM
 #65

My runtime environment is WSL2, Ubuntu 24.04.
The miner process information is as follows:


PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
498 oswald    20   0   36.7g  36.0g   6912 S 821.0  76.5  22:42.60 sost-miner

[MINING] Starting 8 threads for parallel nonce search
[HASHRATE] 33.9 att/s | threads=8 | total=1553 | stable=0% | elapsed=46s
[HASHRATE] 36.6 att/s | threads=8 | total=3086 | stable=0% | elapsed=84s
...
[HASHRATE] 42.0 att/s | threads=8 | total=467262 | stable=0% | elapsed=11124s

I have two questions:
Why is the memory usage 36 GB instead of 8 GB + 8 × 0.5 GB = 12 GB?
Why does "stable" remain at 0%—is this normal?
Neob1844 (OP)
Newbie
*
Offline Offline

Activity: 28
Merit: 0


View Profile
April 13, 2026, 06:30:27 AM
Last edit: April 13, 2026, 08:35:42 AM by Neob1844
 #66

   ⚠ SECURITY FIX — All nodes and miners: update immediately

  A validation bug was found and fixed. Blocks without profile_index were being accepted at E1 difficulty (very easy) instead of the
  correct H12. Additionally, the lag floor is now enforced as a minimum profile — miners cannot declare a profile below lag/8.

  What was fixed:
 
  • Blocks without profile_index are now rejected at V3+ heights
  • Lag floor enforced as minimum: at lag=37, minimum profile is H4 (37/8)
  • Profile_index fallback for chain-imported blocks corrected

  You MUST update both node and miner:
 
Code:
  cd ~/sost-core
  git pull origin main
  cd build
  cmake .. -DCMAKE_BUILD_TYPE=Release
  make -j$(nproc)
 

  Then restart both:
 
Code:
  pkill sost-node
  pkill sost-miner

  # Download fresh chain
  curl -o chain.json https://sostcore.com/bootstrap-chain.json

  # Start node
  ./sost-node --genesis genesis_block.json --chain chain.json \
    --connect 212.132.108.244:19333 \
    --rpc-user YOUR_USER --rpc-pass YOUR_PASS \
    --profile mainnet --p2p-enc off

  # Start miner (after node syncs)
  ./sost-miner --address YOUR_ADDRESS \
    --rpc 127.0.0.1:18232 --rpc-user YOUR_USER --rpc-pass YOUR_PASS \
    --blocks 999999 --profile mainnet --threads N
 

  Old code will have blocks rejected by updated nodes. If your node is stuck or not syncing, delete your chain.json and re-download the
  bootstrap.

  This is the pre-launch testing phase working as intended — real miners found a real edge case, and it's now fixed. Thank you for your
  patience.

 
 
NeoB — SOST Protocol
  sostcore.com · GitHub ·
  Explorer
Rizki Maryanto
Newbie
*
Offline Offline

Activity: 14
Merit: 0


View Profile
April 13, 2026, 06:45:13 AM
 #67

I see that the Neob concept has a solid and well-thought-out foundation, which makes it quite interesting for further development. At the moment, I’m still at an early stage by allocating a small portion of my resources (RAM) to mine SOST as an initial participation.
However, I would like to gain a clearer understanding of the project’s roadmap, particularly regarding the plan for SOST to be listed on CEX platforms. This is an important consideration for me in determining my next steps, including the potential to enter as an early buyer once the token becomes available on the market.
On the other hand, if SOST has not yet been listed, I would also like to know whether there is an option to purchase directly from the developer or the team, of course through a secure and transparent mechanism.
I’m quite interested in following the progress of this project and look forward to potentially being more involved in the future.
Neob1844 (OP)
Newbie
*
Offline Offline

Activity: 28
Merit: 0


View Profile
April 13, 2026, 12:11:31 PM
Last edit: April 18, 2026, 09:00:39 PM by Welsh
 #68

Hi oswaldzc,

  Two good questions:

  1. Memory (36 GB): The 36 GB includes the full scratchpad (8 GB) + the dataset (4 GB) + OS/node overhead. With 8 threads, each thread
  also allocates working memory for the 32×32 matrix operations and stability checks. WSL2 may also report shared memory differently. The key
  metric is: if it runs without "Killed", your RAM is fine.

  2. Stable=0%: This is because the current profile is H12 (margin=105, scale=3). At H12, the stability basin test is extremely strict —
  almost no solutions pass. This is the cASERT equalizer doing its job: the chain is 35+ blocks ahead, so mining is intentionally very hard to
  slow block production.

  Important: Please update your code — a security fix was just deployed. See post #69 above for instructions. After updating, the profile
   will respond correctly and stability will improve as the chain lag decreases.


 Hi Rizki,

  Thank you for the kind words and your interest.

  OTC Status: The OTC sale is currently closed. There was an initial offer of 3,000 SOST at $0.20 each, priced below the PoPC
  reference value (~$0.22 at the time). However, as more tokens are mined, the reference value adjusts. To be clear: this is a simulated
  reference price
based on the tokenized gold I have personally committed to the PoPC program — it is not a market price. SOST is not listed
   on any exchange yet, so there is no real market price.

  Whatever is obtained from any future sale will go entirely to purchasing more tokenized gold (XAUT or PAXG) to strengthen the protocol
  reserve.

  Exchange listing: Exchange outreach is planned from June 2026, subject to network stability and sufficient hashrate.

  But here's what you CAN do — and it's better than buying:

  When PoPC activates after block 5,000, you can earn SOST for free just by holding tokenized gold in your own Ethereum wallet. No need to buy
  SOST at all. There are two models:

  Model A — Autocustody (recommended for crypto holders):
  You hold XAUT or PAXG in your own Ethereum wallet. You lock a SOST bond as commitment. Random audits verify your gold balance via Ethereum
  RPC. At the end of your commitment period, you get your bond back + a reward in SOST.

  Example: You hold 0.5 oz XAUT (~$2,350) in your wallet. You lock a SOST bond (25% of gold value). You commit for 6 months. If you maintain
  custody, you receive your bond back + up to 9% reward. Your gold never leaves your wallet.

  Model B — Escrow (simpler, no audits):
  You deposit XAUT or PAXG into an immutable escrow contract on Ethereum. You receive SOST immediately — no bond, no audits, no slash risk. At
  expiry, you withdraw 100% of your gold.

  Example: You deposit 0.5 oz XAUT into escrow for 6 months. You receive up to 3.5% of gold value in SOST immediately. After 6 months, you
  withdraw your full 0.5 oz XAUT. You keep the SOST.

 Reward rates (Tier 1 — first 25 participants get maximum rates):

  Model A (% of bond, fee 3%):
  1mo: 1% | 3mo: 4% | 6mo: 9% | 9mo: 14% | 12mo: 20%

  Model B (% of gold value, fee 8%):
  1mo: 0.4% | 3mo: 1.5% | 6mo: 3.5% | 9mo: 5.5% | 12mo: 8%

  PoPC Reward Example — Live prices (April 13, 2026)
  XAUT: $4,702.75/oz | SOST reference: $0.17 (PoPC reference, not market price)

  Model A — Autocustody (your gold never moves, fee 3%)
  Bond required: 6,916 SOST ($1,175)

  
DurationNet RewardUSD valueReturn on gold
1 month67 SOST$110.24%
3 months268 SOST$460.97%
6 months604 SOST$1032.18%
9 months939 SOST$1603.40%
12 months1,342 SOST$2284.85%

  Result: bond returned (6,916) + reward (1,342) = 8,257 SOST. Your gold stays in your wallet untouched.

  Model B — Escrow (no SOST needed, fee 8%)
  No bond. SOST paid immediately at deposit.

  
DurationNet RewardUSD valueReturn on gold
1 month102 SOST$170.37%
3 months382 SOST$651.38%
6 months891 SOST$1513.22%
9 months1,400 SOST$2385.06%
12 months2,036 SOST$3467.36%

  Result: 2,036 SOST received on day 1 + your gold returned 100% at expiry.

  Which is better?
  
  • Model A: You need SOST for the bond, 4.85% return on gold, your gold never moves, risk of slash if you sell gold during
      commitment
  • Model B: No SOST needed, 7.36% return on gold paid immediately, but your gold is locked in escrow until expiry

  All values use PoPC reference price ($0.17/SOST) — illustrative only, not a market price. Rates shown are Tier 1 maximums (first
  25 participants).

  Rates decrease automatically as more participants join (6 dynamic tiers). Hard cap: 1,000 SOST max per contract. Full details:
  sostcore.com/sost-popc.html and sostprotocol.com/sost-popc.html  

  


 cASERT V4 — Planned Improvement (coming soon)
  

  

  Current status: The chain is running and the average block time is stabilizing around the 10-minute target. However, block
  production shows sharp oscillations — periods of very slow blocks (30-60 min at high profiles) followed by bursts of fast blocks
  (1-2 min) when the profile drops. This pattern reduces as the chain lag decreases, but it reveals a structural coordination issue
  between the two difficulty controllers.

  The problem:
  cASERT has two independent difficulty controllers:

  
  • bitsQ — the numerical difficulty (slow, strategic, adjusts every block based on timing)
  • Equalizer — the computational difficulty via 17 profiles E4-H12 (fast, tactical, PID-controlled)

  When the chain is ahead of schedule, the equalizer correctly raises the profile to H8-H12 to slow block production. But the slow
  blocks that result cause bitsQ to drop — interpreting the slow block as a signal to reduce difficulty. When the anti-stall
  eventually lowers the profile, bitsQ is already too low, and blocks come out extremely fast — undoing much of the correction.

  In short: the equalizer brakes, but bitsQ releases the brake too early.

  The solution — V4 Ahead Guard:
  V4 will introduce a coordination layer between bitsQ and the equalizer. When the chain is materially ahead of schedule (≥16 blocks),
   bitsQ will be prevented from lowering difficulty aggressively. This ensures both controllers work together instead of against each
  other.

  Key design:
  
  • Enter AHEAD_CORRECTION mode when ahead ≥ 16 blocks
  • Exit when ahead ≤ 8 blocks (hysteresis prevents oscillation)
  • While active: bitsQ downward adjustment is clamped to a minimal value
  • The equalizer, anti-stall, PID signals, and profile table remain unchanged

  Timeline: V4 will be implemented after the chain stabilizes under V3.1 (1-2 days of observation). We want to do one clean,
   well-tested fork
rather than rushing multiple small changes.

  We will announce the exact activation block with sufficient advance notice. As always: git pull, rebuild, restart.

  Why not now? The chain is currently absorbing V3.1 changes. Adding another consensus change while miners are still updating
  would create unnecessary confusion. V3.1 is already reducing the lag (from 67 to 30 blocks ahead). We want clean data before making
  the next move.

  

cASERT V4 — Ahead Guard Coordination Fix (Scheduled)



Overview

The network is currently operating correctly and the average block time is converging toward the 10-minute target. However, during recent observation, block production has shown a clear pattern of oscillation:

  • Periods of very slow blocks (high equalizer profiles H10–H12)
  • Followed by bursts of very fast blocks (1–2 minutes)

This behavior becomes more visible when the chain is significantly ahead of schedule.

Root cause

cASERT currently uses two coordinated but independent difficulty controllers:

  • bitsQ — numerical difficulty (slow, timing-based)
  • Equalizer — computational difficulty via 17 profiles (E4–H12, PID-controlled)

When the chain is ahead:

  • The equalizer correctly raises the profile (H8–H12) to slow down block production
  • Blocks take longer, as expected
  • However, bitsQ interprets the slow block as a signal to reduce difficulty

When the equalizer later drops (anti-stall or normalization), bitsQ is already too low, resulting in very fast blocks that undo part of the correction.

In short: the equalizer applies the brake, but bitsQ releases it too early.



The solution — cASERT V4

V4 introduces a coordination mechanism between bitsQ and the equalizer: the Ahead Guard.

Key idea:
While the chain remains materially ahead of schedule, bitsQ will no longer be allowed to relax difficulty aggressively.

New behavior

  • Enter AHEAD_CORRECTION mode when the chain is ≥16 blocks ahead
  • Exit when the chain returns to ≤8 blocks ahead (hysteresis prevents oscillation)
  • While active: bitsQ downward adjustment is strongly limited
  • bitsQ can still increase difficulty normally
  • Equalizer, PID controller, profiles, and anti-stall remain unchanged

Effect

Instead of this pattern:
Code:
slow block → bitsQ drops → profile drops → very fast blocks → ahead again

We get:
Code:
slow block → bitsQ holds → profile drops → normal blocks → convergence to schedule

Analogy:  
Previously, the system was pressing the brake and the accelerator at the same time.  
With V4, when braking is active, the accelerator is no longer released prematurely.



Implementation details

  • Activation block: 4200
  • Ahead threshold (enter): ≥16 blocks
  • Exit threshold: ≤8 blocks
  • bitsQ downward adjustment cap during ahead correction: ~1.56% per block (previously up to 12.5%)
  • Upward adjustments: unchanged

No changes are made to:
  • Equalizer profile table (E4–H12)
  • PID controller signals
  • Anti-stall logic
  • Emission or consensus structure



Why this requires a hard fork

This change modifies the consensus-level difficulty calculation (bitsQ).  
All nodes must compute the same difficulty to validate blocks.

Therefore:
  • All node operators and miners must update before activation
  • Nodes that do not update will stop syncing at the fork point



Deployment approach

The change has been implemented and committed, but activation is intentionally delayed.

This allows:
  • Observation of V3.1 behavior under real conditions
  • Collection of clean data before activation
  • Avoiding rapid successive forks

The goal is to perform one clean, well-tested correction, rather than multiple incremental changes.



Current status

The chain is already showing improvement under V3.1, with the lead decreasing.

V4 is designed as a targeted fix for the remaining coordination issue and is expected to significantly reduce oscillations and improve convergence toward expected block height.



A note to miners and testers

SOST is a completely new proof-of-work protocol. ConvergenceX, cASERT, the 17-profile equalizer, and the multi-signal control system are being validated under real multi-miner conditions.

Some behaviors only emerge under live operation — not in simulation.

Each iteration improves the system's robustness. We are building transparently, in public, and we appreciate the patience and collaboration of everyone participating in testing.

This is what a serious pre-launch phase looks like.



NeoB — SOST Protocol
sostcore.com ·
GitHub ·
Explorer
vostokzyf
Newbie
*
Offline Offline

Activity: 10
Merit: 0


View Profile
April 13, 2026, 12:23:07 PM
 #69

Has the block been stuck for a long time? There's no sign of it moving right now.
Neob1844 (OP)
Newbie
*
Offline Offline

Activity: 28
Merit: 0


View Profile
April 13, 2026, 08:17:25 PM
Last edit: April 18, 2026, 09:01:57 PM by Welsh
 #70

Hi vostokzyf,

No worries — the chain is not stuck. What you are seeing is the anti-stall mechanism working as designed.

When the chain gets ahead of schedule (currently about 19 blocks ahead), the cASERT equalizer raises the profile to H12 to slow block production. At H12, blocks become intentionally much harder to find. After around 2 hours without a block, the anti-stall system activates and gradually lowers the profile — H12 → H11 → H10 → ... → B0. Each step is reduced every 10–20 minutes. Once the profile returns to a more mineable level (roughly H3–H4), blocks begin flowing again.

This is expected behavior while the chain corrects its lead over the expected schedule. The gap is already narrowing (it was 67 blocks ahead before, now it is around 19).

A further improvement is scheduled at block 4,200: cASERT V4 — Ahead Guard. This upgrade is designed to smooth out these oscillations by preventing the numerical difficulty (bitsQ) from dropping too quickly during long slow periods. After V4, block production should become more consistent.

Please make sure you are on the latest code: `git pull`, rebuild, and restart both the node and the miner.



  🚨 cASERT V4 — Hard fork ACTIVE as of block 4,170 🚨

  V4 HAS ACTIVATED AT BLOCK 4,170. ALL NODES AND MINERS STILL RUNNING V3.1 CODE MUST UPDATE IMMEDIATELY — YOUR BLOCKS
  ARE ALREADY BEING REJECTED BY THE NETWORK.


  

  Why this is urgent

  In the last hours you may have noticed the B0 ↔ H12 oscillation loop: blocks alternating between 37-second bursts and 2-hour
   waits. The chain was effectively stalled at blocks 4,150–4,166 while we diagnosed it. We traced the root cause to a latent bug in
  the V3.1 slew-rate implementation. V4 fixed it and activated cleanly at block 4,170.

  V4 is now live and the chain is advancing normally under the new rules — no more oscillation. Nodes and miners still running old
  code have already been ejected from consensus and are stuck at blocks 4,166–4,167. If that is you, update now to rejoin the network.

  

  The bug

  V3.1 introduced a ±3 per-block slew rate on the equalizer profile. In theory, a jump like B0 → H12 in a single block was impossible.
   In practice, the slew rate was silently disabling itself every time a block was mined at B0.

  Root cause: BlockMeta::profile_index defaulted to 0. The slew-rate code could not distinguish a block legitimately
   mined at B0 (profile_index = 0) from a block whose profile_index was never persisted (also 0). Every legit B0 block was misread as
  "missing", the slew rate fell through to a fallback that disabled itself for that transition, and the next block was free to jump
  directly to H12.

  This is exactly the pattern you saw in the explorer:

  
Code:
B0 block mined → next block: slew disabled → jumps to H12
  H12 → 2h wait → anti-stall drops back to B0 → repeat

  Every cycle took roughly two hours and produced one or two blocks. That is why the chain appeared stuck.

  

  The fix (V4)

  
  • Explicit sentinel. BlockMeta::profile_index now defaults to INT32_MIN. A legit B0 (stored as
      0) is no longer confusable with "missing".
  • Persistence. profile_index is now stored per block in chain.json and carried through every code path
      that builds the chain view for cASERT, including load, P2P relay, and reorg.
  • Fallback removed. The V3.1 prev_H = H escape hatch is deleted entirely. The ±3 slew rate is now unconditional at
       heights ≥ 4,170.
  • Ahead Guard retained. The originally-announced V4 feature — bitsQ downward clamp to ~1.56%/block while the chain is ≥16
      ahead — is included unchanged.
  • Backwards compatibility (transition only). V4 nodes accepted legacy blocks (without profile_index) at heights
      4,100–4,169 with a B0 default so the network could catch up before activation. As of block 4,170 the field is mandatory and is
      being enforced now.

  

  Update procedure — DO THIS NOW

  
Code:
cd ~/sost-core
  git pull origin main
  cmake --build build -j$(nproc)

  # Restart the service — picks up the new binary
  sudo systemctl restart sost-node
  # (if you launch sost-node manually, stop and relaunch it)

  # Restart your miner
  pkill -x sost-miner
  # relaunch your miner

  Verify you are on the V4 code:

  
Code:
git log --oneline -1
  # Must show: a06c988 or later

  # Confirm the running binary matches the rebuilt one
  md5sum build/sost-node
  md5sum /proc/$(pgrep -x sost-node)/exe
  # Both hashes must be identical

  If your chain.json is in a bad state after the oscillation:

  
Code:
curl -o chain.json https://sostcore.com/bootstrap-chain.json
  # then restart sost-node

  

  Activation parameters

  
ParameterValue
CASERT_V4_FORK_HEIGHT4,170 (ACTIVE)
Transition windowblocks 4,100–4,169 (profile_index optional, defaults to B0)
CASERT_AHEAD_ENTER16 blocks ahead
CASERT_AHEAD_EXIT8 blocks ahead (hysteresis)
Ahead Guard bitsQ cap~1.56% max downward per block
Slew rate (post-V4)±3 profile levels per block, unconditional

  Unchanged: equalizer profile table (E4–H12), PID gains, anti-stall logic, emission schedule, block structure.

  

  A note to miners and testers

  SOST is a brand-new proof-of-work protocol. ConvergenceX, cASERT, the 17-profile equalizer, and the multi-signal control system are
  being validated for the first time under real multi-miner conditions. The slew-rate bug described above only became visible after
  multiple miners were active simultaneously — no simulation caught it, because simulations ran single-node chains where every block
  happened to be at a non-B0 profile.

  Each iteration makes the system more robust. Thank you for your patience while we updated — your logs and mining activity made this
  diagnosable.

  Reminder: the chain has split at block 4,170. Nodes and miners that have not yet updated are unable to submit or
  validate new blocks past that height. Update now to rejoin.


  

  NeoB — SOST Protocol

🚨 cASERT V5 — URGENT HARD FORK AT BLOCK 4,300 🚨



IMPORTANT — activation accelerated from 4,350 to 4,300.

All nodes and miners must update BEFORE block 4,300 or their blocks will be rejected from that height onwards.



I sincerely apologize for requesting another consensus update so soon after V4. Each hard fork imposes real cost on miner operations and I understand that cost.

I am taking this fork only because live monitor data confirmed that the B0 → H12 overshoot loop would otherwise keep repeating every ~19–35 blocks indefinitely. Postponing further would have caused progressively worse liveness incidents.

Thank you for your patience.

I expect V5 to resolve the currently observed overshoot and stuck-chain behavior and to bring cASERT much closer to its intended stable form, although no protocol change can ever be guaranteed to solve every edge case with 100% certainty in advance.


Why this was accelerated

Over the last 12 hours, a dedicated monitoring tool has been tracking live network behavior under V4 rules. The data is now unambiguous:

  • 4 confirmed overshoot events in a 97-block observation window
  • 4 blocks over 40 minutes (including one stuck for 155 minutes and another for 151 minutes)
  • Pattern repeats every ~19–35 blocks — each cycle: B0 → H6 → H9 → H12 → long stall → anti-stall → B0 → repeat
  • Monitor traffic light: RED

At the time of this post, the chain has again shown the same failure mode: it falls behind schedule while the equalizer is still holding an excessively hard profile. Waiting until block 4,350 would likely allow several more repetitions of the same loop.

That is why activation has been pulled forward to block 4,300.



What V5 fixes (five consensus changes, one fork)

V5 is a coordinated liveness + determinism fix.  
It is not a redesign of SOST, ConvergenceX, or cASERT. It is a targeted correction of the exact live failure pattern now observed on-chain.



1. Ahead Guard becomes STATELESS

Problem:  
V4 introduced an Ahead Guard using a persistent static bool flag to remember whether the chain was in ahead-correction mode.

That is undesirable in consensus-critical code because consensus logic must be a pure function of chain data, not of local process memory. Under edge cases such as restarts, reorgs, or different sync paths, persistent local state can become a latent determinism risk.

V4-style logic:
Code:
static bool ahead_correction_mode = false;
if (schedule_lag >= 16) ahead_correction_mode = true;
if (schedule_lag <= 8)  ahead_correction_mode = false;
if (ahead_correction_mode) { clamp bitsQ; }

V5 logic:
Code:
if (schedule_lag >= 16) {
    clamp bitsQ;
}

Effect:
  • No persistent local flag
  • No hidden execution-state dependence
  • Consensus behavior derived only from current chain state

This risk has not been observed causing divergence so far, but it is a must-fix.



2. Safety rule 1 is re-applied AFTER slew rate

Problem:  
Before V5, the rule:

Code:
if (lag <= 0) H = min(H, 0);

was applied before slew rate limiting. That allowed the slew logic to partially override it.

Example:
  • chain already behind schedule
  • previous profile still very high (H12 / H9)
  • slew rate keeps profile partially hardened for several more blocks

That is exactly what caused the observed overshoot pattern where the chain was already behind but still trapped in hardening profiles.

V5 fix:
Code:
if (next_height >= CASERT_V5_FORK_HEIGHT) {
    if (lag <= 0) {
        H = std::min<int32_t>(H, 0);
    }
}

Effect:
  • If the chain is behind or on schedule, hardening is immediately capped back to baseline or easier
  • No more multi-block descent through H9/H6/H3 while the chain is already behind
  • This directly fixes the "stuck while behind" behavior



3. Emergency Behind Release (EBR)

Problem:  
There was already a strong mechanism for the ahead side of the controller (lag floor upward), but no equivalent hard release for the behind side in severe cases.

V5 adds a stateless cliff-based emergency release:

LagApprox. delayEBR forces H to
-10 to -14100–140 min behindB0 (0)
-15 to -19150–190 min behindE2 (-2)
-20 to -24200–240 min behindE3 (-3)
≤ -25≥ 250 min behindE4 (-4)

Code:
if (lag <= CASERT_EBR_ENTER) {  // -10
    int32_t ebr_floor;
    if      (lag <= -25) ebr_floor = CASERT_H_MIN;  // E4
    else if (lag <= -20) ebr_floor = -3;            // E3
    else if (lag <= -15) ebr_floor = -2;            // E2
    else                 ebr_floor =  0;            // B0
    H = std::min<int32_t>(H, ebr_floor);
}

Effect:
  • Stateless and deterministic
  • Only triggers under material lag, not normal variance
  • Provides emergency easing when the chain has fallen significantly behind



4. Anti-stall floor reduced from 2h to 60 min

Problem:  
Under V4, anti-stall only began active rescue after 7200 seconds (2 hours). In a small live network, that is too slow once the equalizer has overshot into the extreme range.

V5 changes:
Code:
int64_t t_act = (next_height >= CASERT_V5_FORK_HEIGHT)
    ? CASERT_ANTISTALL_FLOOR_V5   // 3600s = 60 min
    : CASERT_ANTISTALL_FLOOR;     // 7200s = 2 hours

Effect:
  • The safety net activates much earlier
  • Faster rescue if block production stalls again under extreme profiles
  • Works as a secondary protection on top of safety post-slew and EBR



5. Extreme profile entry cap (H10, H11, H12 = +1 per block)

This is the root fix for the observed overshoot loop.

Problem:  
The strongest brakes in the 17-profile table are:

  • H10 = ~15% stability
  • H11 = ~8% stability
  • H12 = ~3% stability

Before V5, the combination of lag floor + slew rate could push the chain into this extreme range too abruptly.

Observed real pattern:
Code:
B0 -> H6 -> H9 -> H12 -> long stall

That means the controller could effectively collapse mining stability from 100% to 3% in only a few blocks, and then block production would freeze.

V5 fix:
Code:
if (H >= CASERT_V5_EXTREME_MIN && H > prev_H + 1) {
    H = prev_H + 1;
}

Where:
  • CASERT_V5_EXTREME_MIN = 10
  • H10 is the first capped profile

New behavior:
  • H9 → H10 (allowed)
  • H10 → H11 (allowed)
  • H11 → H12 (allowed)
  • But no direct jump deeper into the extreme range than +1/block

Why this matters:  
Those extra 2–3 intermediate blocks at H10/H11 are still mineable. The chain keeps producing blocks, lag can begin self-correcting, and in many cases H12 will never be needed at all.

Important: this cap applies only to entry into the extreme range.  
Descent is unrestricted. That asymmetry is intentional:

  • slow brake entry
  • fast brake exit



What V5 does NOT change

  • ConvergenceX proof-of-work design
  • The 17-profile equalizer table (E4–H12)
  • PID weights, burst/volatility signals
  • bitsQ half-life and global cap
  • Emission rules, coinbase split, and economic structure

V5 is a liveness + determinism fix. It is not a redesign.



Update procedure — DO THIS NOW

Code:
cd ~/sost-core
git pull origin main
cmake --build build -j$(nproc)

# Kill and restart the node (rebuild alone is not enough)
sudo systemctl restart sost-node
# or if you launch manually: pkill -x sost-node && relaunch

# Restart your miner
pkill -x sost-miner
# relaunch with your usual command

Verify you are on V5 code:

Code:
git log --oneline -1
# Must show the V5 activation update commit
# (or a later commit)

# Confirm the running binary matches the rebuilt one
md5sum build/sost-node
md5sum /proc/$(pgrep -x sost-node)/exe
# Both hashes must be identical

If your chain.json is in a bad state after the oscillation:

Code:
curl -o chain.json https://sostcore.com/bootstrap-chain.json
# then restart sost-node



Activation parameters

ParameterValue
CASERT_V5_FORK_HEIGHT4,300
CASERT_ANTISTALL_FLOOR_V53600 s (60 min)
CASERT_EBR_ENTER-10 (100 min behind)
CASERT_EBR_LEVEL_E2 / E3 / E4-15 / -20 / -25
CASERT_V5_EXTREME_MINH10 (first capped profile)
Slew rate below H10±3 profile levels per block (unchanged)
Slew rate into H10++1 profile level per block (new)



Observation data (for transparency)

The V5 decision was not a guess. It was data-driven.

The monitoring tool (scripts/v31_monitor.py, already pushed to main) tracks:

  • overshoot events
  • time in H12
  • blocks above 20 / 40 minutes
  • lag extremes

Decision thresholds were defined before observation began:

  • Green = 0 overshoots, 0 blocks > 40min, time in H12 < 30min
  • Yellow = 1 overshoot OR 1 block > 40min OR time in H12 30min–2h
  • Red = ≥2 overshoots OR ≥3 blocks > 40min OR time in H12 ≥ 2h

Observed reading:

Code:
Window 4170-4234 (97 blocks)
  Overshoots:              4    RED
  Blocks > 20min:          4
  Blocks > 40min:          4    RED
  Time in H12:            24m 54s
  Max lag in window:      +3
  Min lag in window:     -13
  Avg block interval:     7m 46s
  Decision: RED

Four full cycles of the same stuck-chain pattern were observed in less than 100 blocks.

V5 is the coordinated fix.



A note to miners and testers

SOST is a brand-new proof-of-work protocol. ConvergenceX, cASERT, the 17-profile equalizer, and the multi-signal control system are being validated under real multi-miner conditions for the first time.

The overshoot pattern that V5 fixes only became visible with multiple independent miners participating live. That is exactly why this pre-market phase exists.

Each iteration makes the system stronger. Thank you for mining through the rough patch — your logs and live participation made this diagnosable and fixable in hours instead of weeks.

Reminder: the chain will split at block 4,300. Nodes and miners that have not updated by then will be unable to submit or validate blocks past that height.



NeoB — SOST Protocol
sostcore.com ·
GitHub ·
Explorer
oswaldzc
Newbie
*
Offline Offline

Activity: 13
Merit: 0


View Profile
April 14, 2026, 05:52:25 AM
 #71

Am I on a fork locally?

Node logs are as follows:
[BLOCK-VALIDATE] h=4231 declared_pi=0 base_profile=0 lag=0 last_stored_pi=0
[BLOCK] CX Transcript V2 verified
[BLOCK] Height 4231 accepted: 16ceb16e633695f0 (txs=1, fees=0, UTXOs=12657, chainwork=0x12d0547)
[SUBMITBLOCK] ACCEPTED
[SUBMITBLOCK] Received block submission (params=1)
[BLOCK-VALIDATE] h=4232 declared_pi=3 base_profile=3 lag=1 last_stored_pi=0
[BLOCK] CX Transcript V2 verified
[BLOCK] Height 4232 accepted: 801f2ee5f8df58b4 (txs=1, fees=0, UTXOs=12660, chainwork=0x12d122e)
[SUBMITBLOCK] ACCEPTED
[SUBMITBLOCK] Received block submission (params=1)
[BLOCK-VALIDATE] h=4233 declared_pi=6 base_profile=6 lag=1 last_stored_pi=3
[BLOCK] CX Transcript V2 verified
[BLOCK] Height 4233 accepted: 353a4b00d0b29b62 (txs=1, fees=0, UTXOs=12663, chainwork=0x12d1f86)
[SUBMITBLOCK] ACCEPTED
[SUBMITBLOCK] Received block submission (params=1)
[BLOCK-VALIDATE] h=4234 declared_pi=9 base_profile=9 lag=2 last_stored_pi=6
[BLOCK] CX Transcript V2 verified
[BLOCK] Height 4234 accepted: ae9e8f8bad9a15b1 (txs=1, fees=0, UTXOs=12666, chainwork=0x12d2d5d)
[SUBMITBLOCK] ACCEPTED

As I understand it, this block should have been discovered.
However, the explorer shows that the miner is not me.

HEIGHT   HASH   TXS   TIME   INTERVAL   DIFFICULTY   MINER   SUBSIDY
#4234   0b39575691···c41574   1   2h ago   ⏱ 6m 32s   11.799 773,289 H12   sost193856…675d   7.8510 SOST
#4233   b31662f261···ee9e1d   1   2h ago   ⏱ 14s   11.744 769,667 H9   sost19957a…391b   7.8510 SOST
#4232   58c782142f···c4715f   1   2h ago   ⏱ 39s   11.691 766,209 H6   sost15c4a0…451c   7.8510 SOST
#4231   72b5876ae6···cc6803   1   2h ago   ⏱ 30s   11.575 758,561 B0   sost15c4a0…451c   7.8510 SOST
#4230   f5c2953053···fadade   1   2h ago   ⏱ 47s   11.525 755,296 B0   sost15c4a0…451c   7.8510 SOST
#4229   cee579214b···0a85fd   1   2h ago   ⏱ 37s   11.474 751,983 B0   sost15c4a0…451c   7.8510 SOST
#4228   2bca9608bf···bfb3ad   1   2h ago   ⏱ 32s   11.423 748,647 B0   sost15c4a0…451c   7.8510 SOST
#4227   382541db0b···d640c7   1   2h ago   ⏱ 37s   11.373 745,364 B0   sost148772…ca8e   7.8510 SOST
#4226   2b06123791···cdee22   1   2h ago   ⏱ 44s   11.324 742,139 B0   sost148772…ca8e   7.8510 SOST
#4225   baeaf1ecc4···0aa4e6   1   2h ago   ⏱ 1m 4s   11.277 739,031 B0   sost148772…ca8e   7.8510 SOST
Neob1844 (OP)
Newbie
*
Offline Offline

Activity: 28
Merit: 0


View Profile
April 14, 2026, 10:12:25 AM
 #72

 Hi oswaldzc,

  Yes, you are on a local fork — confirmed by comparing block hashes:

 
  • Your block #4234: ae9e8f8b...
  • Canonical chain #4234: 0b395756...

  Your node is validating and accepting its own blocks correctly (the
  BLOCK-VALIDATE logs look clean, profile/lag/commit all match), but
  the block sequence has diverged from the main chain. This is a
  P2P sync split, not a consensus bug — your node is fine, it just
  needs to re-sync from the canonical tip.

  To get back on the main chain:

 
Code:
# 1. Stop node and miner
  pkill -x sost-miner
  sudo systemctl stop sost-node       # or your manual stop command

  # 2. Pull the latest code (includes V5, currently tested at 73/73)
  cd ~/sost-core
  git pull origin main
  git log --oneline -1
  # Must show commit eacf7af or later (any commit since fb944b1
  # contains the full V5 code)

  # 3. Rebuild
  cmake --build build -j$(nproc)

  # 4. Download a fresh canonical chain and reset local state
  rm -rf blocks utxo ~/.sost
  curl -o chain.json https://sostcore.com/bootstrap-chain.json

  # 5. Restart with the fresh chain
  ./build/sost-node --genesis genesis_block.json --chain chain.json \
    --connect seed.sostcore.com:19333 \
    --rpc-user YOUR_USER --rpc-pass YOUR_PASS \
    --profile mainnet --p2p-enc off

  # 6. Once synced, restart your miner
 

  Verify you are on the canonical chain after sync:

 
Code:
curl -s --user YOUR_USER:YOUR_PASS \
    -d '{"method":"getblockcount","params":[],"id":1}' \
    http://127.0.0.1:18232
  # Compare the height + the last block hash with https://sostcore.com/sost-explorer.html
 

  Important — V5 hard fork activates at block 4,300: the update
  above already includes the V5 code, so once you sync you are ready
  for activation automatically. No separate step required.

  Post-sync, if you keep seeing forks, please share:
 
  • Output of md5sum build/sost-node
  • First 10 lines of journalctl -u sost-node -f after restart
  • Your peer list (getpeerinfo RPC result)

  Sorry for the trouble — the recent V3.1 → V4 transitions caused
  some nodes to drift, and V5 (coming at block 4,300) will close
  the final chapter of this cASERT tuning cycle.
colerus
Newbie
*
Offline Offline

Activity: 1
Merit: 0


View Profile
April 14, 2026, 07:14:35 PM
 #73

After update to the latest version, trying to do a new build, it throws errors:

Code:
FAILED: [code=1] CMakeFiles/test-checkpoints.dir/tests/test_checkpoints.cpp.obj
C:\msys64\mingw64\bin\c++.exe  -IC:/Projetos/sost-core-mingw/sost-core/include -std=gnu++17 -g -fstack-protector-strong -fstack-clash-protection -fPIE -Wformat -Wformat-security -MD -MT CMakeFiles/test-checkpoints.dir/tests/test_checkpoints.cpp.obj -MF CMakeFiles\test-checkpoints.dir\tests\test_checkpoints.cpp.obj.d -o CMakeFiles/test-checkpoints.dir/tests/test_checkpoints.cpp.obj -c C:/Projetos/sost-core-mingw/sost-core/tests/test_checkpoints.cpp
In file included from C:/msys64/mingw64/include/c++/15.2.0/cassert:46,
                 from C:/Projetos/sost-core-mingw/sost-core/tests/test_checkpoints.cpp:7:
C:/Projetos/sost-core-mingw/sost-core/tests/test_checkpoints.cpp: In function 'void test_consensus_params_unchanged()':
C:/Projetos/sost-core-mingw/sost-core/tests/test_checkpoints.cpp:103:18: error: 'CASERT_L2_BLOCKS' is not a member of 'sost'
  103 |     assert(sost::CASERT_L2_BLOCKS == 5);
      |                  ^~~~~~~~~~~~~~~~
C:/Projetos/sost-core-mingw/sost-core/tests/test_checkpoints.cpp:104:18: error: 'CASERT_L6_BLOCKS' is not a member of 'sost'
  104 |     assert(sost::CASERT_L6_BLOCKS == 101);
      |                  ^~~~~~~~~~~~~~~~

Code:
iuri@NOTEBOOK-IURI:~/coins/sost-core$ git log --oneline -1
6258222 (HEAD -> main, origin/main, origin/HEAD) Explorer: small V5 post-activation reminder strip

Code:
iuri@NOTEBOOK-IURI:~/coins/sost-core$ cmake --build test-build -j$(nproc)
[  1%] Building CXX object CMakeFiles/sost-core.dir/src/emission.cpp.o
[  2%] Building CXX object CMakeFiles/sost-core.dir/src/crypto.cpp.o
[  3%] Building CXX object CMakeFiles/sost-core.dir/src/subsidy.cpp.o
[  4%] Building CXX object CMakeFiles/sost-core.dir/src/pow/convergencex.cpp.o
[  5%] Building CXX object CMakeFiles/sost-core.dir/src/capsule.cpp.o
[  7%] Building CXX object CMakeFiles/sost-core.dir/src/tx_validation.cpp.o
[  7%] Building CXX object CMakeFiles/sost-core.dir/src/sostcompact.cpp.o
[  9%] Building CXX object CMakeFiles/sost-core.dir/src/pow/scratchpad.cpp.o
[  9%] Building CXX object CMakeFiles/sost-core.dir/src/pow/casert.cpp.o
[ 11%] Building CXX object CMakeFiles/sost-core.dir/src/transaction.cpp.o
[ 11%] Building CXX object CMakeFiles/sost-core.dir/src/tx_signer.cpp.o
[ 12%] Building CXX object CMakeFiles/sost-core.dir/src/utxo_set.cpp.o
[ 13%] Building CXX object CMakeFiles/sost-core.dir/src/block.cpp.o
/home/iuri/coins/sost-core/src/crypto.cpp: In function ‘sost::Bytes32 sost::sha256(const uint8_t*, size_t)’:
/home/iuri/coins/sost-core/src/crypto.cpp:9:32: warning: ‘int SHA256_Init(SHA256_CTX*)’ is deprecated: Since OpenSSL 3.0 [-Wdeprecated-declarations]
    9 |     SHA256_CTX ctx; SHA256_Init(&ctx);
      |                     ~~~~~~~~~~~^~~~~~
In file included from /home/iuri/coins/sost-core/src/crypto.cpp:4:
/usr/include/openssl/sha.h:73:27: note: declared here
   73 | OSSL_DEPRECATEDIN_3_0 int SHA256_Init(SHA256_CTX *c);
      |                           ^~~~~~~~~~~
/home/iuri/coins/sost-core/src/crypto.cpp:10:18: warning: ‘int SHA256_Update(SHA256_CTX*, const void*, size_t’ is deprecated: Since OpenSSL 3.0 [-Wdeprecated-declarations]
   10 |     SHA256_Update(&ctx, data, len);
      |     ~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~
/usr/include/openssl/sha.h:74:27: note: declared here
   74 | OSSL_DEPRECATEDIN_3_0 int SHA256_Update(SHA256_CTX *c,
      |                           ^~~~~~~~~~~~~
/home/iuri/coins/sost-core/src/crypto.cpp:11:17: warning: ‘int SHA256_Final(unsigned char*, SHA256_CTX*)’ is deprecated: Since OpenSSL 3.0 [-Wdeprecated-declarations]
   11 |     SHA256_Final(out.data(), &ctx);
      |     ~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~
/usr/include/openssl/sha.h:76:27: note: declared here
   76 | OSSL_DEPRECATEDIN_3_0 int SHA256_Final(unsigned char *md, SHA256_CTX *c);
      |                           ^~~~~~~~~~~~
[ 14%] Building CXX object CMakeFiles/sost-core.dir/src/merkle.cpp.o
/home/iuri/coins/sost-core/src/tx_signer.cpp: In function ‘sost::PubKeyHash sost::ComputePubKeyHash(const PubKey&)’:
/home/iuri/coins/sost-core/src/tx_signer.cpp:495:14: warning: ‘unsigned char* RIPEMD160(const unsigned char*, size_t, unsigned char*)’ is deprecated: Since OpenSSL 3.0 [-Wdeprecated-declarations]
  495 |     RIPEMD160(sha.data(), sha.size(), pkh.data());
      |     ~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from /home/iuri/coins/sost-core/src/tx_signer.cpp:28:
/usr/include/openssl/ripemd.h:49:38: note: declared here
   49 | OSSL_DEPRECATEDIN_3_0 unsigned char *RIPEMD160(const unsigned char *d, size_t n,
      |                                      ^~~~~~~~~
[ 15%] Building CXX object CMakeFiles/sost-core.dir/src/mempool.cpp.o
[ 16%] Building CXX object CMakeFiles/sost-core.dir/src/address.cpp.o
[ 17%] Building CXX object CMakeFiles/sost-core.dir/src/wallet.cpp.o
[ 18%] Building CXX object CMakeFiles/sost-core.dir/src/block_validation.cpp.o
/home/iuri/coins/sost-core/src/tx_signer.cpp: In lambda function:
/home/iuri/coins/sost-core/src/tx_signer.cpp:49:44: warning: ignoring return value of ‘int secp256k1_context_randomize(secp256k1_context*, const unsigned char*)’ declared with attribute ‘warn_unused_result’ [-Wunused-result]
   49 |                 secp256k1_context_randomize(c, seed);
      |                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~
[ 19%] Building CXX object CMakeFiles/sost-core.dir/src/addressbook.cpp.o
[ 20%] Building CXX object CMakeFiles/sost-core.dir/src/wallet_policy.cpp.o
[ 21%] Building CXX object CMakeFiles/sost-core.dir/src/hd_wallet.cpp.o
[ 22%] Building CXX object CMakeFiles/sost-core.dir/src/psbt.cpp.o
[ 23%] Building CXX object CMakeFiles/sost-core.dir/src/script.cpp.o
[ 24%] Building CXX object CMakeFiles/sost-core.dir/src/popc.cpp.o
[ 24%] Building CXX object CMakeFiles/sost-core.dir/src/popc_tx_builder.cpp.o
/home/iuri/coins/sost-core/src/script.cpp: In function ‘sost::PubKeyHash sost::hash160(const uint8_t*, size_t’:
/home/iuri/coins/sost-core/src/script.cpp:18:14: warning: ‘unsigned char* RIPEMD160(const unsigned char*, size_t, unsigned char*)’ is deprecated: Since OpenSSL 3.0 [-Wdeprecated-declarations]
   18 |     RIPEMD160(sha, 32, h.data());
      |     ~~~~~~~~~^~~~~~~~~~~~~~~~~~~
In file included from /home/iuri/coins/sost-core/src/script.cpp:4:
/usr/include/openssl/ripemd.h:49:38: note: declared here
   49 | OSSL_DEPRECATEDIN_3_0 unsigned char *RIPEMD160(const unsigned char *d, size_t n,
      |                                      ^~~~~~~~~
[ 25%] Building CXX object CMakeFiles/sost-core.dir/src/popc_model_b.cpp.o
/home/iuri/coins/sost-core/src/popc.cpp: In function ‘sost::Hash256 sost::compute_audit_seed(const Hash256&, const Hash256&, const Hash256&)’:
/home/iuri/coins/sost-core/src/popc.cpp:203:16: warning: ‘int SHA256_Init(SHA256_CTX*)’ is deprecated: Since OpenSSL 3.0 [-Wdeprecated-declarations]
  203 |     SHA256_Init(&ctx);
      |     ~~~~~~~~~~~^~~~~~
In file included from /home/iuri/coins/sost-core/src/popc.cpp:11:
/usr/include/openssl/sha.h:73:27: note: declared here
   73 | OSSL_DEPRECATEDIN_3_0 int SHA256_Init(SHA256_CTX *c);
      |                           ^~~~~~~~~~~
/home/iuri/coins/sost-core/src/popc.cpp:204:18: warning: ‘int SHA256_Update(SHA256_CTX*, const void*, size_t)’ is deprecated: Since OpenSSL 3.0 [-Wdeprecated-declarations]
  204 |     SHA256_Update(&ctx, buf, 96);
      |     ~~~~~~~~~~~~~^~~~~~~~~~~~~~~
/usr/include/openssl/sha.h:74:27: note: declared here
   74 | OSSL_DEPRECATEDIN_3_0 int SHA256_Update(SHA256_CTX *c,
      |                           ^~~~~~~~~~~~~
/home/iuri/coins/sost-core/src/popc.cpp:205:17: warning: ‘int SHA256_Final(unsigned char*, SHA256_CTX*)’ is deprecated: Since OpenSSL 3.0 [-Wdeprecated-declarations]
  205 |     SHA256_Final(out.data(), &ctx);
      |     ~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~
/usr/include/openssl/sha.h:76:27: note: declared here
   76 | OSSL_DEPRECATEDIN_3_0 int SHA256_Final(unsigned char *md, SHA256_CTX *c);
      |                           ^~~~~~~~~~~~
/home/iuri/coins/sost-core/src/popc.cpp: In function ‘bool sost::is_audit_triggered(const Hash256&, const Hash256&, uint16_t, uint16_t)’:
/home/iuri/coins/sost-core/src/popc.cpp:228:16: warning: ‘int SHA256_Init(SHA256_CTX*)’ is deprecated: Since OpenSSL 3.0 [-Wdeprecated-declarations]
  228 |     SHA256_Init(&ctx);
      |     ~~~~~~~~~~~^~~~~~
/usr/include/openssl/sha.h:73:27: note: declared here
   73 | OSSL_DEPRECATEDIN_3_0 int SHA256_Init(SHA256_CTX *c);
      |                           ^~~~~~~~~~~
/home/iuri/coins/sost-core/src/popc.cpp:229:18: warning: ‘int SHA256_Update(SHA256_CTX*, const void*, size_t)’ is deprecated: Since OpenSSL 3.0 [-Wdeprecated-declarations]
  229 |     SHA256_Update(&ctx, buf, 66);
      |     ~~~~~~~~~~~~~^~~~~~~~~~~~~~~
/usr/include/openssl/sha.h:74:27: note: declared here
   74 | OSSL_DEPRECATEDIN_3_0 int SHA256_Update(SHA256_CTX *c,
      |                           ^~~~~~~~~~~~~
/home/iuri/coins/sost-core/src/popc.cpp:230:17: warning: ‘int SHA256_Final(unsigned char*, SHA256_CTX*)’ is deprecated: Since OpenSSL 3.0 [-Wdeprecated-declarations]
  230 |     SHA256_Final(digest, &ctx);
      |     ~~~~~~~~~~~~^~~~~~~~~~~~~~
/usr/include/openssl/sha.h:76:27: note: declared here
   76 | OSSL_DEPRECATEDIN_3_0 int SHA256_Final(unsigned char *md, SHA256_CTX *c);
      |                           ^~~~~~~~~~~~
[ 26%] Linking CXX static library libsost-core.a
[ 26%] Built target sost-core
[ 28%] Building CXX object CMakeFiles/test-chunk2.dir/tests/test_chunk2.cpp.o
[ 28%] Building CXX object CMakeFiles/test-transaction.dir/tests/test_transaction.cpp.o
[ 30%] Building CXX object CMakeFiles/test-chunk1.dir/tests/test_chunk1.cpp.o
[ 30%] Building CXX object CMakeFiles/test-bond-lock.dir/tests/test_bond_lock.cpp.o
[ 31%] Building CXX object CMakeFiles/test-tx-signer.dir/tests/test_tx_signer.cpp.o
[ 32%] Building CXX object CMakeFiles/test-capsule.dir/tests/test_capsule_codec.cpp.o
[ 33%] Building CXX object CMakeFiles/test-mempool.dir/tests/test_mempool.cpp.o
[ 34%] Building CXX object CMakeFiles/test-tx-validation.dir/tests/test_tx_validation.cpp.o
[ 35%] Building CXX object CMakeFiles/test-casert.dir/tests/test_casert.cpp.o
[ 36%] Building CXX object CMakeFiles/test-utxo-set.dir/tests/test_utxo_set.cpp.o
[ 37%] Building CXX object CMakeFiles/test-merkle-block.dir/tests/test_merkle_block.cpp.o
[ 38%] Building CXX object CMakeFiles/test-checkpoints.dir/tests/test_checkpoints.cpp.o
In file included from /usr/include/c++/13/cassert:44,
                 from /home/iuri/coins/sost-core/tests/test_checkpoints.cpp:7:
/home/iuri/coins/sost-core/tests/test_checkpoints.cpp: In function ‘void test_consensus_params_unchanged()’:
/home/iuri/coins/sost-core/tests/test_checkpoints.cpp:103:18: error: ‘CASERT_L2_BLOCKS’ is not a member of ‘sost’
  103 |     assert(sost::CASERT_L2_BLOCKS == 5);
      |                  ^~~~~~~~~~~~~~~~
/home/iuri/coins/sost-core/tests/test_checkpoints.cpp:104:18: error: ‘CASERT_L6_BLOCKS’ is not a member of ‘sost’
  104 |     assert(sost::CASERT_L6_BLOCKS == 101);
      |                  ^~~~~~~~~~~~~~~~
gmake[2]: *** [CMakeFiles/test-checkpoints.dir/build.make:76: CMakeFiles/test-checkpoints.dir/tests/test_checkpoints.cpp.o] Error 1
gmake[1]: *** [CMakeFiles/Makefile2:471: CMakeFiles/test-checkpoints.dir/all] Error 2
gmake[1]: *** Waiting for unfinished jobs....
[ 39%] Linking CXX executable test-chunk1
[ 40%] Linking CXX executable test-chunk2
[ 41%] Linking CXX executable test-casert
[ 41%] Built target test-casert
[ 41%] Built target test-chunk1
[ 42%] Linking CXX executable test-tx-signer
[ 42%] Built target test-chunk2
[ 43%] Linking CXX executable test-merkle-block
[ 44%] Linking CXX executable test-transaction
[ 44%] Built target test-tx-signer
[ 45%] Linking CXX executable test-mempool
[ 46%] Linking CXX executable test-bond-lock
[ 47%] Linking CXX executable test-capsule
[ 48%] Linking CXX executable test-tx-validation
[ 48%] Built target test-transaction
[ 48%] Built target test-merkle-block
[ 49%] Linking CXX executable test-utxo-set
[ 49%] Built target test-mempool
[ 49%] Built target test-bond-lock
[ 49%] Built target test-capsule
[ 49%] Built target test-tx-validation
[ 49%] Built target test-utxo-set
gmake: *** [Makefile:101: all] Error 2
[/code]
Neob1844 (OP)
Newbie
*
Offline Offline

Activity: 28
Merit: 0


View Profile
April 14, 2026, 10:35:15 PM
Last edit: April 18, 2026, 09:06:13 PM by Welsh
 #74

Good catch, colerus — thanks a lot for the report. This was a stale
  test referencing constants removed when cASERT was unified to the
  E4–H12 profile system. Never failed on existing build dirs but broke
  every fresh clone.

  Fixed in commit 9c7e5c4 — pull and rebuild:

    git pull origin main
    cmake --build build -j$(nproc)

  The OpenSSL 3.0 deprecation warnings about SHA256_Init/RIPEMD160 are
  harmless noise; we'll migrate to EVP_* in a later cleanup pass. They
  don't affect consensus.

  As a thank-you for the clean repro, I'd like to send you a small
  amount of SOST — please share your address here in the thread or by
  private message and I'll push the tx. Thanks again.

 == Small fixes rolling out (no consensus change) ==

  Two display-layer fixes since the last ANN update, neither requires
  any miner action:

  1) Build fix (commit 9c7e5c4) — test_checkpoints.cpp referenced
     removed cASERT_L2/L6_BLOCKS constants, breaking every fresh clone.
     Reported by colerus, fixed.

  2) Explorer/getblock fix (commit a9dfec2) — the node's getblock RPC
     was recomputing profiles on the fly with a window that included
     the queried block itself, producing wrong casert_mode labels
     during stalls. Now returns the actual stored profile_index.

  Both are display-only. Pull and rebuild at your convenience:

    git pull origin main
    cmake --build build -j$(nproc)
    sudo systemctl restart sost-node

  The chain state is unchanged; only the labels the explorer reads
  via RPC are now accurate.
vostokzyf
Newbie
*
Offline Offline

Activity: 10
Merit: 0


View Profile
April 15, 2026, 03:00:06 AM
 #75

After pulling and recompiling, I still don’t see the sost-node service.
Neob1844 (OP)
Newbie
*
Offline Offline

Activity: 28
Merit: 0


View Profile
April 15, 2026, 07:27:34 AM
 #76

cASERT V5 — Technical Status Update

 

  Current state: V5 activated at block 4,300. After four forks in one week (V3, V3.1, V4, V5), the controller is producing a
  mean block time within ~3% of the 10-minute target in the observed window. The pre-V5 pathological loop B0 → H6 → H9 → H12 → long
   stall → repeat
is gone. The remaining distribution roughness appears to be dominated by low-hashrate variance rather than a
  structural controller defect.

 

  Data from the last 50 blocks post-V5

  Measured with scripts/casert_refiner.py --window=50:

 
Code:
    Avg block time:    9m 50s    (target 10m 00s, within 3%)
    Median interval:   51s
    P95 interval:      ~72m      (the outlier tail — see below)
    Lag range:         −4 .. +4 blocks
    Lag std dev:       2.18      (pre-V5 window showed ~29)
    Blocks at H10+:    0         (V5 extreme entry cap working)
    Time in H12:       0s        (pre-V5 window showed ~24 minutes)
    Overshoots:        0         (pre-V5 pattern eliminated)
 

  For context, the same metrics computed over a wider window that includes pre-V5 blocks showed lag std dev 29.44 and ~15 H10+
  entries. The improvement is an order of magnitude.

 

  What is still being observed

  Even with the improved averages, block production is still visually cyclical:

 
  • several short baseline blocks at B0 (intervals of 5–60 seconds)
  • progressive hardening B0 → H3 → H6 → H9 (slew rate ±3 per block)
  • one longer block (~70 minutes) at H9
  • return to baseline, cycle repeats

  Cycle length is ~8–10 blocks, ~75–90 minutes of wall clock per cycle. This is not the pre-V5 failure mode — the chain never
  reaches H10+ in stored values, the extreme cap is holding, and average time stays on target. It is the natural equilibrium of V5
  when real hashrate is low (~1.2K h/s observed).

  At that hashrate, block-time variance is intrinsically high, and the controller’s response to bursts of fast blocks necessarily
  escalates toward H9. A single variance draw then produces the long block that closes the cycle.

  This is not elegant, but at this network size it is the mathematically expected outcome, not a sign of miscalibration.

 

  Side fix: getblock RPC display bug

  While diagnosing post-V5 behavior, a separate non-consensus bug was found in the getblock endpoint (commit
  a9dfec2). The endpoint was recomputing casert_mode on the fly with an off-by-one
  window that included the queried block as its own predecessor. This leaked phantom profile labels into explorers — blocks sealed at
  H9 showed up as B0 during stall tails, and the "casert_mode" field was generally unreliable.

  Fix: the endpoint now returns the actual stored profile_index of each block, which is authoritative
  consensus data. A new casert_profile_index integer field is also exposed for tooling.

  Display-only change, no consensus impact. Node operators can pull and rebuild at their convenience to get accurate profile labels.

 

  Side fix: fresh-clone build breakage

  Reported by colerus (post #81 in this thread). tests/test_checkpoints.cpp asserted on
  CASERT_L2_BLOCKS and CASERT_L6_BLOCKS, constants removed during the cASERT profile
  unification months ago. Existing build directories kept working because the test was not re-running, but every fresh clone failed to
   compile test-checkpoints. Fixed in commit 9c7e5c4. Thanks to colerus for the clean
  repro report.

 

  Technical posture going forward

  No additional consensus changes at this time.

  The prudent next step is observation under a broader range of network conditions, which requires more hashrate and more independent
  miners. At ~1.2K h/s total, the controller is operating close to the noise floor of its own variance, and any tuning decisions made
  in this regime risk overfitting to low-hashrate artifacts.

  A future V6 would only be justified if, after the network grows, one or more of the following persists:

 
  • repeated very long blocks far outside variance bounds
  • sustained lag excursions not explained by hashrate fluctuations
  • evidence that the controller is systematically overreacting under normal operating conditions at higher hashrate

  Until that evidence exists, leaving consensus untouched is the correct engineering call.

 

  How to join mining

  CPU-only, 8 GB RAM minimum, no GPU/ASIC advantage by design. The fastest way to help stress-test cASERT is to bring more independent
   hashrate online.

 
Code:
  git clone https://github.com/Neob1844/sost-core
  cd sost-core
  cmake -B build -DCMAKE_BUILD_TYPE=Release
  cmake --build build -j$(nproc)

  ./build/sost-node \
    --connect seed.sostcore.com:19333 \
    --rpc-user YOUR_USER --rpc-pass YOUR_PASS \
    --profile mainnet

  ./build/sost-miner \
    --address YOUR_ADDRESS \
    --rpc 127.0.0.1:18232 --rpc-user YOUR_USER --rpc-pass YOUR_PASS \
    --blocks 999999 --profile mainnet --threads 4
 

  Full setup, troubleshooting and log-collection instructions: see post #80 in this thread.

 

  Relevant commits since V5

 
Code:
  94ad15d   HARD FORK V5 — activated at block 4,300 (2026-04-13)
  a9dfec2   fix: getblock returns stored profile_index
  9c7e5c4   fix: remove stale CASERT_L2/L6_BLOCKS asserts (fresh-clone build)
  f6bb142   Explorer: BLOCK PRODUCTION chart uses live lag
  0ab7e23   Explorer: unify chainSec formula (coherent chain/wall/offset)
  b8e09a7   Explorer: TIME OFFSET uses live formula
  bc82c38   Explorer: Chain Timing panel uses LIVE wall-clock lag
  615179d   Explorer: TIME OFFSET now moves — use real last-block time
 

  All on main, no breaking changes, no consensus changes beyond V5 itself.

 

  Bottom line

 
  • V5 is working correctly and materially improved the network
  • Mean block time is within 3% of the 10-minute design target
  • Remaining cyclic variance is most likely a low-hashrate effect, not a control defect
  • No additional fork should be considered until more hashrate and more independent miners are present
  • The two side fixes (getblock display, build) are display/tooling only

  Next stage: observation, measurement, and network growth. Not another immediate consensus change.

 

 
NeoB — SOST Protocol
  sostcore.com ·
  GitHub ·
  Explorer
Neob1844 (OP)
Newbie
*
Offline Offline

Activity: 28
Merit: 0


View Profile
April 15, 2026, 07:38:43 AM
 #77

Good point vostokzyf — sorry for the confusion. `sost-node` is NOT
  installed as a systemd service by default; it's just a binary you
  run directly. The `sudo systemctl restart sost-node` line in my
  previous post only applies if you set up your own systemd unit.

  After rebuilding, restart the node the same way you started it.
  If you launched it from a terminal, stop it (Ctrl+C or `kill <pid>`)
  and run it again:

    cd ~/sost-core
    ./build/sost-node \
      --connect seed.sostcore.com:19333 \
      --rpc-user YOUR_USER --rpc-pass YOUR_PASS \
      --profile mainnet

  If you want it to run in the background and survive terminal closes,
  the simplest option is nohup or screen/tmux:

    nohup ./build/sost-node ... > node.log 2>&1 &

  Optional — if you want an actual systemd service, create
  /etc/systemd/system/sost-node.service with something like:

    [Unit]
    Description=SOST Node
    After=network.target

    [Service]
    Type=simple
    User=YOUR_USER
    WorkingDirectory=/home/YOUR_USER/sost-core
    ExecStart=/home/YOUR_USER/sost-core/build/sost-node \
      --connect seed.sostcore.com:19333 \
      --rpc-user YOUR_USER --rpc-pass YOUR_PASS \
      --profile mainnet
    Restart=on-failure

    [Install]
    WantedBy=multi-user.target

  Then:
    sudo systemctl daemon-reload
    sudo systemctl enable sost-node
    sudo systemctl start sost-node

  From that point onwards `sudo systemctl restart sost-node` works.

  Neither approach affects consensus — just convenience for keeping
  the node running. Which one are you using? I can give more specific
  instructions if you tell me how you currently launch it.
vostokzyf
Newbie
*
Offline Offline

Activity: 10
Merit: 0


View Profile
April 15, 2026, 12:17:13 PM
 #78

I prefer to run commands manually and keep it running in the background with screen.
Neob1844 (OP)
Newbie
*
Offline Offline

Activity: 28
Merit: 0


View Profile
April 15, 2026, 01:05:27 PM
 #79

 Perfect choice;  screen is rock-solid for this. Here's the exact
  workflow you need:

  Start the node inside a named screen session:

    cd ~/sost-core
    screen -S sost-node
    ./build/sost-node \
      --connect seed.sostcore.com:19333 \
      --rpc-user YOUR_USER --rpc-pass YOUR_PASS \
      --profile mainnet

  Detach (leave it running in background) with:
    Ctrl+A then D

  Reattach later to check logs or stop it:
    screen -r sost-node

  List all running screens:
    screen -ls

  Kill the node cleanly (from inside the screen):
    Ctrl+C

  For the miner, same pattern in a separate screen session so you can
  watch mining logs independently:

    screen -S sost-miner
    ./build/sost-miner --address YOUR_ADDRESS \
      --rpc 127.0.0.1:18232 --rpc-user YOUR_USER --rpc-pass YOUR_PASS \
      --blocks 999999 --profile mainnet --threads 4
    (Ctrl+A then D to detach)

  One small tip: if you reboot the server, screen sessions die. If you
  need survival-across-reboot, you'd want either systemd (heavier) or a
  simple cron @reboot line:

    crontab -e
    @reboot cd /home/YOU/sost-core && screen -dmS sost-node ./build/sost-node ...

  Please, let me know if anything else breaks.
Neob1844 (OP)
Newbie
*
Offline Offline

Activity: 28
Merit: 0


View Profile
April 15, 2026, 01:15:10 PM
Last edit: April 17, 2026, 07:34:10 PM by Neob1844
 #80

 
SOST Protocol — VT Governance / PoPC / Escrow Activation
  PoPC (Proof of Personal Custody) operational launch, Gold Vault governance & Model B escrow: block 10,000
  Original target was block 5,000. After the internal audit, these mechanisms were moved to block 10,000 for full integration and validation. The chain-stability-only V6 fork is now separated and
  activates earlier at block 5,000.

 

  TL;DR — 6 lines

 
  • VT activation at block 10,000. This is the governance / custody / PoPC activation fork.
  • Gold Vault governance becomes consensus-enforced from block 10,000. The vault is protected by five independent consensus-level defenses. The protocol developer loses executive vault control at
      the same block.
  • Signature-bound Proof of Work is included in the block 10,000 activation package, making conventional mining pools structurally incompatible with SOST consensus. Solo and P2Pool-style cooperative
       mining remain unaffected.
  • PoPC Model A operational launch begins at block 10,000 — Tier 1 (100% multiplier) for the first 25 contracts. Hold tokenized gold in your own wallet, earn SOST. The gold never leaves the holder's
       wallet.
  • PoPC Model B escrow contract written, audited for 10 attack vectors, and published in the repository (contracts/SOSTEscrow.sol). Immutable timelock escrow for XAUT/PAXG on Ethereum — no
      admin key, no upgrade proxy, no pause function, no emergency withdrawal. Deployment to Ethereum mainnet is scheduled after Sepolia testnet validation.
  • Honest audit disclosure: GV1-GV4 rules were unit-tested but were never fully wired into production validation. That integration ships properly at block 10,000.

 

  Status of the chain

  The SOST Protocol is alive, mined by ~26 independent participants, and accumulating its constitutional 25% Gold Vault and 25% PoPC Pool allocations every block since genesis (March 15, 2026). The chain
  is healthy.


  The V6 chain-stability fork (CASERT equalizer slew rate ±3 → ±1) activates at block 5,000. The chain-stability improvement was validated across 4,350+ simulation runs covering all 17 profiles (E4 through
  H12), multiple variance levels, stall injection, and shock scenarios. Results: std dev −48%, sawtooth −99.9%, mean block time unchanged, E-profile recovery marginally slower but within acceptable bounds.

  The larger governance / custody / PoPC package activates later at block 10,000:

 
  • PoPC operational launch (Model A registration + reward payout)
  • PoPC Model B escrow contract (Ethereum, pending Sepolia validation)
  • Gold Vault governance rules (GV1-GV4 spending control, 5-defense model)
  • Bond / Escrow lock output types
  • Capsule activation
  • Signature-bound Proof of Work (anti-pool)

  This post covers the block 10,000 activation package.

 

  What the audit found

  The Gold Vault governance system (rules GV1 through GV4 — gold purchases, monthly operational limits, miner-voted approvals, automatic rejection) was designed and unit-tested (17/17 tests passing in
  tests/test_gold_vault.cpp), but the validator wiring connecting it to the live transaction pipeline was never completed. In practical terms: at block 5,000 the old activation would have
  triggered nothing, because the rules engine sat in the codebase as a library with no production caller.

  This was found by reading the source code line by line, the same way the project asks others to verify its claims. The honest sequence of events is straightforward: the rules logic was written first, the
  wiring was deferred, and that deferral had to be corrected properly before activation.

  The audit also found that the version-bit signaling RPC (getproposals) was returning placeholder data instead of reading actual block versions from the chain.

  What this means in practice today: the Gold Vault and PoPC Pool addresses have been accumulating their 25% allocations since genesis, exactly as the whitepaper specifies. That part is enforced at the
   deepest consensus level — every node rejects a block whose coinbase does not pay those allocations correctly. The accumulation is real and verifiable.

  What is not yet fully enforced by consensus is the spending governance of those balances. Until the block 10,000 activation, the Gold Vault remains under developer custody (the single
  person maintaining the SOST codebase). The custody arrangement is at the developer's operational discretion and is intentionally not detailed publicly — disclosing operational security details creates
  attack surface, not transparency. After block 10,000, the protocol itself enforces the spending logic via on-chain miner governance, and the developer loses executive control of the vault. The transition is
   direct from developer custody to protocol custody, with no intermediate institutional layer.

  Disclosing this proactively was chosen over shipping a rushed patch, because a hard fork done right is worth more than a constant fix done in panic.

 

  VT — what is being bundled at block 10,000

  The block 10,000 activation package does six things in a single coordinated fork.

  1. Gold Vault 5-defense governance model (wired into consensus)

  From block 10,000 onwards, any transaction spending from the Gold Vault address must pass ALL five independent consensus-level defenses simultaneously:

 
  • Defense 1 — Purpose restriction: the vault can only be used for gold reserve operations. Any other purpose is rejected at consensus, regardless of voting outcome.
  • Defense 2 — Destination whitelists: the vault can only send to constitutional addresses hardcoded in the protocol source code, organized into reserve destinations and emergency destinations
      (initially empty). Adding any new destination requires a hard fork. No miner vote, no matter how unanimous, can authorize a transfer to any address outside these whitelists.
  • Defense 3 — Hard per-spend cap: no single transaction can move more than 2% of the current vault balance.
  • Defense 4 — Aggregate rate limit: routine gold purchases are capped at 5% of the vault balance per ~30-day window. Emergency spends require a hard 30-day cooldown between transactions.
  • Defense 5 — Supermajority approval: non-routine spends require ≥95% miner signaling over a 288-block window.

  The vault has no burn route. Vault SOST is never destroyed under any conditions. The Gold Vault must be able to change form, but not purpose.

  Epoch policy — 95% from day one

  The original whitepaper specified a 75% threshold during Epoch 0-1 and 95% from Epoch 2 onwards. After internal review, the threshold is raised to 95% from the start. This is intentionally strict.
  The vault exists to back the protocol with gold, not to fund discretionary spending.

  2. Signature-bound Proof of Work (anti-pool protocol)

  Every winning block must include a digital signature made by the miner's private key over the PoW commitment. The block is valid only if:

 
  • the signature verifies against a public key included in the block header, and
  • the miner reward in the coinbase pays to the address derived from that same public key.

  A conventional pool operator cannot delegate work to thousands of remote workers without either giving them the pool's private key or signing every attempt centrally. Conventional pool models become
  structurally incompatible with SOST consensus. P2Pool-style cooperative mining remains fully supported.

  3. PoPC Model A — operational launch

  Model A is fully implemented and ready for block 10,000. All core components are operational:

 
  • Registration, status, release, and slash RPCs — complete
  • Dynamic reward system (Pool Utilization Ratio, 6 participation tiers, anti-whale tiers) — complete
  • Bond sizing, protocol fee (5% uniform), reward cap (1,000 SOST/contract) — complete
  • Price Bulletin system for pre-exchange bond computation — complete
  • Automation scripts (daemon, oracle, Ethereum balance checker, cron installer) — complete
  • 17/17 Gold Vault governance tests passing

  Reward schedule:

 
Code:
  Duration     Base reward     Tier 1 (first 25 contracts)
  1 month      1% of bond      1.0%
  3 months     4% of bond      4.0%
  6 months     9% of bond      9.0%
  9 months     15% of bond     15.0%
  12 months    22% of bond     22.0%
 

  The first 25 active contracts receive the full 100% multiplier (Tier 1). After that, the multiplier steps down automatically — 75%, 50%, 30%, 15%, 8%. Anti-whale tiers reduce the multiplier above 10
  oz committed; the maximum is 200 oz, beyond which registration is rejected.

  PoPC is intentionally application-layer, not consensus-layer. The 25% accumulation is consensus-enforced. Reward distribution is operator-mediated for the first 4 weeks of operation, transitioning to fully
  automatic via the popc_daemon.py cron daemon once safe production data has been gathered.

  4. PoPC Model B — timelocked gold escrow (SOSTEscrow smart contract)

  Model B is the escrow complement to Model A. Instead of committing to hold gold in their own wallet (Model A), the participant deposits XAUT or PAXG into an immutable smart contract on Ethereum with
  a timelock. The SOST reward is paid immediately at deposit. At expiry, the original depositor — and only the original depositor — can withdraw the full gold amount.

  The smart contract (contracts/SOSTEscrow.sol) is now written, published in the repository, and includes:

 
  • Zero admin keys — no owner, no admin, no Ownable pattern
  • Zero upgrade proxies — no UUPS, no transparent proxy, no beacon, no delegatecall
  • Zero pause function — the contract cannot be stopped by anyone
  • Zero emergency withdrawal — no function bypasses the timelock under any circumstance
  • No extension or modification — once created, a deposit's term is immutable
  • Immutable token allowlist — only XAUT and PAXG, set at construction, cannot be changed
  • Reentrancy protection on all state-changing functions
  • Checks-effects-interactions pattern in the withdrawal function

  Contract functions:

 
Code:
  deposit(token, amount, unlockTime) → depositId
  withdraw(depositId)  — only by original depositor, only after unlock
  getDeposit(depositId) — view
  canWithdraw(depositId) — view
  getUserDepositIds(user) — view
  totalLocked(token) — view
 

  Security analysis covering 10 attack vectors is published at contracts/SECURITY.md. Deployment tooling (Foundry), mock tokens for testnet, 14 automated tests, and Etherscan verification scripts are
   included in the repository.

  Model B deployment path: Sepolia testnet first, manual flow testing, source verification on Etherscan, optional independent audit, then Ethereum mainnet deployment before block 10,000. The contract
  is not deployed yet — only the code and tooling are published.

  Model B reward schedule (lower than Model A because there is no slash risk):

 
Code:
  Duration     Base reward
  1 month      0.4% of gold value
  3 months     1.5% of gold value
  6 months     3.5% of gold value
  9 months     5.5% of gold value
  12 months    8.0% of gold value
 

  Same participation tiers apply. Hard cap: 1,000 SOST max per contract.

  5. Real version-bit signaling

  The getproposals RPC bug is fixed so that it reads actual block header versions instead of placeholder data. Miners can signal through version bits as intended.

  6. Bond / Escrow / Capsule activation

  The lock output types (BOND_LOCK = 0x10, ESCROW_LOCK = 0x11) become valid post-block 10,000, together with Capsule activation.

 

  The cooperative angle — five ways to earn SOST

  SOST is built on cooperativism in the literal sense, not as a slogan. The protocol creates multiple parallel income paths for participants of all sizes. After the block 10,000 activation, the full
  menu is:

  1. Mining the chain

  Every block awards 50% of the subsidy to whoever found the nonce. With CPU-friendly ConvergenceX (8 GB RAM, no ASIC), participation remains accessible. Post-V6, the CASERT slew rate update (±1) makes block
  production more consistent and less dependent on brief anti-stall windows. Post-VT, signature-bound PoW ensures a small miner's hashrate cannot be silently absorbed by a centralized pool operator.

  2. Anti-stall windows (CASERT)

  When the network goes too long without a block, CASERT lowers the profile over time. During these windows, smaller miners have a structurally higher chance of winning a block. With the V6 slew rate update,
  these windows become less extreme but still provide accessible mining opportunities.

  3. PoPC Model A — gold custody commitment

  Hold XAUT or PAXG in your own Ethereum wallet. Commit to keep holding for 1 to 12 months. Earn SOST rewards — up to 22% of your bond annually for a 12-month commitment at Tier 1. The gold never leaves your
  wallet. Zero slash risk on the gold itself; only the posted SOST bond is at risk if the commitment is broken.

  4. PoPC Model B — gold escrow

  Deposit XAUT or PAXG into the immutable SOSTEscrow contract on Ethereum. Receive SOST reward immediately. At expiry, withdraw full gold amount. Zero slash risk, zero audit risk, zero bond requirement. The
  trade-off: lower reward rates than Model A, and the gold is locked (no liquidity during the term).

  5. Gold Vault OTC participation and governance bot operation

  The OTC desk enables direct SOST acquisition against USDC/EUR. Every sale funds gold reserve purchases. The Phase II governance path includes a relayer bot that posts SOST chain state to Reality.eth on
  Ethereum. Anyone can run a competing bot and earn small rewards for correct relay participation.

  The point: a small participant — a single laptop, no specialized mining hardware, and 0.5 oz of gold in a MetaMask wallet — can earn meaningful SOST through mining, anti-stall windows, and PoPC
  simultaneously. Earning a return does not depend on outcompeting a $10,000 mining rig.

 

  Vault custody — two phases

  Vault custody transitions in a single, irreversible step from developer custody to protocol custody at the block 10,000 activation height. There is no intermediate institutional layer.

  Phase I — now to block 10,000 (developer custody)

  The Gold Vault is custodied by the protocol developer (NeoB) until block 10,000. The custody arrangement is at the developer's operational discretion and is intentionally not detailed publicly. What IS
  disclosed:

 
  • The developer commits not to move funds from the Gold Vault for any purpose other than the constitutional one (gold reserve operations).
  • Every reserve operation is documented publicly.
  • The developer has no premine, no allocation, and no special income route other than mining the chain like everyone else.
  • This is openly declared Phase I trust based on reputation and transparency until the protocol takes over automatically.

  Phase II — block 10,000 onwards (protocol-governed custody)

  At the block 10,000 activation height, vault control transitions from developer custody to protocol-governed logic with the five independent consensus-level defenses described above. The protocol developer
  can no longer move the vault unilaterally. The transition is rule-based and has a hard date encoded in the consensus rules — it is not subject to the developer's later willingness to step back.

  Phase III — later, conditional on growth

  Migration from tokenized gold (XAUT, PAXG) to physical gold custody in a regulated vault (Switzerland or London), audited by a recognized custodian. This eliminates issuer risk (Tether, Paxos), eliminates
  smart-contract risk, and provides physical audit reports tied to specific bar serial numbers. No bridges, no wSOST, no cross-chain attack surface.

 

  Why this is being done — the philosophical part

  SOST exists on the assumption that the post-fiat era requires infrastructure with three properties simultaneously:

 
  • Decentralized mining — no single entity, including the developer, controls block production
  • Real-world backing — value tied to physical gold, not to abstract scarcity
  • Cooperative economics — multiple participation paths so that small participants can earn alongside large ones

  There is no foundation behind SOST. There is no council, no DAO, no allocation of pre-mined tokens. There is one developer who wrote the codebase, one set of consensus rules anyone can read, and a chain
  maintained in the open. The developer does not own SOST. Nobody owns SOST. The developer maintains it until the protocol can maintain itself, and then steps back.

  The goal is that nobody, not even the developer, ever has to be trusted permanently.

 

  Timeline

 
Code:
  Block ~4,754             Current chain height
                           V6 code deployed on VPS and available on GitHub
                           VT mechanisms under development

  Block 5,000              V6 ACTIVATION HEIGHT
  (~246 blocks away)       - CASERT equalizer slew rate ±3 → ±1
                           - All miners and nodes must upgrade before this height

  Block ~9,000             VT release candidate published
                           SOSTEscrow deployed on Sepolia testnet (Model B)
                           4-week upgrade window for miners and nodes

  Block 10,000             VT ACTIVATION HEIGHT
                           - Gold Vault 5-defense governance enforced
                           - Signature-bound PoW required
                           - PoPC Model A operational launch
                           - PoPC Model B (escrow) available on Ethereum mainnet
                           - Bond / Escrow / Capsule output types valid
                           - Developer → protocol custody transition

  Block 10,000 + 4 weeks   PoPC reward distribution transitions
                           from supervised manual flow to automated cron daemon
 

 

  What participants need to do

  Node operators: upgrade before block 5,000 for the V6 stability fork, and later again before block 10,000 for the VT governance / custody / PoPC activation package.

  Miners: continue mining as usual. Two milestones require rebuilding from updated sources:
 
  • Block 5,000 — V6 chain-stability fork (rebuild miner binary)
  • Block 10,000 — VT activation (rebuild miner with signature-bound PoW support + hot mining key)

  Tokenized gold holders interested in PoPC Model A: nothing to do until block 10,000. Prepare an Ethereum wallet holding XAUT or PAXG. The registration guide at
  sostcore.com/sost-popc-quickstart.html documents the process. The first 25 contracts receive Tier 1 (100% multiplier).

  Tokenized gold holders interested in PoPC Model B: the SOSTEscrow contract will be deployed on Ethereum mainnet before block 10,000. The contract address will be published on
  sostcore.com and verified on Etherscan. Model B requires depositing gold tokens into the escrow contract — review the contract source at contracts/SOSTEscrow.sol and
   the security analysis at contracts/SECURITY.md before participating.

  Verifiers: clone the repo at github.com/Neob1844/sost-core and verify directly. The smart contract, deployment tooling, 14 automated tests, and full
  security analysis are public. Independent audit contributions are welcome.

 

  Q&A — questions to expect

  Q: Is SOST safe to hold today?
  A: Yes. The 25% accumulation to Gold Vault and PoPC Pool has been consensus-enforced since genesis. The audit findings concerned spending governance, not accumulation. Those spending rules become
  consensus-enforced at block 10,000.

  Q: Could the developer drain the Gold Vault right now?
  A: Until block 10,000, the Gold Vault remains under developer custody. The custody arrangement is at the developer's operational discretion and is intentionally not detailed publicly — disclosing
  operational security details creates attack surface, not transparency. After block 10,000, the five-defense governance model takes over and unilateral executive control ends.

  Q: What can the Gold Vault be used for? Could a colluding majority of miners drain it?
  A: No. After block 10,000, the Gold Vault is constrained by FIVE independent consensus-level defenses, all of which must hold simultaneously:
 
  • Purpose restriction — only gold reserve operations
  • Destination whitelists — only constitutional addresses (hard fork to modify)
  • Hard per-spend cap — max 2% of vault balance per transaction
  • Aggregate rate limit — 5% per 30-day window for routine purchases; 30-day cooldown for emergency spends
  • Supermajority approval — ≥95% miner signaling for non-routine spends
  The vault has no burn route. Vault SOST is never destroyed. The Gold Vault must be able to change form, but not purpose.

  Q: Is the Model B escrow contract safe?
  A: The contract has been analyzed for 10 attack vectors (reentrancy, ERC-20 failures, integer overflow, timestamp manipulation, front-running, gas DoS, approval race, direct token send, deposit ID
  prediction, issuer risk). It uses reentrancy guards, checks-effects-interactions, and is fully immutable (no admin, no proxy, no pause). However, it has NOT been independently audited by a third party yet.
  The code and security analysis are published for review. Sepolia testnet validation is planned before mainnet deployment.

  Q: What is the difference between Model A and Model B?
  A:
 
Code:
                      Model A (Commitment)      Model B (Escrow)
  Gold location       Your own wallet            Smart contract
  Gold moves?         No                         Yes (into escrow)
  Bond required?      Yes (SOST bond)            No
  Slash risk?         Yes (bond at risk)          No
  Audit risk?         Yes (random audits)         No (escrow enforces)
  Reward rate         Higher (1-22% of bond)      Lower (0.4-8% of gold)
  Reward timing       At completion               Immediately at deposit
  Trust model         Audit system + bond         Smart contract code
 

  Q: Why 95% threshold instead of the original 75%?
  A: Because the vault should be extremely hard to misuse. With ~26 miners, 95% means essentially all active miners must approve. The threshold is self-protecting: changing it requires meeting it.

  Q: When will SOST be on an exchange?
  A: When the system is ready, not before. Conditions: publishable transparency reports, verifiable Gold Vault balance, working Phase II governance, and sustained OTC volume. No specific exchange has been
  targeted.

  Q: How can someone contribute?
  A: Run a node. Run a miner. Mirror the explorer. Verify the code. Review the smart contract. Participate in Sepolia testing. Report bugs via BTCTalk or the upcoming Telegram channel.

 

  Public audit trail

  All simulation data, test scripts, contract source, and audit reports are publicly available:

 
  • contracts/SOSTEscrow.sol — Model B escrow contract
  • contracts/SECURITY.md — 10-vector security analysis
  • contracts/test/SOSTEscrow.t.sol — 14 automated tests
  • contracts/README.md — deployment guide
  • reports/simulator_parity_report.md — simulator vs C++ audit
  • reports/pid_tuning_campaign.md — 2,630-config tuning campaign
  • reports/slew_prefork_validation.md — 1,650-run slew validation
  • reports/e_profile_regression.md — 2,700-run E-profile regression
  • reports/casert_dual_audit.md — joint bitsQ/equalizer audit

  Independent review is welcome.

 

 
NeoB — SOST Protocol
  sostcore.com · GitHub · Explorer
  Not financial advice. SOST is experimental software. PoPC is an experimental cooperative reward system. The SOSTEscrow smart contract has not been independently audited. Gold Vault spending
  governance becomes consensus-enforced at block 10,000. The V6 chain-stability fork activates earlier at block 5,000. Review the source code, run the verification commands, and form an independent opinion
  before participating.
Pages: « 1 2 3 [4] 5 »  All
  Print  
 
Jump to:  

Powered by MySQL Powered by PHP Powered by SMF 1.1.19 | SMF © 2006-2009, Simple Machines Valid XHTML 1.0! Valid CSS!