reorgs, fetch batching (parallel fetch), orphans

include/block/block.h

@@ -40,5 +40,7 @@ bool Block_IsFullyValid(const block_t* block);
 void Block_ShutdownPowContext(void);
 void Block_Destroy(block_t* block);
 void Block_Print(const block_t* block);
+// Deep-copy a block (allocates a new `block_t*`). Caller must call `Block_Destroy`.
+block_t* Block_Copy(const block_t* src);
 
 #endif

include/block/chain.h

@@ -24,6 +24,13 @@ size_t Chain_Size(blockchain_t* chain);
 bool Chain_IsValid(blockchain_t* chain);
 void Chain_Wipe(blockchain_t* chain);
 
+// Roll back the chain to `height` (exclusive): after this call, Chain_Size(chain) == height
+// Returns true on success.
+bool Chain_RollbackToHeight(blockchain_t* chain, size_t height);
+
+// Retrieve a deep copy of the block at `index`. Caller must free with `Block_Destroy`.
+bool Chain_GetBlockCopy(blockchain_t* chain, size_t index, block_t** outCopy);
+
 // I/O
 bool Chain_SaveToFile(blockchain_t* chain, const char* dirpath, uint256_t currentSupply, uint64_t currentReward);
 bool Chain_LoadFromFile(blockchain_t* chain, const char* dirpath, uint256_t* outCurrentSupply, uint32_t* outDifficultyTarget, uint64_t* outCurrentReward, uint8_t* outLastSavedHash, bool loadTransactions);

include/constants.h

@@ -23,6 +23,22 @@
 //#define INITIAL_DIFFICULTY 0x1f0c1422 // Default compact target used by Autolykos2 PoW (This is ridiculously low)
 #define INITIAL_DIFFICULTY 0x1f1b7c51 // This takes 90s on my machine with a single thread, good for testing
 
+// Sync / Reorg tuning constants
+// Timeouts and retry/backoff behavior for block fetches during sync (milliseconds)
+static const uint64_t SYNC_REQUEST_TIMEOUT_MS = 5000ULL; // 5s
+static const int MAX_SYNC_RETRIES = 4; // retry attempts per block fetch
+static const uint64_t SYNC_BACKOFF_BASE_MS = 200ULL; // base backoff in ms (exponential)
+// Parallelism
+static const int MAX_PARALLEL_FETCHES = 8; // concurrent block fetches during windowed sync
+// Heuristic: if peer is this many blocks ahead, treat as initial sync
+static const uint64_t INITIAL_SYNC_HEIGHT_DIFF = 50ULL;
+
+// Reorg penalty configuration (used to penalize peers reporting higher heights but with delayed work)
+static const uint64_t REORG_PENALTY_GRACE_BLOCKS = 3ULL; // allow small reorgs without penalty
+static const double REORG_PENALTY_FACTOR = 1.0; // base scaling factor (theta)
+static const double REORG_PENALTY_EXPONENT = 2.0; // exponent p in penalty ~ B^p
+static const double REORG_PENALTY_REF_BLOCK_TIME = 150.0; // reference block time in seconds used by original scheme
+
 // Reward schedule acceleration: 1 means normal-speed progression.
 #define EMISSION_ACCELERATION_FACTOR 1ULL
 
@@ -166,10 +182,16 @@ static inline size_t CalculateTargetDAGSize(blockchain_t* chain) {
     }
 
     // Get the height - EPOCH_LENGTH block and the last block;
-    block_t* lastBlock = Chain_GetBlock(chain, Chain_Size(chain) - 1);
-    block_t* epochStartBlock = Chain_GetBlock(chain, (size_t)(Chain_Size(chain) - 1 - EPOCH_LENGTH));
-    if (!lastBlock || !epochStartBlock) {
-        return 0; // Invalid
+    block_t* lastBlock = NULL;
+    block_t* epochStartBlock = NULL;
+    if (!Chain_GetBlockCopy(chain, Chain_Size(chain) - 1, &lastBlock) || !lastBlock) {
+        if (lastBlock) Block_Destroy(lastBlock);
+        return 0;
+    }
+    if (!Chain_GetBlockCopy(chain, (size_t)(Chain_Size(chain) - 1 - EPOCH_LENGTH), &epochStartBlock) || !epochStartBlock) {
+        Block_Destroy(lastBlock);
+        if (epochStartBlock) Block_Destroy(epochStartBlock);
+        return 0;
     }
 
     int64_t difficultyDelta = (int64_t)epochStartBlock->header.difficultyTarget - (int64_t)lastBlock->header.difficultyTarget;
@@ -190,10 +212,15 @@ static inline size_t CalculateTargetDAGSize(blockchain_t* chain) {
     
     int64_t targetSize = (int64_t)DAG_BASE_SIZE + growth;
     if (targetSize <= 0) {
+        Block_Destroy(lastBlock);
+        Block_Destroy(epochStartBlock);
         return 0;
     }
 
-    return (size_t)targetSize;
+    size_t out = (size_t)targetSize;
+    Block_Destroy(lastBlock);
+    Block_Destroy(epochStartBlock);
+    return out;
 }
 
 static inline void GetNextDAGSeed(blockchain_t* chain, uint8_t outSeed[32]) {
@@ -205,13 +232,15 @@ static inline void GetNextDAGSeed(blockchain_t* chain, uint8_t outSeed[32]) {
         return;
     }
 
-    block_t* prevBlock = Chain_GetBlock(chain, Chain_Size(chain) - 1);
-    if (!prevBlock) {
+    block_t* prevBlock = NULL;
+    if (!Chain_GetBlockCopy(chain, Chain_Size(chain) - 1, &prevBlock) || !prevBlock) {
         memset(outSeed, 0x00, 32); // Fallback to zeroes if we can't get the previous block for some reason; The caller should treat this as an error if height >= EPOCH_LENGTH
+        if (prevBlock) Block_Destroy(prevBlock);
         return;
     }
 
     Block_CalculateHash(prevBlock, outSeed);
+    Block_Destroy(prevBlock);
 }
 
 #endif

include/nets/fetch_scheduler.h

@@ -0,0 +1,10 @@
+#ifndef FETCH_SCHEDULER_H
+#define FETCH_SCHEDULER_H
+
+#include <stdint.h>
+
+// Compute penalty in blocks for a delayed/heavy reorg reported by a peer.
+// Returns the number of penalty blocks to subtract from the peer's advertised work.
+uint64_t FetchScheduler_ComputeReorgPenaltyBlocks(uint64_t delayBlocks);
+
+#endif

include/nets/net_node.h

@@ -15,6 +15,8 @@
 
 #include <dynarr.h>
 
+#include <pthread.h>
+
 #include <block/block.h>
 #include <block/chain.h>
 #include <block/transaction.h>
@@ -27,6 +29,10 @@ typedef struct {
     void (*on_data)(tcp_connection_t* conn, const unsigned char* data, size_t len, void* user);
     void (*on_disconnect)(tcp_connection_t* conn, void* user);
     void* callbackUser;
+    // Maintenance thread for periodic tasks (orphan attach, pruning, metrics)
+    pthread_t maintenanceThread;
+    volatile int maintenanceRunning;
+    int maintenanceIntervalMs;
 } net_node_t;
 
 net_node_t* Node_Create();

include/nets/orphan_pool.h

@@ -0,0 +1,20 @@
+#ifndef ORPHAN_POOL_H
+#define ORPHAN_POOL_H
+
+#include <stdint.h>
+#include <block/block.h>
+#include <block/chain.h>
+
+// Initialize/destroy the global orphan pool
+void OrphanPool_Init(void);
+void OrphanPool_Destroy(void);
+
+// Insert an orphan block into the pool. Ownership of `block` is transferred to the pool.
+// `height` is the block number from the header.
+void OrphanPool_Insert(block_t* block, uint64_t height);
+
+// Attempt to attach any orphans whose parents now exist in `chain`.
+// Returns the number of blocks successfully attached.
+size_t OrphanPool_AttemptAttach(blockchain_t* chain);
+
+#endif

include/runtime_state.h

@@ -6,6 +6,7 @@
 #include <uint256.h>
 
 #include <block/chain.h>
+#include <pthread.h>
 
 extern uint64_t currentBlockHeight;
 extern blockchain_t* currentChain;
@@ -14,4 +15,8 @@ extern uint64_t currentReward;
 extern uint32_t difficultyTarget;
 extern const char* chainDataDir;
 
+// Global synchronization primitives for runtime state
+extern pthread_rwlock_t chainLock; // protects chain structure and related mutations
+extern pthread_mutex_t balanceSheetLock; // protects balance sheet map
+
 #endif