SIGPIPE fix - don't terminate on nodes being nodes

- Implement NodeDiscovery engine: known-peer table (DynArr) with a
  per-tick seed/ping/query/connect state machine driven by the node
  maintenance thread; bounded multi-hop crawl (FANOUT peers per node,
  hop-capped) that connects to reachable peers lowest-ping-first
- Add GET_PEERS/PEERS TCP opcodes for peer-list exchange, handled on
  both inbound and outbound connections
- Measure UDP round-trip time and pass it to the on_pong callback
  (previously the send timestamp was only used for retries)
- Advertise each node's listen port in HELLO/ACK_HELLO and store it
  per-connection, so inbound-only peers and non-default ports are
  discoverable (length-guarded parse; wire-compatible with old peers)
- Wire a udp_node_t + node_discovery_t into net_node_t: init/start in
  Node_Create, tick in the maintenance loop, teardown in Node_Destroy
  (stop UDP before destroying discovery to avoid callback races)
- Add Node_ConnListenEndpoint / Node_GetPeerEndpoints helpers to derive
  peers' listen endpoints (outbound: dialed port; inbound: advertised),
  with IPv4-mapped-IPv6 normalization and IP+port dedup
- Match ping pong/timeout callbacks by peer address (the UDP layer owns
  the nonce), fixing discovered peers stuck UNREACHABLE
- Ping the peer's listen port instead of the ephemeral TCP source port
  (fixes the original stub so pongs actually return)
- Add `peers` CLI command to dump the discovery table (endpoint/hop/
  state/ping)
- Add discovery tunables to constants.h (fanout, max hops, target
  connections, timeouts, caps)

CMakeLists.txt

@@ -160,21 +160,20 @@ if(SKALACOIN_ENABLE_AUTOLYKOS2_REF)
         )
     endif()
     if(TARGET CURL::libcurl)
-        set(_AUTOLYKOS2_CURL_LIB CURL::libcurl)
+        target_link_libraries(autolykos2_ref PRIVATE
+            ${CMAKE_THREAD_LIBS_INIT}
+            OpenSSL::SSL
+            OpenSSL::Crypto
+            CURL::libcurl
+        )
     elseif(DEFINED CURL_LIBRARIES AND CURL_LIBRARIES)
-        set(_AUTOLYKOS2_CURL_LIB ${CURL_LIBRARIES})
+        target_link_libraries(autolykos2_ref PRIVATE
+            ${CMAKE_THREAD_LIBS_INIT}
+            OpenSSL::SSL
+            OpenSSL::Crypto
+            ${CURL_LIBRARIES}
+        )
     else()
-        set(_AUTOLYKOS2_CURL_LIB "")
-    endif()
-
-    target_link_libraries(autolykos2_ref PRIVATE
-        ${CMAKE_THREAD_LIBS_INIT}
-        OpenSSL::SSL
-        OpenSSL::Crypto
-        $<$<BOOL:$_AUTOLYKOS2_CURL_LIB>:$_AUTOLYKOS2_CURL_LIB>
-    )
-
-    if(NOT _AUTOLYKOS2_CURL_LIB)
         message(FATAL_ERROR "autolykos2_ref requires libcurl (curl/curl.h). Install libcurl devel package or allow FetchContent to build it.")
     endif()
     set(SKALACOIN_AUTOLYKOS2_REF_AVAILABLE ON)
@@ -230,5 +229,6 @@ target_compile_options(node PRIVATE
 target_compile_definitions(node PRIVATE
     CHAIN_DATA_DIR="${CMAKE_BINARY_DIR}/chain_data"
     $<$<BOOL:${SKALACOIN_AUTOLYKOS2_REF_AVAILABLE}>:SKALACOIN_AUTOLYKOS2_REF_AVAILABLE>
+    $<$<BOOL:1>:_POSIX_C_SOURCE=200809L>
 )
 set_target_properties(node PROPERTIES OUTPUT_NAME "skalacoin_node")

TODO.txt

@@ -1,6 +1,4 @@
 TODO:
-Implement Horizen's "Reorg Penalty" system to make it harder for the young chain to be attacked by a powerful miner.
-
 Make transactions private. A bit more work, but it's a challenge worth taking on.
 I want to make an "optional privacy" system, where the TX can be public or private. Of course private TXs need more bytes, so the fees (although low) will be higher for them.
 I need to figure out a way to make the privacy work without a UTXO system, and instead, with a "Balance Sheet" approach.
@@ -10,6 +8,23 @@ Maybe move the node system to an async event loop instead of spawning threads.
 
 A potential race could occur if the P2P node receives a new block, or flushes a new block to disk while the user is running a full verify.
 
+Maybe think about how block broadcasting works. Instead of unsolicited broadcasting, maybe only advertise a new height and have peers request the block if they want it. This would reduce bandwidth usage, but it also means that blocks won't propagate as fast, which could lead to more orphaned blocks. It's a tradeoff.
+
+Check if Block FullVerify is actually verifying fully (not missing any conditions).
+
+A loophole in the reorg penalty system could potentially exist where someone broadcasts blocks one-at-a-time. Determine a solution to this.
+
+IPv6 support for the P2P node. Come on guys, it's 2026. RFC 2460 was in 1998. It's about time.
+    Like if someone is behind NAT, fine, workable. CGNAT? Lmao good luck.
+
+TO TEST:
+Implement Horizen's "Reorg Penalty" system to make it harder for the young chain to be attacked by a powerful miner.
+
+NOTE:
+Because tx sizes are currently fixed, mining can use raw fee ordering for now. If tx sizes ever become dynamic, revisit selection to consider fee/byte instead.
+
+Mempool snapshotting for mining should hold the lock only long enough to copy pending txs, but if the mempool grows very large that copy may still be non-trivial.
+
 DONE:
 I want to move away from the Monero emission. I want to do something a bit radical for cryptocurrency, but I feel like it's necessary to make it more like money:
 a constant inflation rate of 1.5% per year. It's lower than fiat (USD is ~2.8% per year), and it additionally doesn't fluctuate during crisis. It's constant.

include/balance_sheet.h

@@ -8,6 +8,7 @@
 #include <stdio.h>
 #include <khash/khash.h>
 #include <crypto/crypto.h>
+#include <block/transaction.h>
 #include <string.h>
 #include <utils.h>
 #include <uint256.h>
@@ -29,4 +30,12 @@ bool BalanceSheet_LoadFromFile(const char* inPath);
 void BalanceSheet_Print();
 void BalanceSheet_Destroy();
 
+bool BalanceSheet_SelectSpendableTransactions(
+    const signed_transaction_t* candidates,
+    size_t candidateCount,
+    signed_transaction_t** outAccepted,
+    size_t* outAcceptedCount,
+    uint64_t* outTotalFees
+);
+
 #endif

include/block/block.h

@@ -36,8 +36,13 @@ void Block_AddTransaction(block_t* block, signed_transaction_t* tx);
 void Block_RemoveTransaction(block_t* block, uint8_t* txHash);
 bool Block_HasValidProofOfWork(const block_t* block);
 bool Block_AllTransactionsValid(const block_t* block);
+bool Block_ValidateCoinbaseAndFees(const block_t* block, uint64_t expectedCoinbaseAmount, uint64_t* outTotalFees);
+bool Block_IsFullyValid(const block_t* block);
 void Block_ShutdownPowContext(void);
 void Block_Destroy(block_t* block);
 void Block_Print(const block_t* block);
+void Block_ShortPrint(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,17 @@ 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);
+
+// Recompute `currentSupply` and `currentReward` from the in-memory chain blocks.
+// Returns true on success and updates runtime state globals.
+bool Chain_RecomputeRuntimeState(blockchain_t* chain);
+
+// 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

@@ -7,11 +7,24 @@
 #include <block/chain.h>
 #include <block/block.h>
 
-extern uint64_t currentBlockHeight;
+#include <runtime_state.h>
 
 // Nets
 #define MAX_CONS 32 // Some baseline for now
 #define LISTEN_PORT 9393
+#define ECHO_PEERS 1 // If non-zero, automatically attempt to connect back to any inbound peers (helps form bidirectional peering)
+
+// Node discovery
+#define DISCOVERY_FANOUT 2 // "A couple" - how many peers to query per round, and how many new peers to accept per PEERS response (keeps the crawl spread out)
+#define DISCOVERY_MAX_HOPS 3 // How many hops away from us we keep crawling
+#define DISCOVERY_TARGET_CONNECTIONS 8 // Desired outbound connection count discovery tries to reach (bounded by MAX_CONS)
+#define DISCOVERY_MAX_KNOWN_PEERS 256 // Cap on the known-peer table size
+#define DISCOVERY_PEERS_RESPONSE_CAP 8 // Max endpoints we put in a single PEERS response
+#define DISCOVERY_MAX_PINGS_PER_TICK 8 // Cap on UDP pings sent per discovery tick
+#define DISCOVERY_PING_TIMEOUT_MS 5000ULL // Backstop: a PINGED peer with no pong for this long is marked unreachable
+#define DISCOVERY_PING_REFRESH_MS 60000ULL // Re-ping a reachable peer after this long to refresh its latency
+#define DISCOVERY_QUERY_INTERVAL_MS 15000ULL // Minimum interval between GET_PEERS to the same peer
+#define DISCOVERY_CONNECT_RETRY_MS 30000ULL // Minimum interval between connect attempts to the same discovered peer
 #define TCP_THREAD_STACK_SIZE (512 * 1024) // 512 KB. We could get away with like 128 KB since it's mostly just recv bufs, but it's good having some breathing room.
                                            // This is also for client threads. The server has the default (~8 MB on POSIX).
 
@@ -23,6 +36,22 @@ extern uint64_t currentBlockHeight;
 //#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
 
@@ -56,11 +85,8 @@ extern uint64_t currentBlockHeight;
 
 static const uint64_t M_CAP = 18446744073709551615ULL; // Max uint64
 static const uint64_t TAIL_EMISSION = 750000000000ULL; // 0.75 coins per block floor
-static uint64_t currentReward = 750000000000ULL; // Epoch reward cache for phase 3
 // No max supply. Instead of halving, it'll follow a more gradual, Monero-like emission curve.
 
-static uint256_t currentSupply = {{0, 0, 0, 0}}; // Global variable to track total supply; updated with each block mined
-
 // Phase 3: update once per effective epoch and keep a fixed per-block reward for that epoch.
 static inline uint64_t GetInflationRateReward(uint256_t currentSupply, blockchain_t* chain) {
     if (!chain || !chain->blocks) { return 0x00; } // Invalid
@@ -169,10 +195,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;
@@ -193,10 +225,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]) {
@@ -208,13 +245,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

@@ -10,19 +10,43 @@
 
 #include <constants.h>
 #include <packettype.h>
+#include <udpd/udpnode.h>
+
+// Forward declaration - the discovery state is defined in nodediscovery.c (opaque here).
+typedef struct node_discovery node_discovery_t;
 
 #include <stddef.h>
 
 #include <dynarr.h>
+#include <dynset.h>
+
+#include <pthread.h>
+
+#include <block/block.h>
+#include <block/chain.h>
+#include <block/transaction.h>
 
 typedef struct {
     tcp_server_t* server;
     tcp_client_t outboundClients[MAX_CONS];
     size_t outboundCount;
+    // Dedup cache for recently seen block hashes (canonical 32-byte hash)
+    DynSet* seenBlocks;
+    // Protects seenBlocks
+    pthread_mutex_t seenLock;
+    // Protects outboundClients snapshots and peerBlockHeight writes
+    pthread_mutex_t outboundLock;
     void (*on_connect)(tcp_connection_t* conn, void* user);
     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;
+    // UDP ping/pong daemon (latency oracle) and peer discovery state
+    udp_node_t* udpNode;
+    node_discovery_t* discovery;
 } net_node_t;
 
 net_node_t* Node_Create();
@@ -40,6 +64,11 @@ int Node_ConnectPeer(net_node_t* node, const char* ip, unsigned short port);
 int Node_ConnectStartupPeers(net_node_t* node, const char** ips, const unsigned short* ports, size_t peersCount);
 
 int Node_SendPacket(net_node_t* node, tcp_connection_t* conn, packet_type_t packetType, const void* payload, size_t payloadLen);
+int Node_BroadcastTransaction(net_node_t* node, signed_transaction_t* tx, tcp_connection_t* excludeNode);
+
+// Helpers for outbound peer selection and block broadcast
+int Node_GetBestOutboundPeer(net_node_t* node, tcp_connection_t** outConn, uint64_t* outHeight);
+void Node_BroadcastChainRange(net_node_t* node, size_t startHeightInclusive, tcp_connection_t* sourceConn);
 
 // Callback logic
 void Node_Server_OnConnect(tcp_connection_t* client);
@@ -49,4 +78,15 @@ void Node_Client_OnConnect(tcp_connection_t* client);
 void Node_Client_OnData(tcp_connection_t* client);
 void Node_Client_OnDisconnect(tcp_connection_t* client);
 
+void Node_GetClientList(net_node_t* node, tcp_connection_t** outClients, size_t* outCount);
+
+// Computes a connection's peer listen endpoint (IP + advertised/dialed listen port) into *out.
+// Outbound: the dialed peerAddr port already is the listen port. Inbound: uses peerListenPort.
+// Returns non-zero on success (usable endpoint with a known, non-zero port), zero otherwise.
+int Node_ConnListenEndpoint(const tcp_connection_t* conn, struct sockaddr_storage* out);
+
+// Fills outEndpoints with the listen endpoints of all current connections (inbound + outbound),
+// deduped by IP+port. Returns the number of endpoints written (<= maxOut).
+size_t Node_GetPeerEndpoints(net_node_t* node, struct sockaddr_storage* outEndpoints, size_t maxOut);
+
 #endif

include/nets/nodediscovery.h

@@ -0,0 +1,29 @@
+#ifndef NODEDISCOVERY_H
+#define NODEDISCOVERY_H
+
+#include <nets/net_node.h>
+#include <udpd/udpnode.h>
+
+// Create/destroy the peer-discovery state. Owns the known-peer table and its lock.
+node_discovery_t* NodeDiscovery_Create(net_node_t* node, udp_node_t* udpNode);
+void NodeDiscovery_Destroy(node_discovery_t* disc);
+
+// Periodic tick (driven by the node maintenance thread): seed currently-connected peers,
+// UDP-ping newly-learned ones, query a couple of connected peers for more, and connect to
+// the reachable peers with the lowest ping until we reach the target connection count.
+void NodeDiscovery_Iterate(node_discovery_t* disc);
+
+// UDP latency callbacks (forwarded from the udp node via net_node thunks).
+void NodeDiscovery_OnPong(node_discovery_t* disc, const struct sockaddr_storage* from, uint64_t nonce, uint64_t rttMs);
+void NodeDiscovery_OnPingTimeout(node_discovery_t* disc, const struct sockaddr_storage* dest, uint64_t nonce);
+
+// TCP peer-exchange handlers (called from the net_node packet dispatch).
+// Build a PEERS response (a sample of our peers, excluding the requester) and send it over fromConn.
+void NodeDiscovery_OnGetPeers(node_discovery_t* disc, tcp_connection_t* fromConn);
+// Decode a received PEERS payload and fold a couple of its endpoints into the known-peer table.
+void NodeDiscovery_OnPeersReceived(node_discovery_t* disc, tcp_connection_t* fromConn, const unsigned char* payload, size_t payloadLen);
+
+// Dump the known-peer table to stdout (for the CLI `peers` command).
+void NodeDiscovery_PrintPeers(node_discovery_t* disc);
+
+#endif

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/packettype.h

@@ -14,7 +14,9 @@ typedef enum {
     PACKET_TYPE_BROADCAST_TX = 7, // Here's a new transaction I want to share with the network
     PACKET_TYPE_ACK_TX = 8, // I have received your transaction, here's what I did with it (response to broadcast)
     PACKET_TYPE_ERROR = 9, // Something went wrong with the packet you sent me, here's an error message (can be response to any packet)
-    PACKET_TYPE_MAX = 10
+    PACKET_TYPE_GET_PEERS = 10, // Who are your peers? Send me a few of them so I can discover more of the network
+    PACKET_TYPE_PEERS = 11, // Here are some of my peers' listen endpoints (response to GET_PEERS)
+    PACKET_TYPE_MAX = 12
 } packet_type_t;
 
 static inline int PacketType_IsValid(uint8_t packetType) {

include/runtime_state.h

@@ -0,0 +1,25 @@
+#ifndef RUNTIME_STATE_H
+#define RUNTIME_STATE_H
+
+#include <stdint.h>
+
+#include <uint256.h>
+
+#include <block/chain.h>
+#include <pthread.h>
+
+extern uint64_t currentBlockHeight;
+extern blockchain_t* currentChain;
+extern uint256_t currentSupply;
+extern uint64_t currentReward;
+extern uint32_t difficultyTarget;
+extern const char* chainDataDir;
+extern unsigned short listenPort;
+extern bool echoPeersEnabled;
+extern bool forceOrphanReorgEnabled;
+
+// 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

include/tcpd/tcpclient.h

@@ -3,6 +3,7 @@
 
 #include <arpa/inet.h>
 #include <stddef.h>
+#include <stdint.h>
 
 #include <constants.h>
 #include <tcpd/tcpconnection.h>
@@ -13,6 +14,7 @@ typedef struct {
     void (*on_data)(tcp_connection_t* conn);
     void (*on_disconnect)(tcp_connection_t* conn);
     void* owner;
+    uint64_t peerBlockHeight;
 } tcp_client_t;
 
 int TcpClient_Init(tcp_client_t* client);

include/tcpd/tcpconnection.h

@@ -6,6 +6,7 @@
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
+#include <sys/socket.h>
 
 #define TCP_IO_BUFFER_SIZE 1500
 #define TCP_FRAME_HEADER_SIZE 4U
@@ -20,10 +21,15 @@ typedef struct tcp_connection_t tcp_connection_t;
 
 struct tcp_connection_t {
     int sockFd;
-    struct sockaddr_in peerAddr;
+    sa_family_t addrFamily;
+    struct sockaddr_storage peerAddr;
     uint32_t connectionId;
     tcp_connection_role_t role;
 
+    // Peer's advertised TCP/UDP listen port (learned from HELLO/ACK_HELLO). 0 until known.
+    // For OUTBOUND connections the peerAddr port already is the listen port; this matters for INBOUND peers.
+    uint16_t peerListenPort;
+
     pthread_t ioThread;
     pthread_mutex_t sendLock;
     pthread_mutex_t stateLock;
@@ -46,7 +52,7 @@ struct tcp_connection_t {
     void* owner;
 };
 
-int TcpConnection_Init(tcp_connection_t* conn, int sockFd, const struct sockaddr_in* peerAddr, tcp_connection_role_t role);
+int TcpConnection_Init(tcp_connection_t* conn, int sockFd, const struct sockaddr_storage* peerAddr, tcp_connection_role_t role);
 void TcpConnection_Destroy(tcp_connection_t* conn);
 
 int TcpConnection_SetDataBuffer(tcp_connection_t* conn, const unsigned char* data, size_t len);
@@ -54,6 +60,14 @@ int TcpConnection_SetDataBuffer(tcp_connection_t* conn, const unsigned char* dat
 void TcpConnection_ResetFramingState(tcp_connection_t* conn);
 int TcpConnection_FeedFramedData(tcp_connection_t* conn, const unsigned char* input, size_t inputLen);
 
+// Returns the peer's canonical IP string (strips ::ffff: IPv4-mapped prefix).
+// Writes at most bufLen bytes to buf. Returns buf on success, NULL on failure.
+const char* TcpConnection_GetPeerAddrStr(const tcp_connection_t* conn, char* buf, size_t bufLen);
+
+// Returns non-zero if both connections have the same peer IP address.
+// Handles AF_INET vs AF_INET6 mismatches via IPv4-mapped normalisation.
+int TcpConnection_PeerAddrEqual(const tcp_connection_t* a, const tcp_connection_t* b);
+
 int TcpConnection_SendRaw(int sockFd, const void* data, size_t len);
 int TcpConnection_SendFramed(tcp_connection_t* conn, const void* payload, size_t payloadLen);
 

include/tcpd/tcpserver.h

@@ -9,8 +9,8 @@
 #include <tcpd/tcpconnection.h>
 
 typedef struct {
-    int sockFd;
-    struct sockaddr_in addr;
+    int sockFd;    // IPv6 listening socket (-1 if IPv6 unavailable)
+    int sockFdV4;  // IPv4 listening socket (-1 on bind failure)
     int opt;
     int isRunning;
     void* owner;
@@ -27,7 +27,8 @@ typedef struct {
     tcp_connection_t** clientsArrPtr;
     pthread_mutex_t clientsMutex;
 
-    pthread_t svrThread;
+    pthread_t svrThread;    // IPv6 accept thread
+    pthread_t svrThreadV4;  // IPv4 accept thread
 } tcp_server_t;
 
 struct tcpclient_thread_args {

include/txmempool.h

@@ -13,7 +13,10 @@ void TxMempool_Init();
 // Assumed that the transation was confirmed to be valid
 int TxMempool_Insert(signed_transaction_t tx);
 bool TxMempool_Lookup(uint8_t* txHash, signed_transaction_t* out);
+bool TxMempool_Snapshot(signed_transaction_t** outTxs, size_t* outCount);
 void TxMempool_Print();
+// Remove a transaction from the mempool by its hash. Returns true if removed.
+bool TxMempool_Remove(const uint8_t* txHash);
 void TxMempool_Destroy();
 
 #endif

include/udpd/udpnode.h

@@ -0,0 +1,56 @@
+#ifndef UDP_NODE_H
+#define UDP_NODE_H
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <pthread.h>
+#include <netinet/in.h>
+
+#include <udpd/udppackettype.h>
+
+#define UDP_LISTEN_PORT 9393
+#define UDP_PING_RETRY_INTERVAL_MS 1000
+#define UDP_PING_MAX_RETRIES 3
+#define UDP_MAX_PENDING_PINGS 64
+
+typedef struct {
+    uint64_t nonce;
+    struct sockaddr_storage dest;
+    uint64_t lastSentMs;
+    int retries;
+    bool active;
+} pending_ping_t;
+
+typedef struct udp_node {
+    int sockFd; // AF_INET6, IPV6_V6ONLY=1
+    int sockFdV4; // AF_INET
+
+    volatile int isRunning;
+
+    pthread_t recvThreadV6;
+    pthread_t recvThreadV4;
+    pthread_t retryThread;
+
+    pending_ping_t pendingPings[UDP_MAX_PENDING_PINGS];
+    pthread_mutex_t pingsMutex;
+
+    void (*on_pong)(struct udp_node* node,
+                    const struct sockaddr_storage* from,
+                    uint64_t nonce, int protoVersion, uint64_t rttMs, void* user);
+    void (*on_ping_timeout)(struct udp_node* node,
+                            const struct sockaddr_storage* dest,
+                            uint64_t nonce, void* user);
+    void* callbackUser;
+} udp_node_t;
+
+int UdpNode_Init(udp_node_t* node, uint16_t port);
+void UdpNode_SetCallbacks(udp_node_t* node,
+        void (*on_pong)(udp_node_t*, const struct sockaddr_storage*, uint64_t, int, uint64_t, void*),
+        void (*on_ping_timeout)(udp_node_t*, const struct sockaddr_storage*, uint64_t, void*),
+        void* user);
+int UdpNode_Start(udp_node_t* node);
+void UdpNode_Stop(udp_node_t* node);
+void UdpNode_Destroy(udp_node_t* node);
+int UdpNode_SendPing(udp_node_t* node, const struct sockaddr_storage* dest);
+
+#endif

include/udpd/udppackettype.h

@@ -0,0 +1,14 @@
+#ifndef UDP_PACKET_TYPE_H
+#define UDP_PACKET_TYPE_H
+
+typedef enum {
+    UDP_PACKET_TYPE_NONE = 0,
+    UDP_PACKET_TYPE_PING = 1,
+    UDP_PACKET_TYPE_PONG = 2,
+} udp_packet_type_t;
+
+// Wire sizes in bytes
+#define UDP_PING_WIRE_SIZE 9   // 1 (type) + 8 (nonce)
+#define UDP_PONG_WIRE_SIZE 13  // 1 (type) + 8 (nonce) + 4 (proto_version)
+
+#endif

include/utils.h

@@ -14,6 +14,8 @@ typedef struct {
     uint8_t bytes[32];
 } key32_t;
 
+#define PROTO_VERSION 1
+
 static inline uint32_t hash_key32(key32_t k) {
     uint32_t hash = 2166136261u;
     for (int i = 0; i < 32; i++) {
@@ -36,6 +38,19 @@ static inline uint64_t get_current_time_ms(void) {
     return (spec.tv_sec * 1000) + (spec.tv_nsec / 1000000);
 }
 
+static inline void sleep_for_microseconds(uint64_t microseconds) {
+    struct timespec req;
+    req.tv_sec = (time_t)(microseconds / 1000000ULL);
+    req.tv_nsec = (long)((microseconds % 1000000ULL) * 1000ULL);
+    while (nanosleep(&req, &req) == -1) {
+        continue;
+    }
+}
+
+static inline void sleep_for_milliseconds(uint64_t milliseconds) {
+    sleep_for_microseconds(milliseconds * 1000ULL);
+}
+
 static inline void AddressToHexString(const uint8_t address[32], char out[65]) {
     if (!address || !out) {
         return;
@@ -154,7 +169,7 @@ static inline bool GenerateTestMinerIdentity(uint8_t privateKey[32], uint8_t com
     return false;
 }
 
-static inline bool GenerateRandomTestAddress(uint8_t outAddress[32]) {
+static inline bool GenerateRandomTestAddress(uint8_t outAddress[32], uint8_t outPrivateKey[32], uint8_t outCompressedPubkey[33]) {
     if (!outAddress) {
         return false;
     }
@@ -187,11 +202,18 @@ static inline bool GenerateRandomTestAddress(uint8_t outAddress[32]) {
         }
 
         AddressFromCompressedPubkey(compressedPubkey, outAddress);
+        if (outPrivateKey) {
+            memcpy(outPrivateKey, privateKey, 32);
+        }
+        if (outCompressedPubkey) {
+            memcpy(outCompressedPubkey, compressedPubkey, 33);
+        }
         secp256k1_context_destroy(ctx);
         return true;
     }
 
     secp256k1_context_destroy(ctx);
+
     return false;
 }
 

src/autolykos2/autolykos2.c

@@ -254,7 +254,7 @@ static bool Autolykos2_HashCore(
         DWORD ms = (DWORD)((autolykos2_sleepBetweenHashOperationsMicroseconds + 999) / 1000);
         Sleep(ms);
 #else
-        usleep((useconds_t)autolykos2_sleepBetweenHashOperationsMicroseconds);
+        sleep_for_microseconds(autolykos2_sleepBetweenHashOperationsMicroseconds);
 #endif
     }
 

src/balance_sheet.c

@@ -1,32 +1,179 @@
 #include <balance_sheet.h>
+#include <pthread.h>
 
 khash_t(balance_sheet_map_m)* sheetMap = NULL;
+static pthread_mutex_t g_sheetLock;
 
-void BalanceSheet_Init() {
-    sheetMap = kh_init(balance_sheet_map_m);
+static bool BalanceSheet_GetSimEntry(
+    khash_t(balance_sheet_map_m)* simMap,
+    const uint8_t address[32],
+    balance_sheet_entry_t* out
+) {
+    if (!simMap || !address || !out) {
+        return false;
+    }
+
+    key32_t key;
+    memcpy(key.bytes, address, 32);
+
+    khiter_t k = kh_get(balance_sheet_map_m, simMap, key);
+    if (k != kh_end(simMap)) {
+        *out = kh_value(simMap, k);
+        return true;
+    }
+
+    if (BalanceSheet_Lookup((uint8_t*)address, out)) {
+        int ret = 0;
+        k = kh_put(balance_sheet_map_m, simMap, key, &ret);
+        if (k == kh_end(simMap)) {
+            return false;
+        }
+        kh_value(simMap, k) = *out;
+        return true;
+    }
+
+    memset(out, 0, sizeof(*out));
+    memcpy(out->address, address, 32);
+    out->balance = uint256_from_u64(0);
+
+    int ret = 0;
+    k = kh_put(balance_sheet_map_m, simMap, key, &ret);
+    if (k == kh_end(simMap)) {
+        return false;
+    }
+
+    kh_value(simMap, k) = *out;
+    return true;
 }
 
-int BalanceSheet_Insert(balance_sheet_entry_t entry) {
-    if (!sheetMap) { return -1; }
+static bool BalanceSheet_StoreSimEntry(
+    khash_t(balance_sheet_map_m)* simMap,
+    const balance_sheet_entry_t* entry
+) {
+    if (!simMap || !entry) {
+        return false;
+    }
+
+    key32_t key;
+    memcpy(key.bytes, entry->address, 32);
+
+    int ret = 0;
+    khiter_t k = kh_put(balance_sheet_map_m, simMap, key, &ret);
+    if (k == kh_end(simMap)) {
+        return false;
+    }
+
+    kh_value(simMap, k) = *entry;
+    return true;
+}
+
+static bool BalanceSheet_ApplyCandidateTransaction(
+    khash_t(balance_sheet_map_m)* simMap,
+    const signed_transaction_t* tx,
+    uint64_t* outFee
+) {
+    if (!simMap || !tx) {
+        return false;
+    }
+
+    if (Address_IsCoinbase(tx->transaction.senderAddress)) {
+        return true;
+    }
+
+    if (!Transaction_Verify(tx)) {
+        return false;
+    }
+
+    balance_sheet_entry_t senderEntry;
+    if (!BalanceSheet_GetSimEntry(simMap, tx->transaction.senderAddress, &senderEntry)) {
+        return false;
+    }
+
+    uint256_t spend = uint256_from_u64(0);
+    if (uint256_add_u64(&spend, tx->transaction.amount1) ||
+        uint256_add_u64(&spend, tx->transaction.amount2) ||
+        uint256_add_u64(&spend, tx->transaction.fee)) {
+        return false;
+    }
+
+    if (uint256_cmp(&senderEntry.balance, &spend) < 0) {
+        return false;
+    }
+
+    if (!uint256_subtract(&senderEntry.balance, &spend)) {
+        return false;
+    }
+    if (!BalanceSheet_StoreSimEntry(simMap, &senderEntry)) {
+        return false;
+    }
+
+    balance_sheet_entry_t recipient1Entry;
+    if (!BalanceSheet_GetSimEntry(simMap, tx->transaction.recipientAddress1, &recipient1Entry)) {
+        return false;
+    }
+    if (uint256_add_u64(&recipient1Entry.balance, tx->transaction.amount1)) {
+        return false;
+    }
+    if (!BalanceSheet_StoreSimEntry(simMap, &recipient1Entry)) {
+        return false;
+    }
+
+    if (tx->transaction.amount2 > 0) {
+        balance_sheet_entry_t recipient2Entry;
+        if (!BalanceSheet_GetSimEntry(simMap, tx->transaction.recipientAddress2, &recipient2Entry)) {
+            return false;
+        }
+        if (uint256_add_u64(&recipient2Entry.balance, tx->transaction.amount2)) {
+            return false;
+        }
+        if (!BalanceSheet_StoreSimEntry(simMap, &recipient2Entry)) {
+            return false;
+        }
+    }
+
+    if (outFee) {
+        *outFee = tx->transaction.fee;
+    }
+
+    return true;
+}
+
+static int BalanceSheet_InsertLocked(balance_sheet_entry_t entry) {
+    if (!sheetMap) {
+        return -1;
+    }
 
-    // Encapsulate key
     key32_t key;
     memcpy(key.bytes, entry.address, 32);
 
-    int ret;
+    int ret = 0;
     khiter_t k = kh_put(balance_sheet_map_m, sheetMap, key, &ret);
     if (k == kh_end(sheetMap)) {
         return -1;
     }
 
     kh_value(sheetMap, k) = entry;
+    return ret;
+}
 
+void BalanceSheet_Init() {
+    sheetMap = kh_init(balance_sheet_map_m);
+    pthread_mutex_init(&g_sheetLock, NULL);
+}
+
+int BalanceSheet_Insert(balance_sheet_entry_t entry) {
+    if (!sheetMap) { return -1; }
+
+    pthread_mutex_lock(&g_sheetLock);
+    int ret = BalanceSheet_InsertLocked(entry);
+    pthread_mutex_unlock(&g_sheetLock);
     return ret;
 }
 
 bool BalanceSheet_Lookup(uint8_t* address, balance_sheet_entry_t* out) {
     if (!address || !out) { return false; }
-    
+
+    pthread_mutex_lock(&g_sheetLock);
     key32_t key;
     memcpy(key.bytes, address, 32);
 
@@ -34,20 +181,26 @@ bool BalanceSheet_Lookup(uint8_t* address, balance_sheet_entry_t* out) {
     if (k != kh_end(sheetMap)) {
         balance_sheet_entry_t entry = kh_value(sheetMap, k);
         memcpy(out, &entry, sizeof(balance_sheet_entry_t));
+        pthread_mutex_unlock(&g_sheetLock);
         return true;
     }
 
+    pthread_mutex_unlock(&g_sheetLock);
     return false;
 }
 
 bool BalanceSheet_SaveToFile(const char* outPath) {
     if (!sheetMap) { return false; }
 
+    pthread_mutex_lock(&g_sheetLock);
     char outFile[512];
     strcpy(outFile, outPath);
     strcat(outFile, "/balance_sheet.data");
     FILE* file = fopen(outFile, "wb");
-    if (!file) { return false; }
+    if (!file) {
+        pthread_mutex_unlock(&g_sheetLock);
+        return false;
+    }
 
     khiter_t k;
     for (k = kh_begin(sheetMap); k != kh_end(sheetMap); ++k) {
@@ -55,39 +208,48 @@ bool BalanceSheet_SaveToFile(const char* outPath) {
             balance_sheet_entry_t entry = kh_val(sheetMap, k);
             if (fwrite(&entry, sizeof(balance_sheet_entry_t), 1, file) != 1) {
                 fclose(file);
+                pthread_mutex_unlock(&g_sheetLock);
                 return false;
             }
         }
     }
 
     fclose(file);
+    pthread_mutex_unlock(&g_sheetLock);
     return true;
 }
 
 bool BalanceSheet_LoadFromFile(const char* inPath) {
     if (!sheetMap) { return false; }
 
+    pthread_mutex_lock(&g_sheetLock);
     char inFile[512];
     strcpy(inFile, inPath);
     strcat(inFile, "/balance_sheet.data");
     FILE* file = fopen(inFile, "rb");
-    if (!file) { return false; }
+    if (!file) {
+        pthread_mutex_unlock(&g_sheetLock);
+        return false;
+    }
 
     balance_sheet_entry_t entry;
     while (fread(&entry, sizeof(balance_sheet_entry_t), 1, file) == 1) {
-        if (BalanceSheet_Insert(entry) < 0) {
+        if (BalanceSheet_InsertLocked(entry) < 0) {
             fclose(file);
+            pthread_mutex_unlock(&g_sheetLock);
             return false;
         }
     }
 
     fclose(file);
+    pthread_mutex_unlock(&g_sheetLock);
     return true;
 }
 
 void BalanceSheet_Print() {
     if (!sheetMap) { return; }
 
+    pthread_mutex_lock(&g_sheetLock);
     // Iterate through every entry
     khiter_t k;
     for (k = kh_begin(sheetMap); k != kh_end(sheetMap); ++k) {
@@ -107,9 +269,72 @@ void BalanceSheet_Print() {
                 balanceStr);
         }
     }
+    pthread_mutex_unlock(&g_sheetLock);
 }
 
 void BalanceSheet_Destroy() {
     kh_destroy(balance_sheet_map_m, sheetMap);
     sheetMap = NULL;
+    pthread_mutex_destroy(&g_sheetLock);
+}
+
+bool BalanceSheet_SelectSpendableTransactions(
+    const signed_transaction_t* candidates,
+    size_t candidateCount,
+    signed_transaction_t** outAccepted,
+    size_t* outAcceptedCount,
+    uint64_t* outTotalFees
+) {
+    if (!outAccepted || !outAcceptedCount || !outTotalFees) {
+        return false;
+    }
+
+    *outAccepted = NULL;
+    *outAcceptedCount = 0;
+    *outTotalFees = 0;
+
+    if (!candidates || candidateCount == 0) {
+        return true;
+    }
+
+    signed_transaction_t* accepted = (signed_transaction_t*)calloc(candidateCount, sizeof(signed_transaction_t));
+    if (!accepted) {
+        return false;
+    }
+
+    khash_t(balance_sheet_map_m)* simMap = kh_init(balance_sheet_map_m);
+    if (!simMap) {
+        free(accepted);
+        return false;
+    }
+
+    size_t acceptedCount = 0;
+    uint64_t totalFees = 0;
+
+    for (size_t i = 0; i < candidateCount; ++i) {
+        const signed_transaction_t* tx = &candidates[i];
+        if (Address_IsCoinbase(tx->transaction.senderAddress)) {
+            continue;
+        }
+
+        uint64_t fee = 0;
+        if (!BalanceSheet_ApplyCandidateTransaction(simMap, tx, &fee)) {
+            continue;
+        }
+
+        accepted[acceptedCount++] = *tx;
+        totalFees += fee;
+    }
+
+    kh_destroy(balance_sheet_map_m, simMap);
+
+    if (acceptedCount == 0) {
+        free(accepted);
+        accepted = NULL;
+    }
+
+    *outAccepted = accepted;
+    *outAcceptedCount = acceptedCount;
+    *outTotalFees = totalFees;
+    return true;
 }

src/block/block.c

@@ -214,23 +214,99 @@ bool Block_AllTransactionsValid(const block_t* block) {
 
     for (size_t i = 0; i < DynArr_size(block->transactions); i++) {
         signed_transaction_t* tx = (signed_transaction_t*)DynArr_at(block->transactions, i);
+        if (!Transaction_Verify(tx)) {
+            return false;
+        }
+
         if (tx && Address_IsCoinbase(tx->transaction.senderAddress)) {
             if (hasCoinbase) {
-                return false; // More than one coinbase transaction
+                return false;
             }
 
             hasCoinbase = true;
-            continue; // Coinbase transactions are valid since the miner has the right to create coins. Only rule is one per block.
-        }
-        
-        if (!Transaction_Verify(tx)) {
-            return false;
         }
     }
 
     return true && hasCoinbase && DynArr_size(block->transactions) > 0; // Every block must have at least one transaction (the coinbase)
 }
 
+bool Block_ValidateCoinbaseAndFees(const block_t* block, uint64_t expectedCoinbaseAmount, uint64_t* outTotalFees) {
+    if (!block || !block->transactions) {
+        return false;
+    }
+
+    bool hasCoinbase = false;
+    uint64_t totalFees = 0;
+    uint8_t zeroAddress[32] = {0};
+
+    for (size_t i = 0; i < DynArr_size(block->transactions); ++i) {
+        signed_transaction_t* tx = (signed_transaction_t*)DynArr_at(block->transactions, i);
+        if (!tx) {
+            return false;
+        }
+
+        if (Address_IsCoinbase(tx->transaction.senderAddress)) {
+            if (hasCoinbase) {
+                return false;
+            }
+
+            hasCoinbase = true;
+
+            if (!Transaction_Verify(tx)) {
+                return false;
+            }
+
+            if (tx->transaction.fee != 0 || tx->transaction.amount2 != 0) {
+                return false;
+            }
+
+            if (tx->transaction.amount1 != expectedCoinbaseAmount) {
+                return false;
+            }
+
+            if (Address_IsCoinbase(tx->transaction.recipientAddress1)) {
+                return false;
+            }
+
+            if (memcmp(tx->transaction.recipientAddress2, zeroAddress, sizeof(zeroAddress)) != 0) {
+                return false;
+            }
+
+            continue;
+        }
+
+        if (!Transaction_Verify(tx)) {
+            return false;
+        }
+
+        if (UINT64_MAX - totalFees < tx->transaction.fee) {
+            return false;
+        }
+        totalFees += tx->transaction.fee;
+    }
+
+    if (!hasCoinbase) {
+        return false;
+    }
+
+    if (outTotalFees) {
+        *outTotalFees = totalFees;
+    }
+
+    return true;
+}
+
+bool Block_IsFullyValid(const block_t* block) {
+    bool merkleValid = false;
+    uint8_t calculatedMerkleRoot[32];
+    if (block && block->transactions) {
+        Block_CalculateMerkleRoot(block, calculatedMerkleRoot);
+        merkleValid = (memcmp(calculatedMerkleRoot, block->header.merkleRoot, 32) == 0);
+    }
+
+    return Block_HasValidProofOfWork(block) && Block_AllTransactionsValid(block) && DynArr_size(block->transactions) > 0 && merkleValid;
+}
+
 void Block_Destroy(block_t* block) {
     if (!block) return;
     DynArr_destroy(block->transactions);
@@ -274,3 +350,48 @@ void Block_Print(const block_t* block) {
         printf("No transactions (or none loaded)\n");
     }
 }
+
+void Block_ShortPrint(const block_t* block) {
+    if (!block) return;
+
+    printf("Block #%llu: Timestamp %llu, Nonce %llu, DiffTarget 0x%08x, Version %u, PrevHash %02x%02x...%02x%02x, MerkleRoot %02x%02x...%02x%02x, TxCount %zu\n",
+        (unsigned long long)block->header.blockNumber,
+        (unsigned long long)block->header.timestamp,
+        (unsigned long long)block->header.nonce,
+        block->header.difficultyTarget,
+        block->header.version,
+        block->header.prevHash[0], block->header.prevHash[1], block->header.prevHash[30], block->header.prevHash[31],
+        block->header.merkleRoot[0], block->header.merkleRoot[1], block->header.merkleRoot[30], block->header.merkleRoot[31],
+        block->transactions ? DynArr_size(block->transactions) : 0);
+}
+
+block_t* Block_Copy(const block_t* src) {
+    if (!src) return NULL;
+    block_t* dst = (block_t*)malloc(sizeof(block_t));
+    if (!dst) return NULL;
+    dst->header = src->header;
+    if (src->transactions) {
+        size_t txCount = DynArr_size(src->transactions);
+        dst->transactions = DYNARR_CREATE(signed_transaction_t, txCount == 0 ? 1 : txCount);
+        if (!dst->transactions) {
+            free(dst);
+            return NULL;
+        }
+        for (size_t i = 0; i < txCount; ++i) {
+            signed_transaction_t* tx = (signed_transaction_t*)DynArr_at(src->transactions, i);
+            if (!tx) {
+                DynArr_destroy(dst->transactions);
+                free(dst);
+                return NULL;
+            }
+            if (!DynArr_push_back(dst->transactions, tx)) {
+                DynArr_destroy(dst->transactions);
+                free(dst);
+                return NULL;
+            }
+        }
+    } else {
+        dst->transactions = NULL;
+    }
+    return dst;
+}

src/block/chain.c

@@ -1,8 +1,11 @@
 #include <block/chain.h>
 #include <constants.h>
+#include <runtime_state.h>
+#include <txmempool.h>
 #include <errno.h>
 #include <limits.h>
 #include <sys/stat.h>
+#include <pthread.h>
 
 uint64_t currentBlockHeight = 0;
 
@@ -95,6 +98,37 @@ static bool DebitAddress(const uint8_t address[32], const uint256_t* amount) {
     return BalanceSheet_Insert(entry) >= 0;
 }
 
+bool Chain_RecomputeRuntimeState(blockchain_t* chain) {
+    if (!chain) {
+        return false;
+    }
+
+    uint256_t rebuiltSupply = uint256_from_u64(0);
+    for (size_t i = 0; i < chain->size; ++i) {
+        block_t* blk = (block_t*)DynArr_at(chain->blocks, i);
+        if (!blk || !blk->transactions) {
+            return false;
+        }
+
+        for (size_t j = 0; j < DynArr_size(blk->transactions); ++j) {
+            signed_transaction_t* tx = (signed_transaction_t*)DynArr_at(blk->transactions, j);
+            if (!tx) {
+                return false;
+            }
+
+            if (Address_IsCoinbase(tx->transaction.senderAddress)) {
+                if (uint256_add_u64(&rebuiltSupply, tx->transaction.amount1)) {
+                    return false;
+                }
+            }
+        }
+    }
+
+    currentSupply = rebuiltSupply;
+    currentReward = CalculateBlockReward(currentSupply, chain);
+    return true;
+}
+
 static void Chain_ClearBlocks(blockchain_t* chain) {
     if (!chain || !chain->blocks) {
         return;
@@ -135,6 +169,8 @@ void Chain_Destroy(blockchain_t* chain) {
 }
 
 bool Chain_AddBlock(blockchain_t* chain, block_t* block) {
+    bool ok = true;
+
     if (!chain || !block || !chain->blocks) {
         return false;
     }
@@ -143,96 +179,209 @@ bool Chain_AddBlock(blockchain_t* chain, block_t* block) {
         return false;
     }
 
-    // First pass: ensure all non-coinbase senders can cover the full spend
-    // (amount1 + amount2 + fee) before mutating the chain or balance sheet.
-    size_t txCount = DynArr_size(block->transactions);
-    for (size_t i = 0; i < txCount; ++i) {
-        signed_transaction_t* tx = (signed_transaction_t*)DynArr_at(block->transactions, i);
-        if (!tx) {
-            return false;
-        }
+    // Acquire global write locks to protect chain and balance sheet mutations.
+    pthread_rwlock_wrlock(&chainLock);
+    pthread_mutex_lock(&balanceSheetLock);
 
-        if (Address_IsCoinbase(tx->transaction.senderAddress)) {
-            continue;
-        }
-
-        uint256_t spend;
-        if (!BuildSpendAmount(tx, &spend)) {
-            return false;
-        }
-
-        balance_sheet_entry_t senderEntry;
-        if (!BalanceSheet_Lookup(tx->transaction.senderAddress, &senderEntry)) {
-            fprintf(stderr, "Error: Sender address not found in balance sheet during block addition. Bailing!\n");
-            return false;
-        }
-
-        if (uint256_cmp(&senderEntry.balance, &spend) < 0) {
-            fprintf(stderr, "Error: Sender balance insufficient for block transaction. Bailing!\n");
-            return false;
-        }
-    }
-
-    // Push the block only after validation succeeds.
-    block_t* blk = (block_t*)DynArr_push_back(chain->blocks, block);
-    if (!blk) {
+    // Ensure the incoming block's header.blockNumber matches the index it will be appended at.
+    size_t expectedIndex = DynArr_size(chain->blocks);
+    if (block->header.blockNumber != expectedIndex) {
+        // Mismatched block number; reject to avoid duplicate indices or inconsistent headers.
+        pthread_mutex_unlock(&balanceSheetLock);
+        pthread_rwlock_unlock(&chainLock);
         return false;
     }
-    chain->size++;
-    currentBlockHeight = (uint64_t)(chain->size - 1);
 
-    // Second pass: apply the ledger changes.
-    if (blk->transactions) {
-        txCount = DynArr_size(blk->transactions);
+    do {
+        size_t txCount = DynArr_size(block->transactions);
+        signed_transaction_t* candidateTxs = (signed_transaction_t*)calloc(txCount, sizeof(signed_transaction_t));
+        if (!candidateTxs) {
+            ok = false;
+            break;
+        }
+
+        size_t nonCoinbaseCount = 0;
         for (size_t i = 0; i < txCount; ++i) {
-            signed_transaction_t* tx = (signed_transaction_t*)DynArr_at(blk->transactions, i);
+            signed_transaction_t* tx = (signed_transaction_t*)DynArr_at(block->transactions, i);
             if (!tx) {
-                continue;
+                ok = false;
+                break;
             }
 
+            candidateTxs[i] = *tx;
             if (!Address_IsCoinbase(tx->transaction.senderAddress)) {
-                uint256_t spend;
-                if (!BuildSpendAmount(tx, &spend) || !DebitAddress(tx->transaction.senderAddress, &spend)) {
-                    fprintf(stderr, "Error: Failed to debit sender balance during block addition. Bailing!\n");
-                    return false;
+                ++nonCoinbaseCount;
+            }
+        }
+
+        if (!ok) {
+            free(candidateTxs);
+            break;
+        }
+
+        signed_transaction_t* spendableTxs = NULL;
+        size_t spendableCount = 0;
+        uint64_t totalFees = 0;
+        if (!BalanceSheet_SelectSpendableTransactions(candidateTxs, txCount, &spendableTxs, &spendableCount, &totalFees)) {
+            free(candidateTxs);
+            ok = false;
+            break;
+        }
+
+        free(candidateTxs);
+
+        if (spendableCount != nonCoinbaseCount) {
+            free(spendableTxs);
+            ok = false;
+            break;
+        }
+
+        uint64_t expectedCoinbaseAmount = currentReward;
+        if (UINT64_MAX - expectedCoinbaseAmount < totalFees) {
+            free(spendableTxs);
+            ok = false;
+            break;
+        }
+        expectedCoinbaseAmount += totalFees;
+
+            // Debug: log expected coinbase and fees to aid diagnosis when nodes disagree
+            {
+                uint64_t cbAmount = 0;
+                if (block->transactions && DynArr_size(block->transactions) > 0) {
+                    signed_transaction_t* firstTx = (signed_transaction_t*)DynArr_at(block->transactions, 0);
+                    if (firstTx && Address_IsCoinbase(firstTx->transaction.senderAddress)) {
+                        cbAmount = firstTx->transaction.amount1;
+                    }
                 }
+                char supplyStr[80];
+                Uint256ToDecimal(&currentSupply, supplyStr, sizeof(supplyStr));
+                printf("Chain_AddBlock: blockIndex=%zu expectedCoinbase=%llu totalFees=%llu observedBlockCoinbase=%llu currentReward=%llu currentSupply=%s\n",
+                    expectedIndex,
+                    (unsigned long long)expectedCoinbaseAmount,
+                    (unsigned long long)totalFees,
+                    (unsigned long long)cbAmount,
+                    (unsigned long long)currentReward,
+                    supplyStr);
             }
 
-            if (!CreditAddress(tx->transaction.recipientAddress1, tx->transaction.amount1)) {
-                fprintf(stderr, "Error: Failed to credit recipient1 balance during block addition. Bailing!\n");
-                return false;
-            }
+        uint64_t observedFees = 0;
+        if (!Block_ValidateCoinbaseAndFees(block, expectedCoinbaseAmount, &observedFees) || observedFees != totalFees) {
+            // Log mismatch details for debugging
+            printf("Chain_AddBlock: validation failed: expectedCoinbase=%llu totalFees=%llu observedFees=%llu\n",
+                (unsigned long long)expectedCoinbaseAmount,
+                (unsigned long long)totalFees,
+                (unsigned long long)observedFees);
+            free(spendableTxs);
+            ok = false;
+            break;
+        }
 
-            if (tx->transaction.amount2 > 0) {
-                uint8_t zeroAddress[32] = {0};
-                if (memcmp(tx->transaction.recipientAddress2, zeroAddress, 32) == 0) {
-                    fprintf(stderr, "Error: amount2 is non-zero but recipient2 is empty during block addition. Bailing!\n");
-                    return false;
+        free(spendableTxs);
+
+        // Push the block only after validation succeeds.
+        block_t* blk = (block_t*)DynArr_push_back(chain->blocks, block);
+        if (!blk) { ok = false; break; }
+        chain->size++;
+        currentBlockHeight = (uint64_t)(chain->size - 1);
+
+        // Second pass: apply the ledger changes.
+        if (blk->transactions) {
+            txCount = DynArr_size(blk->transactions);
+            for (size_t i = 0; i < txCount; ++i) {
+                signed_transaction_t* tx = (signed_transaction_t*)DynArr_at(blk->transactions, i);
+                if (!tx) {
+                    continue;
                 }
 
-                if (!CreditAddress(tx->transaction.recipientAddress2, tx->transaction.amount2)) {
-                    fprintf(stderr, "Error: Failed to credit recipient2 balance during block addition. Bailing!\n");
-                    return false;
+                if (!Address_IsCoinbase(tx->transaction.senderAddress)) {
+                    uint256_t spend;
+                    if (!BuildSpendAmount(tx, &spend) || !DebitAddress(tx->transaction.senderAddress, &spend)) {
+                        fprintf(stderr, "Error: Failed to debit sender balance during block addition. Bailing!\n");
+                        ok = false; break;
+                    }
+                }
+
+                    if (!CreditAddress(tx->transaction.recipientAddress1, tx->transaction.amount1)) {
+                    fprintf(stderr, "Error: Failed to credit recipient1 balance during block addition. Bailing!\n");
+                    ok = false; break;
+                }
+
+                if (tx->transaction.amount2 > 0) {
+                    uint8_t zeroAddress[32] = {0};
+                    if (memcmp(tx->transaction.recipientAddress2, zeroAddress, 32) == 0) {
+                        fprintf(stderr, "Error: amount2 is non-zero but recipient2 is empty during block addition. Bailing!\n");
+                        ok = false; break;
+                    }
+
+                    if (!CreditAddress(tx->transaction.recipientAddress2, tx->transaction.amount2)) {
+                        fprintf(stderr, "Error: Failed to credit recipient2 balance during block addition. Bailing!\n");
+                        ok = false; break;
+                    }
                 }
             }
         }
-    }
 
-    return true;
+        // Remove mined non-coinbase transactions from the mempool so they are not re-mined or re-broadcast.
+        if (blk->transactions) {
+            for (size_t i = 0; i < DynArr_size(blk->transactions); ++i) {
+                signed_transaction_t* tx = (signed_transaction_t*)DynArr_at(blk->transactions, i);
+                if (!tx) continue;
+                if (Address_IsCoinbase(tx->transaction.senderAddress)) continue;
+                uint8_t txHash[32];
+                Transaction_CalculateHash(tx, txHash);
+                if (TxMempool_Remove(txHash)) {
+                    // optional: log removal
+                    // printf("TxMempool_Remove: removed tx from mempool: "); PrintHexBytes(txHash, 32); printf("\n");
+                }
+            }
+        }
+        // ok remains true if no failures
+    } while (0);
+
+    // Release locks
+    pthread_mutex_unlock(&balanceSheetLock);
+    pthread_rwlock_unlock(&chainLock);
+
+    printf("Added new block to chain:\n");
+    Block_ShortPrint(block);
+
+    /* Debug proof removed: coinbase == baseReward + totalFees was printed here during debugging. */
+
+    return ok;
 }
 
 block_t* Chain_GetBlock(blockchain_t* chain, size_t index) {
-    if (chain) {
-        return DynArr_at(chain->blocks, index);
+    if (!chain) return NULL;
+    block_t* blk = NULL;
+    pthread_rwlock_rdlock(&chainLock);
+    blk = (block_t*)DynArr_at(chain->blocks, index);
+    pthread_rwlock_unlock(&chainLock);
+    return blk;
+}
+
+bool Chain_GetBlockCopy(blockchain_t* chain, size_t index, block_t** outCopy) {
+    if (!chain || !outCopy) return false;
+    *outCopy = NULL;
+    pthread_rwlock_rdlock(&chainLock);
+    block_t* src = (block_t*)DynArr_at(chain->blocks, index);
+    if (!src) {
+        pthread_rwlock_unlock(&chainLock);
+        return false;
     }
-    return NULL;
+    block_t* copy = Block_Copy(src);
+    pthread_rwlock_unlock(&chainLock);
+    if (!copy) return false;
+    *outCopy = copy;
+    return true;
 }
 
 size_t Chain_Size(blockchain_t* chain) {
-    if (chain) {
-        return DynArr_size(chain->blocks);
-    }
-    return 0;
+    if (!chain) return 0;
+    size_t sz = 0;
+    pthread_rwlock_rdlock(&chainLock);
+    sz = DynArr_size(chain->blocks);
+    pthread_rwlock_unlock(&chainLock);
+    return sz;
 }
 
 bool Chain_IsValid(blockchain_t* chain) {
@@ -271,6 +420,137 @@ bool Chain_IsValid(blockchain_t* chain) {
     return true;
 }
 
+bool Chain_RollbackToHeight(blockchain_t* chain, size_t height) {
+    if (!chain || !chain->blocks) return false;
+
+    pthread_rwlock_wrlock(&chainLock);
+    pthread_mutex_lock(&balanceSheetLock);
+
+    size_t cur = DynArr_size(chain->blocks);
+    if (height >= cur) {
+        pthread_mutex_unlock(&balanceSheetLock);
+        pthread_rwlock_unlock(&chainLock);
+        return true; // nothing to do
+    }
+
+    // Remove blocks above height
+    for (size_t i = cur; i > height; --i) {
+        size_t idx = i - 1;
+        block_t* blk = (block_t*)DynArr_at(chain->blocks, idx);
+        if (blk && blk->transactions) {
+            DynArr_destroy(blk->transactions);
+            blk->transactions = NULL;
+        }
+        DynArr_remove(chain->blocks, idx);
+    }
+
+    chain->size = DynArr_size(chain->blocks);
+    currentBlockHeight = chain->size ? (uint64_t)(chain->size - 1) : 0ULL;
+
+    // Rebuild balance sheet from scratch up to current chain size
+    BalanceSheet_Destroy();
+    BalanceSheet_Init();
+
+    for (size_t i = 0; i < chain->size; ++i) {
+        block_t* blk = (block_t*)DynArr_at(chain->blocks, i);
+        block_t* toProcess = blk;
+        bool loaded = false;
+
+        if (!blk || !blk->transactions) {
+            // Try to load from disk
+            block_t* loadedBlk = NULL;
+            size_t txCount = 0;
+            if (!Chain_LoadBlockFromFile(chainDataDir, (uint64_t)i, true, &loadedBlk, &txCount)) {
+                // Can't rebuild without transactions
+                pthread_mutex_unlock(&balanceSheetLock);
+                pthread_rwlock_unlock(&chainLock);
+                return false;
+            }
+            toProcess = loadedBlk;
+            loaded = true;
+        }
+
+        // Apply transactions
+        if (toProcess && toProcess->transactions) {
+            size_t txCount = DynArr_size(toProcess->transactions);
+            for (size_t ti = 0; ti < txCount; ++ti) {
+                signed_transaction_t* tx = (signed_transaction_t*)DynArr_at(toProcess->transactions, ti);
+                if (!tx) continue;
+
+                // Coinbase credit
+                if (Address_IsCoinbase(tx->transaction.senderAddress)) {
+                    balance_sheet_entry_t entry;
+                    if (!BalanceSheet_Lookup(tx->transaction.recipientAddress1, &entry)) {
+                        memset(&entry, 0, sizeof(entry));
+                        memcpy(entry.address, tx->transaction.recipientAddress1, 32);
+                        entry.balance = uint256_from_u64(tx->transaction.amount1);
+                    } else {
+                        (void)uint256_add_u64(&entry.balance, tx->transaction.amount1);
+                    }
+                    (void)BalanceSheet_Insert(entry);
+                    continue;
+                }
+
+                // Non-coinbase: debit sender
+                uint256_t spend = uint256_from_u64(0);
+                (void)uint256_add_u64(&spend, tx->transaction.amount1);
+                if (tx->transaction.amount2 > 0) (void)uint256_add_u64(&spend, tx->transaction.amount2);
+                if (tx->transaction.fee > 0) (void)uint256_add_u64(&spend, tx->transaction.fee);
+
+                balance_sheet_entry_t senderEntry;
+                if (!BalanceSheet_Lookup(tx->transaction.senderAddress, &senderEntry)) {
+                    // Missing sender; create zero and then subtract (will underflow if invalid)
+                    memset(&senderEntry, 0, sizeof(senderEntry));
+                    memcpy(senderEntry.address, tx->transaction.senderAddress, 32);
+                    senderEntry.balance = uint256_from_u64(0);
+                }
+                (void)uint256_subtract(&senderEntry.balance, &spend);
+                (void)BalanceSheet_Insert(senderEntry);
+
+                // Credit recipient1
+                balance_sheet_entry_t rec1;
+                if (!BalanceSheet_Lookup(tx->transaction.recipientAddress1, &rec1)) {
+                    memset(&rec1, 0, sizeof(rec1));
+                    memcpy(rec1.address, tx->transaction.recipientAddress1, 32);
+                    rec1.balance = uint256_from_u64(tx->transaction.amount1);
+                } else {
+                    (void)uint256_add_u64(&rec1.balance, tx->transaction.amount1);
+                }
+                (void)BalanceSheet_Insert(rec1);
+
+                // Credit recipient2 if any
+                if (tx->transaction.amount2 > 0) {
+                    balance_sheet_entry_t rec2;
+                    if (!BalanceSheet_Lookup(tx->transaction.recipientAddress2, &rec2)) {
+                        memset(&rec2, 0, sizeof(rec2));
+                        memcpy(rec2.address, tx->transaction.recipientAddress2, 32);
+                        rec2.balance = uint256_from_u64(tx->transaction.amount2);
+                    } else {
+                        (void)uint256_add_u64(&rec2.balance, tx->transaction.amount2);
+                    }
+                    (void)BalanceSheet_Insert(rec2);
+                }
+            }
+        }
+
+        if (loaded && toProcess) {
+            if (toProcess->transactions) DynArr_destroy(toProcess->transactions);
+            free(toProcess);
+        }
+    }
+
+    if (!Chain_RecomputeRuntimeState(chain)) {
+        pthread_mutex_unlock(&balanceSheetLock);
+        pthread_rwlock_unlock(&chainLock);
+        return false;
+    }
+
+    pthread_mutex_unlock(&balanceSheetLock);
+    pthread_rwlock_unlock(&chainLock);
+
+    return true;
+}
+
 void Chain_Wipe(blockchain_t* chain) {
     Chain_ClearBlocks(chain);
     currentBlockHeight = 0;
@@ -298,112 +578,134 @@ bool Chain_SaveToFile(blockchain_t* chain, const char* dirpath, uint256_t curren
     if (!BuildPath(tablePath, sizeof(tablePath), dirpath, "chain.table")) {
         return false;
     }
-    
-    // Find metadata file (create if not exists) to get the saved chain size (+ other things)
-    FILE* metaFile = fopen(metaPath, "rb+");
-    FILE* chainFile = fopen(chainPath, "rb+");
-    FILE* tableFile = fopen(tablePath, "rb+");
+
+    char metaTmpPath[512];
+    char chainTmpPath[512];
+    char tableTmpPath[512];
+    if (!BuildPath(metaTmpPath, sizeof(metaTmpPath), dirpath, "chain.meta.tmp") ||
+        !BuildPath(chainTmpPath, sizeof(chainTmpPath), dirpath, "chain.data.tmp") ||
+        !BuildPath(tableTmpPath, sizeof(tableTmpPath), dirpath, "chain.table.tmp")) {
+        return false;
+    }
+
+    pthread_rwlock_wrlock(&chainLock);
+
+    FILE* metaFile = fopen(metaTmpPath, "wb+");
+    FILE* chainFile = fopen(chainTmpPath, "wb+");
+    FILE* tableFile = fopen(tableTmpPath, "wb+");
     if (!metaFile || !chainFile || !tableFile) {
-        // Just overwrite everything
-        metaFile = fopen(metaPath, "wb+");
-        if (!metaFile) { return false; }
-
-        // Initialize metadata with size 0
-        size_t initialSize = 0;
-        fwrite(&initialSize, sizeof(size_t), 1, metaFile);
-        // Write last block hash (32 bytes of zeros for now)
-        uint8_t zeroHash[32] = {0};
-        fwrite(zeroHash, sizeof(uint8_t), 32, metaFile);
-        uint256_t zeroSupply = {0};
-        fwrite(&zeroSupply, sizeof(uint256_t), 1, metaFile);
-        uint32_t initialTarget = INITIAL_DIFFICULTY;
-        fwrite(&initialTarget, sizeof(uint32_t), 1, metaFile);
-        uint64_t initialReward = 0;
-        fwrite(&initialReward, sizeof(uint64_t), 1, metaFile);
-
-        chainFile = fopen(chainPath, "wb+");
-        if (!chainFile) { return false; }
-
-        tableFile = fopen(tablePath, "wb+");
-        if (!tableFile) { return false; }
-
-        // TODO: Potentially some other things here, we'll see
-    }
-
-    // Read
-    size_t savedSize = 0;
-    fread(&savedSize, sizeof(size_t), 1, metaFile);
-    uint8_t lastSavedHash[32];
-    fread(lastSavedHash, sizeof(uint8_t), 32, metaFile);
-
-    // Assume chain saved is valid, and that the chain in memory is valid (as LoadFromFile will verify the saved one)
-    if (savedSize > DynArr_size(chain->blocks)) {
-        // Saved chain is longer than current chain, this should not happen if we are always saving the current chain, but just in case, fail to save to avoid overwriting a potentially valid longer chain with a shorter one.
-        fclose(metaFile);
-        fclose(chainFile);
-        fclose(tableFile);
+        if (metaFile) fclose(metaFile);
+        if (chainFile) fclose(chainFile);
+        if (tableFile) fclose(tableFile);
+        pthread_rwlock_unlock(&chainLock);
+        remove(metaTmpPath);
+        remove(chainTmpPath);
+        remove(tableTmpPath);
         return false;
     }
 
-    // Filename format: dirpath/chain.data
-    // File format: ([block_header][num_transactions][transactions...])[*length] - since block_header is fixed size, LoadFromFile will only read those by default
-
-    fseek(chainFile, 0, SEEK_END); // Seek to the end of those files
-    fseek(tableFile, 0, SEEK_END);
-    long pos = ftell(chainFile);
-    if (pos < 0) {
-        fclose(metaFile);
-        fclose(chainFile);
-        fclose(tableFile);
-        return false;
-    }
-
-    uint64_t byteCount = (uint64_t)pos; // Get the size
-
-    // Save blocks that are not yet saved
-    for (size_t i = savedSize; i < DynArr_size(chain->blocks); i++) {
+    const size_t chainSize = DynArr_size(chain->blocks);
+    uint64_t byteCount = 0;
+    for (size_t i = 0; i < chainSize; ++i) {
         block_t* blk = (block_t*)DynArr_at(chain->blocks, i);
         if (!blk) {
             fclose(metaFile);
             fclose(chainFile);
             fclose(tableFile);
+            pthread_rwlock_unlock(&chainLock);
+            remove(metaTmpPath);
+            remove(chainTmpPath);
+            remove(tableTmpPath);
             return false;
         }
 
-        uint64_t preIncrementByteSize = byteCount;
-
-        // Construct file path
-        // Write block header
-        fwrite(&blk->header, sizeof(block_header_t), 1, chainFile);
-        size_t txSize = DynArr_size(blk->transactions);
-        fwrite(&txSize, sizeof(size_t), 1, chainFile); // Write number of transactions
-        byteCount += sizeof(block_header_t) + sizeof(size_t);
-        // Write transactions
-        for (size_t j = 0; j < txSize; j++) {
-            signed_transaction_t* tx = (signed_transaction_t*)DynArr_at(blk->transactions, j);
-            if (fwrite(tx, sizeof(signed_transaction_t), 1, chainFile) != 1) {
-                fclose(chainFile);
+        block_t* diskCopy = blk;
+        bool loadedTemp = false;
+        if (!diskCopy->transactions) {
+            if (!Chain_LoadBlockFromFile(dirpath, (uint64_t)i, true, &diskCopy, NULL) || !diskCopy || !diskCopy->transactions) {
+                if (loadedTemp && diskCopy) {
+                    Block_Destroy(diskCopy);
+                }
                 fclose(metaFile);
+                fclose(chainFile);
                 fclose(tableFile);
+                pthread_rwlock_unlock(&chainLock);
+                remove(metaTmpPath);
+                remove(chainTmpPath);
+                remove(tableTmpPath);
                 return false;
             }
+            loadedTemp = true;
+        }
 
+        const uint64_t blockStart = byteCount;
+        if (fwrite(&diskCopy->header, sizeof(block_header_t), 1, chainFile) != 1) {
+            if (loadedTemp) Block_Destroy(diskCopy);
+            fclose(metaFile);
+            fclose(chainFile);
+            fclose(tableFile);
+            pthread_rwlock_unlock(&chainLock);
+            remove(metaTmpPath);
+            remove(chainTmpPath);
+            remove(tableTmpPath);
+            return false;
+        }
+
+        const size_t txSize = DynArr_size(diskCopy->transactions);
+        if (fwrite(&txSize, sizeof(size_t), 1, chainFile) != 1) {
+            if (loadedTemp) Block_Destroy(diskCopy);
+            fclose(metaFile);
+            fclose(chainFile);
+            fclose(tableFile);
+            pthread_rwlock_unlock(&chainLock);
+            remove(metaTmpPath);
+            remove(chainTmpPath);
+            remove(tableTmpPath);
+            return false;
+        }
+        byteCount += sizeof(block_header_t) + sizeof(size_t);
+
+        for (size_t j = 0; j < txSize; ++j) {
+            signed_transaction_t* tx = (signed_transaction_t*)DynArr_at(diskCopy->transactions, j);
+            if (!tx || fwrite(tx, sizeof(signed_transaction_t), 1, chainFile) != 1) {
+                if (loadedTemp) Block_Destroy(diskCopy);
+                fclose(metaFile);
+                fclose(chainFile);
+                fclose(tableFile);
+                pthread_rwlock_unlock(&chainLock);
+                remove(metaTmpPath);
+                remove(chainTmpPath);
+                remove(tableTmpPath);
+                return false;
+            }
             byteCount += sizeof(signed_transaction_t);
         }
 
-        // Create an entry in the block table
         block_table_entry_t entry;
         entry.blockNumber = i;
-        entry.byteNumber = preIncrementByteSize;
-        entry.blockSize = byteCount - preIncrementByteSize;
-        fwrite(&entry, sizeof(block_table_entry_t), 1, tableFile);
+        entry.byteNumber = blockStart;
+        entry.blockSize = byteCount - blockStart;
+        if (fwrite(&entry, sizeof(block_table_entry_t), 1, tableFile) != 1) {
+            if (loadedTemp) Block_Destroy(diskCopy);
+            fclose(metaFile);
+            fclose(chainFile);
+            fclose(tableFile);
+            pthread_rwlock_unlock(&chainLock);
+            remove(metaTmpPath);
+            remove(chainTmpPath);
+            remove(tableTmpPath);
+            return false;
+        }
 
-        DynArr_destroy(blk->transactions);
-        blk->transactions = NULL; // Clear transactions to save memory since they're now saved on disk
+        if (loadedTemp) {
+            Block_Destroy(diskCopy);
+        } else if (blk->transactions) {
+            DynArr_destroy(blk->transactions);
+            blk->transactions = NULL;
+        }
     }
 
-    // Update metadata with new size and last block hash
-    size_t newSize = DynArr_size(chain->blocks);
+    size_t newSize = chainSize;
     fseek(metaFile, 0, SEEK_SET);
     fwrite(&newSize, sizeof(size_t), 1, metaFile);
     uint32_t difficultyTarget = INITIAL_DIFFICULTY;
@@ -421,16 +723,23 @@ bool Chain_SaveToFile(blockchain_t* chain, const char* dirpath, uint256_t curren
     fwrite(&difficultyTarget, sizeof(uint32_t), 1, metaFile);
     fwrite(&currentReward, sizeof(uint64_t), 1, metaFile);
 
-    // Safety
     fflush(metaFile);
     fflush(chainFile);
     fflush(tableFile);
 
-    // Close all pointers
     fclose(metaFile);
     fclose(chainFile);
     fclose(tableFile);
 
+    if (rename(metaTmpPath, metaPath) != 0 || rename(chainTmpPath, chainPath) != 0 || rename(tableTmpPath, tablePath) != 0) {
+        pthread_rwlock_unlock(&chainLock);
+        remove(metaTmpPath);
+        remove(chainTmpPath);
+        remove(tableTmpPath);
+        return false;
+    }
+
+    pthread_rwlock_unlock(&chainLock);
     return true;
 }
 

src/block/transaction.c

@@ -42,7 +42,23 @@ bool Transaction_Verify(const signed_transaction_t* tx) {
     }
 
     if (Address_IsCoinbase(tx->transaction.senderAddress)) {
-        // Coinbase transactions are valid if the signature is correct for the block (handled in Block_Verify)
+        if (tx->transaction.amount1 == 0) {
+            return false;
+        }
+
+        if (tx->transaction.amount2 != 0) {
+            return false;
+        }
+
+        if (Address_IsCoinbase(tx->transaction.recipientAddress1) || Address_IsCoinbase(tx->transaction.recipientAddress2)) {
+            return false;
+        }
+
+        uint8_t zeroAddress[32] = {0};
+        if (memcmp(tx->transaction.recipientAddress2, zeroAddress, 32) != 0) {
+            return false;
+        }
+
         return true;
     }
 

src/nets/fetch_scheduler.c

@@ -0,0 +1,24 @@
+#include <nets/fetch_scheduler.h>
+#include <constants.h>
+#include <math.h>
+
+// Note: floating point is used intentionally here for readability and
+// because the final penalty is rounded to whole blocks. This keeps the
+// implementation straightforward while avoiding subtle integer overflow
+// for large exponents. If desired, replace with fixed-point arithmetic.
+uint64_t FetchScheduler_ComputeReorgPenaltyBlocks(uint64_t delayBlocks) {
+    if (delayBlocks <= REORG_PENALTY_GRACE_BLOCKS) {
+        return 0ULL;
+    }
+
+    double B = (double)delayBlocks;
+    double factor = REORG_PENALTY_FACTOR;
+    double exp = REORG_PENALTY_EXPONENT;
+    double timeScale = ((double)TARGET_BLOCK_TIME) / REORG_PENALTY_REF_BLOCK_TIME;
+
+    double raw = factor * pow(B, exp) * timeScale;
+    if (raw < 0.0) raw = 0.0;
+
+    uint64_t penalty = (uint64_t)ceil(raw);
+    return penalty;
+}

src/nets/nodediscovery.c

@@ -0,0 +1,472 @@
+#include <nets/nodediscovery.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+
+#include <constants.h>
+#include <dynarr.h>
+#include <numgen.h>
+#include <utils.h>
+
+// Wire layout of a single peer endpoint inside a PEERS payload:
+//   [uint8 family (4 or 6)][uint8 ip[16]][uint16 port (host order)]  -> 19 bytes
+// (Host-endian raw layout, consistent with the rest of the protocol.)
+#define DISCOVERY_WIRE_ENTRY_SIZE (1 + 16 + 2)
+
+typedef enum {
+    DISCOVERY_STATE_NEW = 0,      // learned, not yet pinged
+    DISCOVERY_STATE_PINGED,       // first ping in flight, reachability unknown
+    DISCOVERY_STATE_REACHABLE,    // pong received, latency known
+    DISCOVERY_STATE_CONNECTED,    // currently a live outbound connection
+    DISCOVERY_STATE_UNREACHABLE   // ping timed out
+} discovery_state_t;
+
+typedef struct {
+    struct sockaddr_storage addr;  // listen endpoint (port already set to the peer's listen port)
+    uint64_t pingMs;               // measured UDP RTT, UINT64_MAX if unknown
+    uint32_t hop;                  // distance from us (0 = directly connected)
+    discovery_state_t state;
+    int pingPending;               // 1 while a ping is outstanding (matched by address on pong/timeout).
+                                   // The UDP layer generates its own nonce, so we can't match by nonce here.
+    uint64_t lastPingMs;           // when we last sent a ping
+    uint64_t lastQueryMs;          // when we last sent GET_PEERS to it
+    uint64_t lastConnectMs;        // when we last attempted a connect to it
+} discovered_peer_t;
+
+struct node_discovery {
+    net_node_t* node;
+    udp_node_t* udpNode;
+    DynArr* peers;                 // of discovered_peer_t
+    pthread_mutex_t lock;
+};
+
+// ---- small helpers (most assume the caller holds disc->lock) ------------------------------
+
+static int Discovery_AddrEqual(const struct sockaddr_storage* a, const struct sockaddr_storage* b) {
+    if (a->ss_family != b->ss_family) return 0;
+    if (a->ss_family == AF_INET) {
+        const struct sockaddr_in* x = (const struct sockaddr_in*)a;
+        const struct sockaddr_in* y = (const struct sockaddr_in*)b;
+        return x->sin_port == y->sin_port &&
+               memcmp(&x->sin_addr, &y->sin_addr, sizeof(struct in_addr)) == 0;
+    }
+    if (a->ss_family == AF_INET6) {
+        const struct sockaddr_in6* x = (const struct sockaddr_in6*)a;
+        const struct sockaddr_in6* y = (const struct sockaddr_in6*)b;
+        return x->sin6_port == y->sin6_port &&
+               memcmp(&x->sin6_addr, &y->sin6_addr, sizeof(struct in6_addr)) == 0;
+    }
+    return 0;
+}
+
+static discovered_peer_t* Discovery_FindPtr(node_discovery_t* disc, const struct sockaddr_storage* addr) {
+    size_t n = DynArr_size(disc->peers);
+    for (size_t i = 0; i < n; ++i) {
+        discovered_peer_t* p = (discovered_peer_t*)DynArr_at(disc->peers, i);
+        if (Discovery_AddrEqual(&p->addr, addr)) return p;
+    }
+    return NULL;
+}
+
+// Insert addr if not already present. Returns a pointer to the (existing or new) entry, or NULL
+// if the table is full. Note: the returned pointer is invalidated by any later push_back.
+static discovered_peer_t* Discovery_Upsert(node_discovery_t* disc, const struct sockaddr_storage* addr, uint32_t hop) {
+    discovered_peer_t* existing = Discovery_FindPtr(disc, addr);
+    if (existing) {
+        if (hop < existing->hop) existing->hop = hop; // keep the shortest known distance
+        return existing;
+    }
+    if (DynArr_size(disc->peers) >= DISCOVERY_MAX_KNOWN_PEERS) return NULL;
+
+    discovered_peer_t np;
+    memset(&np, 0, sizeof(np));
+    np.addr = *addr;
+    np.pingMs = UINT64_MAX;
+    np.hop = hop;
+    np.state = DISCOVERY_STATE_NEW;
+    DynArr_push_back(disc->peers, &np);
+    return (discovered_peer_t*)DynArr_at(disc->peers, DynArr_size(disc->peers) - 1);
+}
+
+static int Discovery_AddrToWire(const struct sockaddr_storage* addr, unsigned char out[DISCOVERY_WIRE_ENTRY_SIZE]) {
+    memset(out, 0, DISCOVERY_WIRE_ENTRY_SIZE);
+    if (addr->ss_family == AF_INET) {
+        const struct sockaddr_in* a = (const struct sockaddr_in*)addr;
+        out[0] = 4;
+        memcpy(out + 1, &a->sin_addr, sizeof(struct in_addr));
+        uint16_t port = ntohs(a->sin_port);
+        memcpy(out + 1 + 16, &port, sizeof(port));
+        return 1;
+    }
+    if (addr->ss_family == AF_INET6) {
+        const struct sockaddr_in6* a = (const struct sockaddr_in6*)addr;
+        out[0] = 6;
+        memcpy(out + 1, &a->sin6_addr, sizeof(struct in6_addr));
+        uint16_t port = ntohs(a->sin6_port);
+        memcpy(out + 1 + 16, &port, sizeof(port));
+        return 1;
+    }
+    return 0;
+}
+
+static int Discovery_WireToAddr(const unsigned char in[DISCOVERY_WIRE_ENTRY_SIZE], struct sockaddr_storage* out) {
+    memset(out, 0, sizeof(*out));
+    uint8_t fam = in[0];
+    uint16_t port;
+    memcpy(&port, in + 1 + 16, sizeof(port));
+    if (fam == 4) {
+        struct sockaddr_in* a = (struct sockaddr_in*)out;
+        a->sin_family = AF_INET;
+        memcpy(&a->sin_addr, in + 1, sizeof(struct in_addr));
+        a->sin_port = htons(port);
+        return port != 0;
+    }
+    if (fam == 6) {
+        struct sockaddr_in6* a = (struct sockaddr_in6*)out;
+        a->sin6_family = AF_INET6;
+        memcpy(&a->sin6_addr, in + 1, sizeof(struct in6_addr));
+        a->sin6_port = htons(port);
+        return port != 0;
+    }
+    return 0;
+}
+
+static int Discovery_AddrToIpPort(const struct sockaddr_storage* addr, char* ipOut, size_t ipLen, unsigned short* portOut) {
+    if (addr->ss_family == AF_INET) {
+        const struct sockaddr_in* a = (const struct sockaddr_in*)addr;
+        if (!inet_ntop(AF_INET, &a->sin_addr, ipOut, (socklen_t)ipLen)) return 0;
+        *portOut = ntohs(a->sin_port);
+        return 1;
+    }
+    if (addr->ss_family == AF_INET6) {
+        const struct sockaddr_in6* a = (const struct sockaddr_in6*)addr;
+        if (!inet_ntop(AF_INET6, &a->sin6_addr, ipOut, (socklen_t)ipLen)) return 0;
+        *portOut = ntohs(a->sin6_port);
+        return 1;
+    }
+    return 0;
+}
+
+// ---- lifecycle ---------------------------------------------------------------------------
+
+node_discovery_t* NodeDiscovery_Create(net_node_t* node, udp_node_t* udpNode) {
+    if (!node || !udpNode) return NULL;
+    node_discovery_t* disc = (node_discovery_t*)malloc(sizeof(node_discovery_t));
+    if (!disc) return NULL;
+    memset(disc, 0, sizeof(*disc));
+    disc->node = node;
+    disc->udpNode = udpNode;
+    disc->peers = DYNARR_CREATE(discovered_peer_t, 16);
+    if (!disc->peers) {
+        free(disc);
+        return NULL;
+    }
+    pthread_mutex_init(&disc->lock, NULL);
+    return disc;
+}
+
+void NodeDiscovery_Destroy(node_discovery_t* disc) {
+    if (!disc) return;
+    if (disc->peers) DynArr_destroy(disc->peers);
+    pthread_mutex_destroy(&disc->lock);
+    free(disc);
+}
+
+// ---- UDP latency callbacks ---------------------------------------------------------------
+
+void NodeDiscovery_OnPong(node_discovery_t* disc, const struct sockaddr_storage* from, uint64_t nonce, uint64_t rttMs) {
+    if (!disc || !from) return;
+    (void)nonce; // UDP layer owns the nonce; we match the peer by its reply address instead.
+    pthread_mutex_lock(&disc->lock);
+    discovered_peer_t* p = Discovery_FindPtr(disc, from);
+    if (p && p->pingPending) {
+        p->pingMs = rttMs;
+        p->pingPending = 0;
+        if (p->state == DISCOVERY_STATE_PINGED) p->state = DISCOVERY_STATE_REACHABLE;
+    }
+    pthread_mutex_unlock(&disc->lock);
+}
+
+void NodeDiscovery_OnPingTimeout(node_discovery_t* disc, const struct sockaddr_storage* dest, uint64_t nonce) {
+    if (!disc || !dest) return;
+    (void)nonce; // matched by the destination address we pinged
+    pthread_mutex_lock(&disc->lock);
+    discovered_peer_t* p = Discovery_FindPtr(disc, dest);
+    if (p && p->pingPending) {
+        p->pingPending = 0;
+        // Only demote a peer whose reachability was still unknown; a refresh ping that times
+        // out on an already-connected/reachable peer must not drop it.
+        if (p->state == DISCOVERY_STATE_PINGED) p->state = DISCOVERY_STATE_UNREACHABLE;
+    }
+    pthread_mutex_unlock(&disc->lock);
+}
+
+// ---- TCP peer exchange -------------------------------------------------------------------
+
+void NodeDiscovery_OnGetPeers(node_discovery_t* disc, tcp_connection_t* fromConn) {
+    if (!disc || !fromConn) return;
+
+    // Snapshot our current peers' listen endpoints (inbound + outbound).
+    struct sockaddr_storage all[MAX_CONS * 2];
+    size_t total = Node_GetPeerEndpoints(disc->node, all, sizeof(all) / sizeof(all[0]));
+
+    struct sockaddr_storage reqEndpoint;
+    int haveReq = Node_ConnListenEndpoint(fromConn, &reqEndpoint);
+
+    // Build the response payload: [uint16 count][entries...], capped and sampled for spread.
+    unsigned char payload[sizeof(uint16_t) + DISCOVERY_PEERS_RESPONSE_CAP * DISCOVERY_WIRE_ENTRY_SIZE];
+    size_t offset = sizeof(uint16_t);
+    uint16_t count = 0;
+
+    size_t startIdx = total ? (size_t)(random_four_byte() % total) : 0;
+    for (size_t k = 0; k < total && count < DISCOVERY_PEERS_RESPONSE_CAP; ++k) {
+        size_t idx = (startIdx + k) % total;
+        if (haveReq && Discovery_AddrEqual(&all[idx], &reqEndpoint)) continue; // don't tell them about themselves
+        unsigned char entry[DISCOVERY_WIRE_ENTRY_SIZE];
+        if (!Discovery_AddrToWire(&all[idx], entry)) continue;
+        memcpy(payload + offset, entry, DISCOVERY_WIRE_ENTRY_SIZE);
+        offset += DISCOVERY_WIRE_ENTRY_SIZE;
+        count++;
+    }
+    memcpy(payload, &count, sizeof(count));
+
+    Node_SendPacket(disc->node, fromConn, PACKET_TYPE_PEERS, payload, offset);
+}
+
+void NodeDiscovery_OnPeersReceived(node_discovery_t* disc, tcp_connection_t* fromConn, const unsigned char* payload, size_t payloadLen) {
+    if (!disc || !payload || payloadLen < sizeof(uint16_t)) return;
+
+    uint16_t count;
+    memcpy(&count, payload, sizeof(count));
+    size_t need = sizeof(uint16_t) + (size_t)count * DISCOVERY_WIRE_ENTRY_SIZE;
+    if (payloadLen < need) return; // malformed / truncated
+
+    // Determine the hop distance of the peer that answered, so its peers land one hop further out.
+    struct sockaddr_storage srcEndpoint;
+    int haveSrc = fromConn ? Node_ConnListenEndpoint(fromConn, &srcEndpoint) : 0;
+
+    pthread_mutex_lock(&disc->lock);
+
+    uint32_t srcHop = 0;
+    if (haveSrc) {
+        discovered_peer_t* srcp = Discovery_FindPtr(disc, &srcEndpoint);
+        if (srcp) srcHop = srcp->hop;
+    }
+    uint32_t newHop = srcHop + 1;
+
+    // Fold in at most DISCOVERY_FANOUT *new* endpoints (a couple per node -> keeps the crawl spread).
+    if (newHop <= DISCOVERY_MAX_HOPS) {
+        int added = 0;
+        for (uint16_t i = 0; i < count && added < DISCOVERY_FANOUT; ++i) {
+            const unsigned char* entry = payload + sizeof(uint16_t) + (size_t)i * DISCOVERY_WIRE_ENTRY_SIZE;
+            struct sockaddr_storage ep;
+            if (!Discovery_WireToAddr(entry, &ep)) continue;
+            if (Discovery_FindPtr(disc, &ep) != NULL) continue; // already known -> doesn't count toward fanout
+            if (Discovery_Upsert(disc, &ep, newHop) != NULL) added++;
+        }
+    }
+
+    pthread_mutex_unlock(&disc->lock);
+}
+
+// ---- periodic tick -----------------------------------------------------------------------
+
+void NodeDiscovery_Iterate(node_discovery_t* disc) {
+    if (!disc || !disc->node || !disc->udpNode) return;
+    uint64_t now = get_current_time_ms();
+
+    // Snapshot current outbound connections and their listen endpoints (used for querying and
+    // for the "already connected?" checks below).
+    tcp_connection_t* outConns[MAX_CONS];
+    size_t outCount = 0;
+    Node_GetClientList(disc->node, outConns, &outCount);
+
+    struct sockaddr_storage outEndpoints[MAX_CONS];
+    size_t outEpCount = 0;
+    for (size_t i = 0; i < outCount; ++i) {
+        struct sockaddr_storage ep;
+        if (Node_ConnListenEndpoint(outConns[i], &ep)) {
+            outEndpoints[outEpCount++] = ep;
+        }
+    }
+
+    // Deferred network actions, collected under the lock and executed after releasing it
+    // (Node_ConnectPeer / Node_SendPacket must not run while holding disc->lock).
+    tcp_connection_t* toQuery[MAX_CONS];
+    size_t toQueryCount = 0;
+    struct { char ip[INET6_ADDRSTRLEN]; unsigned short port; } toConnect[MAX_CONS];
+    size_t toConnectCount = 0;
+
+    pthread_mutex_lock(&disc->lock);
+
+    // 1. Seed: upsert connected (outbound) peers as CONNECTED at hop 0.
+    for (size_t i = 0; i < outEpCount; ++i) {
+        discovered_peer_t* p = Discovery_Upsert(disc, &outEndpoints[i], 0);
+        if (p) {
+            p->hop = 0;
+            p->state = DISCOVERY_STATE_CONNECTED;
+        }
+    }
+    // Demote entries still marked CONNECTED that are no longer in the outbound set.
+    {
+        size_t n = DynArr_size(disc->peers);
+        for (size_t i = 0; i < n; ++i) {
+            discovered_peer_t* p = (discovered_peer_t*)DynArr_at(disc->peers, i);
+            if (p->state != DISCOVERY_STATE_CONNECTED) continue;
+            int stillConnected = 0;
+            for (size_t j = 0; j < outEpCount; ++j) {
+                if (Discovery_AddrEqual(&p->addr, &outEndpoints[j])) { stillConnected = 1; break; }
+            }
+            if (!stillConnected) {
+                p->state = (p->pingMs != UINT64_MAX) ? DISCOVERY_STATE_REACHABLE : DISCOVERY_STATE_NEW;
+            }
+        }
+    }
+
+    // 2. Ping NEW peers (and refresh stale REACHABLE ones), capped per tick.
+    {
+        int pings = 0;
+        size_t n = DynArr_size(disc->peers);
+        for (size_t i = 0; i < n && pings < DISCOVERY_MAX_PINGS_PER_TICK; ++i) {
+            discovered_peer_t* p = (discovered_peer_t*)DynArr_at(disc->peers, i);
+            int shouldPing = 0;
+            if (!p->pingPending) {
+                if (p->state == DISCOVERY_STATE_NEW) {
+                    shouldPing = 1;
+                } else if (p->state == DISCOVERY_STATE_REACHABLE &&
+                           (now - p->lastPingMs) > DISCOVERY_PING_REFRESH_MS) {
+                    shouldPing = 1;
+                }
+            }
+            if (!shouldPing) continue;
+
+            p->pingPending = 1;
+            p->lastPingMs = now;
+            if (p->state == DISCOVERY_STATE_NEW) p->state = DISCOVERY_STATE_PINGED;
+            UdpNode_SendPing(disc->udpNode, &p->addr);
+            pings++;
+        }
+    }
+
+    // 3. Timeout backstop (in case the UDP layer's own timeout callback is missed).
+    {
+        size_t n = DynArr_size(disc->peers);
+        for (size_t i = 0; i < n; ++i) {
+            discovered_peer_t* p = (discovered_peer_t*)DynArr_at(disc->peers, i);
+            if (p->state == DISCOVERY_STATE_PINGED && p->pingPending &&
+                (now - p->lastPingMs) > DISCOVERY_PING_TIMEOUT_MS) {
+                p->pingPending = 0;
+                p->state = DISCOVERY_STATE_UNREACHABLE;
+            }
+        }
+    }
+
+    // 4. Query up to DISCOVERY_FANOUT connected peers with GET_PEERS, preferring the lowest ping
+    //    and skipping ones we queried recently or that are already at the hop horizon.
+    {
+        int queries = 0;
+        while (queries < DISCOVERY_FANOUT) {
+            size_t bestIdx = outCount;         // sentinel = none
+            uint64_t bestPing = UINT64_MAX;
+            for (size_t i = 0; i < outCount; ++i) {
+                struct sockaddr_storage ep;
+                if (!Node_ConnListenEndpoint(outConns[i], &ep)) continue;
+                discovered_peer_t* p = Discovery_FindPtr(disc, &ep);
+                if (!p) continue;
+                if (p->hop >= DISCOVERY_MAX_HOPS) continue;
+                if (p->lastQueryMs != 0 && (now - p->lastQueryMs) < DISCOVERY_QUERY_INTERVAL_MS) continue;
+                if (bestIdx == outCount || p->pingMs < bestPing) {
+                    bestIdx = i;
+                    bestPing = p->pingMs;
+                }
+            }
+            if (bestIdx == outCount) break; // nothing eligible
+
+            // Mark queried so it isn't picked again this tick, and queue the send.
+            struct sockaddr_storage ep;
+            if (Node_ConnListenEndpoint(outConns[bestIdx], &ep)) {
+                discovered_peer_t* p = Discovery_FindPtr(disc, &ep);
+                if (p) p->lastQueryMs = now;
+            }
+            toQuery[toQueryCount++] = outConns[bestIdx];
+            queries++;
+        }
+    }
+
+    // 5. Connect: pick REACHABLE, not-currently-connected, cooled-down peers with the lowest ping
+    //    until we reach the target connection count.
+    if (outCount < (size_t)DISCOVERY_TARGET_CONNECTIONS) {
+        size_t slots = (size_t)DISCOVERY_TARGET_CONNECTIONS - outCount;
+        for (size_t s = 0; s < slots && toConnectCount < MAX_CONS; ++s) {
+            discovered_peer_t* best = NULL;
+            size_t n = DynArr_size(disc->peers);
+            for (size_t i = 0; i < n; ++i) {
+                discovered_peer_t* p = (discovered_peer_t*)DynArr_at(disc->peers, i);
+                if (p->state != DISCOVERY_STATE_REACHABLE) continue;
+                if (p->lastConnectMs != 0 && (now - p->lastConnectMs) < DISCOVERY_CONNECT_RETRY_MS) continue;
+                int already = 0;
+                for (size_t j = 0; j < outEpCount; ++j) {
+                    if (Discovery_AddrEqual(&p->addr, &outEndpoints[j])) { already = 1; break; }
+                }
+                if (already) continue;
+                if (!best || p->pingMs < best->pingMs) best = p;
+            }
+            if (!best) break;
+
+            best->lastConnectMs = now; // reserve so it isn't picked again this tick
+            char ip[INET6_ADDRSTRLEN];
+            unsigned short port = 0;
+            if (Discovery_AddrToIpPort(&best->addr, ip, sizeof(ip), &port) && port != 0) {
+                strncpy(toConnect[toConnectCount].ip, ip, INET6_ADDRSTRLEN - 1);
+                toConnect[toConnectCount].ip[INET6_ADDRSTRLEN - 1] = '\0';
+                toConnect[toConnectCount].port = port;
+                toConnectCount++;
+            }
+        }
+    }
+
+    pthread_mutex_unlock(&disc->lock);
+
+    // Execute the deferred network actions outside the lock.
+    for (size_t i = 0; i < toQueryCount; ++i) {
+        Node_SendPacket(disc->node, toQuery[i], PACKET_TYPE_GET_PEERS, NULL, 0);
+    }
+    for (size_t i = 0; i < toConnectCount; ++i) {
+        printf("NodeDiscovery: connecting to discovered peer %s:%u\n", toConnect[i].ip, toConnect[i].port);
+        (void)Node_ConnectPeer(disc->node, toConnect[i].ip, toConnect[i].port);
+    }
+}
+
+// ---- diagnostics -------------------------------------------------------------------------
+
+void NodeDiscovery_PrintPeers(node_discovery_t* disc) {
+    if (!disc) {
+        printf("NodeDiscovery: not active\n");
+        return;
+    }
+
+    static const char* stateNames[] = { "NEW", "PINGED", "REACHABLE", "CONNECTED", "UNREACHABLE" };
+
+    pthread_mutex_lock(&disc->lock);
+    size_t n = DynArr_size(disc->peers);
+    printf("Known peers (%zu):\n", n);
+    for (size_t i = 0; i < n; ++i) {
+        discovered_peer_t* p = (discovered_peer_t*)DynArr_at(disc->peers, i);
+        char ip[INET6_ADDRSTRLEN] = {0};
+        unsigned short port = 0;
+        Discovery_AddrToIpPort(&p->addr, ip, sizeof(ip), &port);
+        const char* stateStr = (p->state <= DISCOVERY_STATE_UNREACHABLE) ? stateNames[p->state] : "?";
+        if (p->pingMs == UINT64_MAX) {
+            printf("  %-46s hop=%u state=%-11s ping=--\n", ip, p->hop, stateStr);
+        } else {
+            printf("  %-46s hop=%u state=%-11s ping=%" PRIu64 "ms\n", ip, p->hop, stateStr, p->pingMs);
+        }
+        (void)port; // port is part of ip endpoint identity; shown via connect logs
+    }
+    pthread_mutex_unlock(&disc->lock);
+}

src/nets/orphan_pool.c

@@ -0,0 +1,208 @@
+#include <nets/orphan_pool.h>
+#include <dynarr.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+typedef struct {
+    block_t* block;
+    uint64_t height;
+} orphan_entry_t;
+
+static DynArr* g_orphans = NULL;
+
+void OrphanPool_Init(void) {
+    if (g_orphans) return;
+    g_orphans = DYNARR_CREATE(orphan_entry_t, 16);
+}
+
+void OrphanPool_Destroy(void) {
+    if (!g_orphans) return;
+    size_t n = DynArr_size(g_orphans);
+    for (size_t i = 0; i < n; ++i) {
+        orphan_entry_t* e = (orphan_entry_t*)DynArr_at(g_orphans, i);
+        if (e && e->block) {
+            Block_Destroy(e->block);
+        }
+    }
+    DynArr_destroy(g_orphans);
+    g_orphans = NULL;
+}
+
+void OrphanPool_Insert(block_t* block, uint64_t height) {
+    if (!block) return;
+    if (!g_orphans) OrphanPool_Init();
+    orphan_entry_t e;
+    e.block = block;
+    e.height = height;
+    (void)DynArr_push_back(g_orphans, &e);
+}
+
+static size_t OrphanPool_TryAdoptBranch(blockchain_t* chain, uint64_t forkHeight) {
+    if (!g_orphans || !chain) return 0;
+
+    DynArr* seq = DYNARR_CREATE(block_t*, 8);
+    if (!seq) return 0;
+
+    size_t cursor = forkHeight;
+    while (1) {
+        bool found = false;
+        size_t count = DynArr_size(g_orphans);
+        for (size_t i = 0; i < count; ++i) {
+            orphan_entry_t* entry = (orphan_entry_t*)DynArr_at(g_orphans, i);
+            if (!entry || !entry->block) continue;
+            if (entry->height == cursor) {
+                (void)DynArr_push_back(seq, &entry->block);
+                found = true;
+                break;
+            }
+        }
+        if (!found) break;
+        cursor++;
+    }
+
+    size_t seqCount = DynArr_size(seq);
+    if (seqCount == 0) {
+        DynArr_destroy(seq);
+        return 0;
+    }
+
+    size_t currentTipHeight = Chain_Size(chain) == 0 ? 0 : Chain_Size(chain) - 1;
+    size_t seqTopHeight = forkHeight + seqCount - 1;
+    if (seqTopHeight <= currentTipHeight) {
+        DynArr_destroy(seq);
+        return 0;
+    }
+
+    size_t rollbackHeight = (forkHeight == 0) ? 0 : (forkHeight - 1);
+    if (!Chain_RollbackToHeight(chain, rollbackHeight)) {
+        DynArr_destroy(seq);
+        return 0;
+    }
+
+    size_t attached = 0;
+    for (size_t i = 0; i < seqCount; ++i) {
+        block_t* bptr = *(block_t**)DynArr_at(seq, i);
+        if (!bptr || !Chain_AddBlock(chain, bptr)) {
+            break;
+        }
+
+        size_t count = DynArr_size(g_orphans);
+        for (size_t j = 0; j < count; ++j) {
+            orphan_entry_t* entry = (orphan_entry_t*)DynArr_at(g_orphans, j);
+            if (entry && entry->block == bptr) {
+                DynArr_remove(g_orphans, j);
+                break;
+            }
+        }
+
+        attached++;
+    }
+
+    DynArr_destroy(seq);
+    return attached;
+}
+
+size_t OrphanPool_AttemptAttach(blockchain_t* chain) {
+    if (!g_orphans || !chain) return 0;
+    size_t attached = 0;
+    bool madeProgress = true;
+
+    // Attempt repeatedly while progress is made (to handle chained orphans)
+    while (madeProgress) {
+        madeProgress = false;
+        size_t n = DynArr_size(g_orphans);
+        for (size_t i = 0; i < n; ++i) {
+            orphan_entry_t* e = (orphan_entry_t*)DynArr_at(g_orphans, i);
+            if (!e || !e->block) continue;
+
+            uint64_t parentIndex = (e->height == 0) ? (uint64_t)-1 : (e->height - 1);
+            bool parentExists = false;
+            if (e->height == 0) {
+                // genesis-style block: parent is zero-hash; accept if chain empty
+                parentExists = (Chain_Size(chain) == 0);
+            } else if (parentIndex < Chain_Size(chain)) {
+                block_t* parent = NULL;
+                if (Chain_GetBlockCopy(chain, (size_t)parentIndex, &parent) && parent) {
+                    parentExists = true;
+                    Block_Destroy(parent);
+                } else {
+                    parentExists = false;
+                }
+            }
+
+            if (parentExists) {
+                if (e->height < Chain_Size(chain)) {
+                    block_t* local = NULL;
+                    if (Chain_GetBlockCopy(chain, (size_t)e->height, &local) && local) {
+                        uint8_t localHash[32];
+                        uint8_t orphanHash[32];
+                        Block_CalculateHash(local, localHash);
+                        Block_CalculateHash(e->block, orphanHash);
+                        Block_Destroy(local);
+
+                        if (memcmp(localHash, orphanHash, 32) != 0) {
+                            size_t adopted = OrphanPool_TryAdoptBranch(chain, e->height);
+                            if (adopted > 0) {
+                                attached += adopted;
+                                madeProgress = true;
+                                n = DynArr_size(g_orphans);
+                                i = (size_t)-1;
+                                break;
+                            }
+                        }
+                    } else if (local) {
+                        Block_Destroy(local);
+                    }
+                }
+
+                // Verify that the parent's hash matches the orphan's prevHash before attaching.
+                bool parentMatches = false;
+                if (e->height == 0) {
+                    parentMatches = (Chain_Size(chain) == 0);
+                } else {
+                    block_t* parent = NULL;
+                    if (Chain_GetBlockCopy(chain, (size_t)parentIndex, &parent) && parent) {
+                        uint8_t parentHash[32];
+                        Block_CalculateHash(parent, parentHash);
+                        parentMatches = (memcmp(parentHash, e->block->header.prevHash, 32) == 0);
+                        Block_Destroy(parent);
+                    } else {
+                        parentMatches = false;
+                    }
+                }
+
+                if (!parentMatches) {
+                    // Parent exists but does not match this orphan's prevHash.
+                    size_t adopted = OrphanPool_TryAdoptBranch(chain, e->height);
+                    if (adopted > 0) {
+                        attached += adopted;
+                        madeProgress = true;
+                        n = DynArr_size(g_orphans);
+                        i = (size_t)-1;
+                        break;
+                    }
+
+                    continue;
+                }
+
+                // Try to add to chain
+                if (Chain_AddBlock(chain, e->block)) {
+                    attached++;
+                    madeProgress = true;
+                    // remove this entry
+                    DynArr_remove(g_orphans, i);
+                    // adjust indices
+                    n = DynArr_size(g_orphans);
+                    i = (size_t)-1; // reset outer loop
+                    break;
+                } else {
+                    // Keep the orphan around; rejection may be temporary while the local tip is being reorged.
+                    continue;
+                }
+            }
+        }
+    }
+
+    return attached;
+}

src/tcpd/tcpclient.c

@@ -3,12 +3,15 @@
 #include <tcpd/tcpclient.h>
 
 #include <errno.h>
+#include <netinet/in.h>
 #include <numgen.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/socket.h>
 #include <unistd.h>
+#include <fcntl.h>
+#include <sys/select.h>
 
 static void* TcpClient_ThreadProc(void* arg) {
     tcp_client_t* client = (tcp_client_t*)arg;
@@ -51,6 +54,7 @@ int TcpClient_Init(tcp_client_t* client) {
 
     memset(client, 0, sizeof(*client));
     client->connection = NULL;
+    client->peerBlockHeight = 0;
     return 0;
 }
 
@@ -79,25 +83,87 @@ int TcpClient_Connect(
         return -1;
     }
 
-    int sockFd = socket(AF_INET, SOCK_STREAM, 0);
+    // Detect address family from the IP string
+    struct sockaddr_in6 addr6;
+    struct sockaddr_in addr4;
+    struct sockaddr* pSockAddr;
+    socklen_t sockAddrLen;
+    int af;
+
+    memset(&addr6, 0, sizeof(addr6));
+    memset(&addr4, 0, sizeof(addr4));
+
+    if (inet_pton(AF_INET6, peerIp, &addr6.sin6_addr) == 1) {
+        af = AF_INET6;
+        addr6.sin6_family = AF_INET6;
+        addr6.sin6_port = htons(peerPort);
+        pSockAddr = (struct sockaddr*)&addr6;
+        sockAddrLen = sizeof(addr6);
+    } else if (inet_pton(AF_INET, peerIp, &addr4.sin_addr) == 1) {
+        af = AF_INET;
+        addr4.sin_family = AF_INET;
+        addr4.sin_port = htons(peerPort);
+        pSockAddr = (struct sockaddr*)&addr4;
+        sockAddrLen = sizeof(addr4);
+    } else {
+        return -1;
+    }
+
+    int sockFd = socket(af, SOCK_STREAM, 0);
     if (sockFd < 0) {
         return -1;
     }
 
-    struct sockaddr_in peerAddr;
-    memset(&peerAddr, 0, sizeof(peerAddr));
-    peerAddr.sin_family = AF_INET;
-    peerAddr.sin_port = htons(peerPort);
+    // Use non-blocking connect with a timeout to avoid long blocking in the CLI.
+    int flags = fcntl(sockFd, F_GETFL, 0);
+    if (flags == -1) flags = 0;
+    fcntl(sockFd, F_SETFL, flags | O_NONBLOCK);
 
-    if (inet_pton(AF_INET, peerIp, &peerAddr.sin_addr) <= 0) {
-        close(sockFd);
-        return -1;
+    int rc = connect(sockFd, pSockAddr, sockAddrLen);
+    if (rc < 0) {
+        if (errno != EINPROGRESS) {
+            close(sockFd);
+            return -1;
+        }
+
+        // Wait up to 5 seconds for the socket to become writable (connected)
+        struct timeval tv;
+        tv.tv_sec = 5;
+        tv.tv_usec = 0;
+        fd_set wfds;
+        FD_ZERO(&wfds);
+        FD_SET(sockFd, &wfds);
+        int sel = select(sockFd + 1, NULL, &wfds, NULL, &tv);
+        if (sel <= 0) {
+            // timeout or error
+            if (sel == 0) {
+                errno = ETIMEDOUT;
+            }
+            close(sockFd);
+            return -1;
+        }
+
+        // Check for socket error
+        int so_error = 0;
+        socklen_t len = sizeof(so_error);
+        if (getsockopt(sockFd, SOL_SOCKET, SO_ERROR, &so_error, &len) < 0) {
+            close(sockFd);
+            return -1;
+        }
+        if (so_error != 0) {
+            errno = so_error;
+            close(sockFd);
+            return -1;
+        }
     }
 
-    if (connect(sockFd, (struct sockaddr*)&peerAddr, sizeof(peerAddr)) < 0) {
-        close(sockFd);
-        return -1;
-    }
+    // Restore blocking mode
+    fcntl(sockFd, F_SETFL, flags & ~O_NONBLOCK);
+
+    // Pack the address into sockaddr_storage for TcpConnection_Init
+    struct sockaddr_storage peerStorage;
+    memset(&peerStorage, 0, sizeof(peerStorage));
+    memcpy(&peerStorage, pSockAddr, sockAddrLen);
 
     tcp_connection_t* conn = (tcp_connection_t*)malloc(sizeof(*conn));
     if (!conn) {
@@ -105,7 +171,7 @@ int TcpClient_Connect(
         return -1;
     }
 
-    if (TcpConnection_Init(conn, sockFd, &peerAddr, TCP_CONNECTION_ROLE_OUTBOUND) != 0) {
+    if (TcpConnection_Init(conn, sockFd, &peerStorage, TCP_CONNECTION_ROLE_OUTBOUND) != 0) {
         free(conn);
         close(sockFd);
         return -1;

src/tcpd/tcpconnection.c

@@ -9,7 +9,7 @@
 #include <sys/socket.h>
 #include <unistd.h>
 
-int TcpConnection_Init(tcp_connection_t* conn, int sockFd, const struct sockaddr_in* peerAddr, tcp_connection_role_t role) {
+int TcpConnection_Init(tcp_connection_t* conn, int sockFd, const struct sockaddr_storage* peerAddr, tcp_connection_role_t role) {
     if (!conn || sockFd < 0 || !peerAddr) {
         return -1;
     }
@@ -17,6 +17,7 @@ int TcpConnection_Init(tcp_connection_t* conn, int sockFd, const struct sockaddr
     memset(conn, 0, sizeof(*conn));
     conn->sockFd = sockFd;
     conn->peerAddr = *peerAddr;
+    conn->addrFamily = peerAddr->ss_family;
     conn->role = role;
 
     if (pthread_mutex_init(&conn->sendLock, NULL) != 0) {
@@ -261,4 +262,58 @@ bool TcpConnection_IsDisconnectNotified(tcp_connection_t* conn) {
     return notified;
 }
 
+static int extract_v4(const tcp_connection_t* conn, struct in_addr* v4out) {
+    if (conn->addrFamily == AF_INET6) {
+        const struct sockaddr_in6* a6 = (const struct sockaddr_in6*)&conn->peerAddr;
+        if (IN6_IS_ADDR_V4MAPPED(&a6->sin6_addr)) {
+            memcpy(v4out, &a6->sin6_addr.s6_addr[12], sizeof(*v4out));
+            return 1;
+        }
+        return 0;
+    }
+    *v4out = ((const struct sockaddr_in*)&conn->peerAddr)->sin_addr;
+    return 1;
+}
+
+const char* TcpConnection_GetPeerAddrStr(const tcp_connection_t* conn, char* buf, size_t bufLen) {
+    if (!conn || !buf || bufLen == 0) {
+        return NULL;
+    }
+
+    if (conn->addrFamily == AF_INET6) {
+        const struct sockaddr_in6* a6 = (const struct sockaddr_in6*)&conn->peerAddr;
+        if (IN6_IS_ADDR_V4MAPPED(&a6->sin6_addr)) {
+            struct in_addr v4;
+            memcpy(&v4, &a6->sin6_addr.s6_addr[12], sizeof(v4));
+            return inet_ntop(AF_INET, &v4, buf, (socklen_t)bufLen);
+        }
+        return inet_ntop(AF_INET6, &a6->sin6_addr, buf, (socklen_t)bufLen);
+    }
+
+    const struct sockaddr_in* a4 = (const struct sockaddr_in*)&conn->peerAddr;
+    return inet_ntop(AF_INET, &a4->sin_addr, buf, (socklen_t)bufLen);
+}
+
+int TcpConnection_PeerAddrEqual(const tcp_connection_t* a, const tcp_connection_t* b) {
+    if (!a || !b) {
+        return 0;
+    }
+
+    struct in_addr va, vb;
+    int a_is_v4 = extract_v4(a, &va);
+    int b_is_v4 = extract_v4(b, &vb);
+
+    if (a_is_v4 && b_is_v4) {
+        return va.s_addr == vb.s_addr;
+    }
+
+    if (!a_is_v4 && !b_is_v4) {
+        const struct in6_addr* aa6 = &((const struct sockaddr_in6*)&a->peerAddr)->sin6_addr;
+        const struct in6_addr* ab6 = &((const struct sockaddr_in6*)&b->peerAddr)->sin6_addr;
+        return memcmp(aa6, ab6, sizeof(*aa6)) == 0;
+    }
+
+    return 0;
+}
+
 #endif

src/tcpd/tcpserver.c

@@ -3,6 +3,7 @@
 #include <tcpd/tcpserver.h>
 
 #include <errno.h>
+#include <netinet/in.h>
 #include <numgen.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -10,6 +11,11 @@
 #include <sys/socket.h>
 #include <unistd.h>
 
+typedef struct {
+    tcp_server_t* serverPtr;
+    int listenFd;
+} tcpaccept_thread_args_t;
+
 static void TcpServer_RemoveClientByPtrUnlocked(tcp_server_t* svr, tcp_connection_t* cli) {
     if (!svr || !svr->clientsArrPtr || !cli) {
         return;
@@ -70,15 +76,20 @@ static void* TcpServer_clientthreadprocess(void* ptr) {
 }
 
 static void* TcpServer_threadprocess(void* ptr) {
-    tcp_server_t* svr = (tcp_server_t*)ptr;
-    if (!svr) {
+    tcpaccept_thread_args_t* args = (tcpaccept_thread_args_t*)ptr;
+    if (!args || !args->serverPtr) {
+        free(args);
         return NULL;
     }
 
+    tcp_server_t* svr = args->serverPtr;
+    int listenFd = args->listenFd;
+    free(args);
+
     while (svr->isRunning) {
-        struct sockaddr_in clientAddr;
+        struct sockaddr_storage clientAddr;
         socklen_t clientSize = sizeof(clientAddr);
-        int clientFd = accept(svr->sockFd, (struct sockaddr*)&clientAddr, &clientSize);
+        int clientFd = accept(listenFd, (struct sockaddr*)&clientAddr, &clientSize);
 
         if (clientFd < 0) {
             if (!svr->isRunning) {
@@ -168,7 +179,9 @@ tcp_server_t* TcpServer_Create() {
 
     memset(svr, 0, sizeof(*svr));
     svr->sockFd = -1;
+    svr->sockFdV4 = -1;
     svr->svrThread = 0;
+    svr->svrThreadV4 = 0;
     svr->isRunning = 0;
     svr->maxClients = 0;
     svr->clientsArrPtr = NULL;
@@ -200,31 +213,65 @@ void TcpServer_Init(tcp_server_t* ptr, unsigned short port, const char* addr) {
         return;
     }
 
-    ptr->sockFd = socket(AF_INET, SOCK_STREAM, 0);
-    if (ptr->sockFd < 0) {
-        return;
+    ptr->opt = 1;
+
+    // IPv6 (pure, not dual-stack — a dedicated IPv4 socket handles IPv4 clients)
+    int fd6 = socket(AF_INET6, SOCK_STREAM, 0);
+    if (fd6 >= 0) {
+        setsockopt(fd6, SOL_SOCKET, SO_REUSEADDR, &ptr->opt, sizeof(ptr->opt));
+        int v6only = 1;
+        setsockopt(fd6, IPPROTO_IPV6, IPV6_V6ONLY, &v6only, sizeof(v6only));
+
+        struct sockaddr_in6 a6;
+        memset(&a6, 0, sizeof(a6));
+        a6.sin6_family = AF_INET6;
+        a6.sin6_port = htons(port);
+        a6.sin6_addr = in6addr_any;
+
+        if (bind(fd6, (struct sockaddr*)&a6, sizeof(a6)) == 0) {
+            ptr->sockFd = fd6;
+        } else {
+            close(fd6);
+        }
     }
 
-    ptr->opt = 1;
-    setsockopt(ptr->sockFd, SOL_SOCKET, SO_REUSEADDR, &ptr->opt, sizeof(int));
+    // IPv4 (always attempted regardless of IPv6 result)
+    int fd4 = socket(AF_INET, SOCK_STREAM, 0);
+    if (fd4 >= 0) {
+        setsockopt(fd4, SOL_SOCKET, SO_REUSEADDR, &ptr->opt, sizeof(ptr->opt));
 
-    memset(&ptr->addr, 0, sizeof(ptr->addr));
-    ptr->addr.sin_family = AF_INET;
-    ptr->addr.sin_port = htons(port);
-    inet_pton(AF_INET, addr, &ptr->addr.sin_addr);
+        struct sockaddr_in a4;
+        memset(&a4, 0, sizeof(a4));
+        a4.sin_family = AF_INET;
+        a4.sin_port = htons(port);
+        if (inet_pton(AF_INET, addr, &a4.sin_addr) <= 0) {
+            a4.sin_addr.s_addr = INADDR_ANY;
+        }
 
-    if (bind(ptr->sockFd, (struct sockaddr*)&ptr->addr, sizeof(ptr->addr)) < 0) {
-        close(ptr->sockFd);
-        ptr->sockFd = -1;
+        if (bind(fd4, (struct sockaddr*)&a4, sizeof(a4)) == 0) {
+            ptr->sockFdV4 = fd4;
+        } else {
+            close(fd4);
+        }
     }
 }
 
 void TcpServer_Start(tcp_server_t* ptr, int maxcons) {
-    if (!ptr || ptr->sockFd < 0 || maxcons <= 0 || ptr->isRunning) {
+    if (!ptr || (ptr->sockFd < 0 && ptr->sockFdV4 < 0) || maxcons <= 0 || ptr->isRunning) {
         return;
     }
 
-    if (listen(ptr->sockFd, maxcons) < 0) {
+    if (ptr->sockFd >= 0 && listen(ptr->sockFd, maxcons) < 0) {
+        close(ptr->sockFd);
+        ptr->sockFd = -1;
+    }
+
+    if (ptr->sockFdV4 >= 0 && listen(ptr->sockFdV4, maxcons) < 0) {
+        close(ptr->sockFdV4);
+        ptr->sockFdV4 = -1;
+    }
+
+    if (ptr->sockFd < 0 && ptr->sockFdV4 < 0) {
         return;
     }
 
@@ -245,7 +292,35 @@ void TcpServer_Start(tcp_server_t* ptr, int maxcons) {
     ptr->isRunning = 1;
     pthread_mutex_unlock(&ptr->clientsMutex);
 
-    if (pthread_create(&ptr->svrThread, NULL, TcpServer_threadprocess, ptr) != 0) {
+    int anyThreadStarted = 0;
+
+    if (ptr->sockFd >= 0) {
+        tcpaccept_thread_args_t* args = (tcpaccept_thread_args_t*)malloc(sizeof(*args));
+        if (args) {
+            args->serverPtr = ptr;
+            args->listenFd = ptr->sockFd;
+            if (pthread_create(&ptr->svrThread, NULL, TcpServer_threadprocess, args) == 0) {
+                anyThreadStarted = 1;
+            } else {
+                free(args);
+            }
+        }
+    }
+
+    if (ptr->sockFdV4 >= 0) {
+        tcpaccept_thread_args_t* args = (tcpaccept_thread_args_t*)malloc(sizeof(*args));
+        if (args) {
+            args->serverPtr = ptr;
+            args->listenFd = ptr->sockFdV4;
+            if (pthread_create(&ptr->svrThreadV4, NULL, TcpServer_threadprocess, args) == 0) {
+                anyThreadStarted = 1;
+            } else {
+                free(args);
+            }
+        }
+    }
+
+    if (!anyThreadStarted) {
         pthread_mutex_lock(&ptr->clientsMutex);
         ptr->isRunning = 0;
         free(ptr->clientsArrPtr);
@@ -268,11 +343,22 @@ void TcpServer_Stop(tcp_server_t* ptr) {
         ptr->sockFd = -1;
     }
 
+    if (ptr->sockFdV4 >= 0) {
+        shutdown(ptr->sockFdV4, SHUT_RDWR);
+        close(ptr->sockFdV4);
+        ptr->sockFdV4 = -1;
+    }
+
     if (ptr->svrThread != 0 && !pthread_equal(ptr->svrThread, pthread_self())) {
         pthread_join(ptr->svrThread, NULL);
     }
     ptr->svrThread = 0;
 
+    if (ptr->svrThreadV4 != 0 && !pthread_equal(ptr->svrThreadV4, pthread_self())) {
+        pthread_join(ptr->svrThreadV4, NULL);
+    }
+    ptr->svrThreadV4 = 0;
+
     pthread_mutex_lock(&ptr->clientsMutex);
     size_t maxClients = ptr->maxClients;
     tcp_connection_t** local = ptr->clientsArrPtr;

src/txmempool.c

@@ -1,14 +1,21 @@
 #include <txmempool.h>
+#include <pthread.h>
+
+static pthread_mutex_t g_txMempoolLock;
+static bool g_txMempoolLockInitialized = false;
 
 khash_t(tx_mempool_map_m)* txMempool = NULL;
 
 void TxMempool_Init() {
     txMempool = kh_init(tx_mempool_map_m);
+    pthread_mutex_init(&g_txMempoolLock, NULL);
+    g_txMempoolLockInitialized = true;
 }
 
 int TxMempool_Insert(signed_transaction_t tx) {
     if (!txMempool) { return -1; }
 
+    pthread_mutex_lock(&g_txMempoolLock);
     uint8_t txHash[32];
     Transaction_CalculateHash(&tx, txHash);
 
@@ -18,17 +25,21 @@ int TxMempool_Insert(signed_transaction_t tx) {
     int ret;
     khiter_t k = kh_put(tx_mempool_map_m, txMempool, key, &ret);
     if (k == kh_end(txMempool)) {
+        pthread_mutex_unlock(&g_txMempoolLock);
         return -1;
     }
 
     kh_value(txMempool, k) = tx;
 
+    pthread_mutex_unlock(&g_txMempoolLock);
+
     return ret;
 }
 
 bool TxMempool_Lookup(uint8_t* txHash, signed_transaction_t* out) {
     if (!txMempool || !txHash || !out) { return false; }
     
+    pthread_mutex_lock(&g_txMempoolLock);
     key32_t key;
     memcpy(key.bytes, txHash, 32);
 
@@ -36,15 +47,65 @@ bool TxMempool_Lookup(uint8_t* txHash, signed_transaction_t* out) {
     if (k != kh_end(txMempool)) {
         signed_transaction_t tx = kh_value(txMempool, k);
         memcpy(out, &tx, sizeof(signed_transaction_t));
+        pthread_mutex_unlock(&g_txMempoolLock);
         return true;
     }
 
+    pthread_mutex_unlock(&g_txMempoolLock);
     return false;
 }
 
+bool TxMempool_Snapshot(signed_transaction_t** outTxs, size_t* outCount) {
+    if (!outTxs || !outCount) {
+        return false;
+    }
+
+    *outTxs = NULL;
+    *outCount = 0;
+
+    if (!txMempool) {
+        return true;
+    }
+
+    pthread_mutex_lock(&g_txMempoolLock);
+
+    size_t count = 0;
+    khiter_t k;
+    for (k = kh_begin(txMempool); k != kh_end(txMempool); ++k) {
+        if (kh_exist(txMempool, k)) {
+            ++count;
+        }
+    }
+
+    if (count == 0) {
+        pthread_mutex_unlock(&g_txMempoolLock);
+        return true;
+    }
+
+    signed_transaction_t* snapshot = (signed_transaction_t*)malloc(count * sizeof(signed_transaction_t));
+    if (!snapshot) {
+        pthread_mutex_unlock(&g_txMempoolLock);
+        return false;
+    }
+
+    size_t index = 0;
+    for (k = kh_begin(txMempool); k != kh_end(txMempool); ++k) {
+        if (kh_exist(txMempool, k)) {
+            snapshot[index++] = kh_value(txMempool, k);
+        }
+    }
+
+    pthread_mutex_unlock(&g_txMempoolLock);
+
+    *outTxs = snapshot;
+    *outCount = count;
+    return true;
+}
+
 void TxMempool_Print() {
     if (!txMempool) { return; }
 
+    pthread_mutex_lock(&g_txMempoolLock);
     khiter_t k;
     for (k = kh_begin(txMempool); k != kh_end(txMempool); ++k) {
         if (kh_exist(txMempool, k)) {
@@ -62,10 +123,37 @@ void TxMempool_Print() {
                 (unsigned long long)tx.transaction.fee);
         }
     }
+    pthread_mutex_unlock(&g_txMempoolLock);
 }
 
 void TxMempool_Destroy() {
     if (txMempool) {
+        pthread_mutex_lock(&g_txMempoolLock);
         kh_destroy(tx_mempool_map_m, txMempool);
+        txMempool = NULL;
+        pthread_mutex_unlock(&g_txMempoolLock);
+    }
+
+    if (g_txMempoolLockInitialized) {
+        pthread_mutex_destroy(&g_txMempoolLock);
+        g_txMempoolLockInitialized = false;
     }
 }
+
+bool TxMempool_Remove(const uint8_t* txHash) {
+    if (!txMempool || !txHash) { return false; }
+
+    pthread_mutex_lock(&g_txMempoolLock);
+    key32_t key;
+    memcpy(key.bytes, txHash, 32);
+
+    khiter_t k = kh_get(tx_mempool_map_m, txMempool, key);
+    if (k == kh_end(txMempool)) {
+        pthread_mutex_unlock(&g_txMempoolLock);
+        return false;
+    }
+
+    kh_del(tx_mempool_map_m, txMempool, k);
+    pthread_mutex_unlock(&g_txMempoolLock);
+    return true;
+}

src/udpd/udpnode.c

@@ -0,0 +1,379 @@
+#include <udpd/udpnode.h>
+#include <udpd/udppackettype.h>
+#include <utils.h>
+#include <numgen.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <errno.h>
+
+typedef struct {
+    udp_node_t* node;
+    int sockFd;
+} udprecv_thread_args_t;
+
+// Send a raw PING packet (nonce already chosen) to dest.
+static void UdpNode_SendRawPing(udp_node_t* node, uint64_t nonce, const struct sockaddr_storage* dest) {
+    unsigned char buf[UDP_PING_WIRE_SIZE];
+    buf[0] = (unsigned char)UDP_PACKET_TYPE_PING;
+    memcpy(buf + 1, &nonce, sizeof(nonce));
+
+    int sock = -1;
+    socklen_t addrLen = 0;
+
+    if (dest->ss_family == AF_INET6 && node->sockFd >= 0) {
+        sock = node->sockFd;
+        addrLen = sizeof(struct sockaddr_in6);
+    } else if (dest->ss_family == AF_INET && node->sockFdV4 >= 0) {
+        sock = node->sockFdV4;
+        addrLen = sizeof(struct sockaddr_in);
+    }
+
+    if (sock < 0) {
+        return;
+    }
+
+    sendto(sock, buf, sizeof(buf), 0, (const struct sockaddr*)dest, addrLen);
+}
+
+static void UdpNode_HandlePacket(udp_node_t* node, int fromSock,
+                                  const unsigned char* buf, ssize_t n,
+                                  const struct sockaddr_storage* from) {
+    if (n < 1) {
+        return;
+    }
+
+    udp_packet_type_t type = (udp_packet_type_t)buf[0];
+
+    switch (type) {
+        case UDP_PACKET_TYPE_PING: {
+            if (n < UDP_PING_WIRE_SIZE) {
+                return;
+            }
+            uint64_t nonce;
+            memcpy(&nonce, buf + 1, sizeof(nonce));
+
+            // Build and send PONG
+            unsigned char reply[UDP_PONG_WIRE_SIZE];
+            reply[0] = (unsigned char)UDP_PACKET_TYPE_PONG;
+            memcpy(reply + 1, &nonce, sizeof(nonce));
+            int32_t protoVer = (int32_t)PROTO_VERSION;
+            memcpy(reply + 1 + sizeof(nonce), &protoVer, sizeof(protoVer));
+
+            socklen_t addrLen = (from->ss_family == AF_INET6)
+                ? sizeof(struct sockaddr_in6)
+                : sizeof(struct sockaddr_in);
+            sendto(fromSock, reply, sizeof(reply), 0, (const struct sockaddr*)from, addrLen);
+            break;
+        }
+
+        case UDP_PACKET_TYPE_PONG: {
+            if (n < UDP_PONG_WIRE_SIZE) {
+                return;
+            }
+            uint64_t nonce;
+            int32_t protoVer;
+            memcpy(&nonce, buf + 1, sizeof(nonce));
+            memcpy(&protoVer, buf + 1 + sizeof(nonce), sizeof(protoVer));
+
+            bool found = false;
+            uint64_t rttMs = 0;
+            pthread_mutex_lock(&node->pingsMutex);
+            for (int i = 0; i < UDP_MAX_PENDING_PINGS; i++) {
+                if (node->pendingPings[i].active && node->pendingPings[i].nonce == nonce) {
+                    uint64_t nowMs = get_current_time_ms();
+                    rttMs = (nowMs >= node->pendingPings[i].lastSentMs)
+                        ? (nowMs - node->pendingPings[i].lastSentMs)
+                        : 0;
+                    node->pendingPings[i].active = false;
+                    found = true;
+                    break;
+                }
+            }
+            pthread_mutex_unlock(&node->pingsMutex);
+
+            if (found && node->on_pong) {
+                node->on_pong(node, from, nonce, (int)protoVer, rttMs, node->callbackUser);
+            }
+            break;
+        }
+
+        default:
+            break;
+    }
+}
+
+static void* UdpNode_RecvThreadProc(void* arg) {
+    udprecv_thread_args_t* args = (udprecv_thread_args_t*)arg;
+    udp_node_t* node = args->node;
+    int sock = args->sockFd;
+    free(args);
+
+    unsigned char buf[1500];
+
+    while (node->isRunning) {
+        struct sockaddr_storage from;
+        socklen_t fromLen = sizeof(from);
+        ssize_t n = recvfrom(sock, buf, sizeof(buf), 0,
+                             (struct sockaddr*)&from, &fromLen);
+        if (n < 1) {
+            if (!node->isRunning) {
+                break;
+            }
+            // Transient error — keep going
+            continue;
+        }
+        UdpNode_HandlePacket(node, sock, buf, n, &from);
+    }
+
+    return NULL;
+}
+
+static void* UdpNode_RetryThreadProc(void* arg) {
+    udp_node_t* node = (udp_node_t*)arg;
+
+    struct {
+        uint64_t nonce;
+        struct sockaddr_storage dest;
+    } timedOut[UDP_MAX_PENDING_PINGS];
+
+    while (node->isRunning) {
+        sleep_for_milliseconds(100);
+
+        int timedOutCount = 0;
+
+        pthread_mutex_lock(&node->pingsMutex);
+        uint64_t now = get_current_time_ms();
+        for (int i = 0; i < UDP_MAX_PENDING_PINGS; i++) {
+            pending_ping_t* p = &node->pendingPings[i];
+            if (!p->active) {
+                continue;
+            }
+            if (now - p->lastSentMs < UDP_PING_RETRY_INTERVAL_MS) {
+                continue;
+            }
+            if (p->retries >= UDP_PING_MAX_RETRIES) {
+                timedOut[timedOutCount].nonce = p->nonce;
+                timedOut[timedOutCount].dest  = p->dest;
+                timedOutCount++;
+                p->active = false;
+            } else {
+                UdpNode_SendRawPing(node, p->nonce, &p->dest);
+                p->retries++;
+                p->lastSentMs = now;
+            }
+        }
+        pthread_mutex_unlock(&node->pingsMutex);
+
+        for (int i = 0; i < timedOutCount; i++) {
+            if (node->on_ping_timeout) {
+                node->on_ping_timeout(node, &timedOut[i].dest,
+                                      timedOut[i].nonce, node->callbackUser);
+            }
+        }
+    }
+
+    return NULL;
+}
+
+int UdpNode_Init(udp_node_t* node, uint16_t port) {
+    if (!node) {
+        return -1;
+    }
+
+    memset(node, 0, sizeof(*node));
+    node->sockFd = -1;
+    node->sockFdV4 = -1;
+
+    int opt = 1;
+
+    // IPv6 (pure, not dual-stack)
+    int fd6 = socket(AF_INET6, SOCK_DGRAM, 0);
+    if (fd6 >= 0) {
+        setsockopt(fd6, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
+        int v6only = 1;
+        setsockopt(fd6, IPPROTO_IPV6, IPV6_V6ONLY, &v6only, sizeof(v6only));
+
+        struct sockaddr_in6 a6;
+        memset(&a6, 0, sizeof(a6));
+        a6.sin6_family = AF_INET6;
+        a6.sin6_port = htons(port);
+        a6.sin6_addr = in6addr_any;
+
+        if (bind(fd6, (struct sockaddr*)&a6, sizeof(a6)) == 0) {
+            node->sockFd = fd6;
+        } else {
+            close(fd6);
+        }
+    }
+
+    // IPv4
+    int fd4 = socket(AF_INET, SOCK_DGRAM, 0);
+    if (fd4 >= 0) {
+        setsockopt(fd4, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
+
+        struct sockaddr_in a4;
+        memset(&a4, 0, sizeof(a4));
+        a4.sin_family = AF_INET;
+        a4.sin_port = htons(port);
+        a4.sin_addr.s_addr = INADDR_ANY;
+
+        if (bind(fd4, (struct sockaddr*)&a4, sizeof(a4)) == 0) {
+            node->sockFdV4 = fd4;
+        } else {
+            close(fd4);
+        }
+    }
+
+    if (node->sockFd < 0 && node->sockFdV4 < 0) {
+        return -1;
+    }
+
+    pthread_mutex_init(&node->pingsMutex, NULL);
+    return 0;
+}
+
+void UdpNode_SetCallbacks(udp_node_t* node,
+        void (*on_pong)(udp_node_t*, const struct sockaddr_storage*, uint64_t, int, uint64_t, void*),
+        void (*on_ping_timeout)(udp_node_t*, const struct sockaddr_storage*, uint64_t, void*),
+        void* user) {
+    if (!node) {
+        return;
+    }
+    node->on_pong = on_pong;
+    node->on_ping_timeout = on_ping_timeout;
+    node->callbackUser = user;
+}
+
+int UdpNode_Start(udp_node_t* node) {
+    if (!node || node->isRunning) {
+        return -1;
+    }
+    if (node->sockFd < 0 && node->sockFdV4 < 0) {
+        return -1;
+    }
+
+    node->isRunning = 1;
+    int anyStarted  = 0;
+
+    if (node->sockFd >= 0) {
+        udprecv_thread_args_t* args = (udprecv_thread_args_t*)malloc(sizeof(*args));
+        if (args) {
+            args->node = node;
+            args->sockFd = node->sockFd;
+            if (pthread_create(&node->recvThreadV6, NULL, UdpNode_RecvThreadProc, args) == 0) {
+                anyStarted = 1;
+            } else {
+                free(args);
+            }
+        }
+    }
+
+    if (node->sockFdV4 >= 0) {
+        udprecv_thread_args_t* args = (udprecv_thread_args_t*)malloc(sizeof(*args));
+        if (args) {
+            args->node = node;
+            args->sockFd = node->sockFdV4;
+            if (pthread_create(&node->recvThreadV4, NULL, UdpNode_RecvThreadProc, args) == 0) {
+                anyStarted = 1;
+            } else {
+                free(args);
+            }
+        }
+    }
+
+    if (pthread_create(&node->retryThread, NULL, UdpNode_RetryThreadProc, node) == 0) {
+        anyStarted = 1;
+    }
+
+    if (!anyStarted) {
+        node->isRunning = 0;
+        return -1;
+    }
+
+    return 0;
+}
+
+void UdpNode_Stop(udp_node_t* node) {
+    if (!node || !node->isRunning) {
+        return;
+    }
+
+    node->isRunning = 0;
+
+    // Close sockets to unblock recvfrom in receive threads
+    if (node->sockFd >= 0) {
+        int fd = node->sockFd;
+        node->sockFd = -1;
+        close(fd);
+    }
+    if (node->sockFdV4 >= 0) {
+        int fd = node->sockFdV4;
+        node->sockFdV4 = -1;
+        close(fd);
+    }
+
+    pthread_join(node->recvThreadV6, NULL);
+    pthread_join(node->recvThreadV4, NULL);
+    pthread_join(node->retryThread, NULL);
+}
+
+void UdpNode_Destroy(udp_node_t* node) {
+    if (!node) {
+        return;
+    }
+
+    if (node->sockFd >= 0) {
+        close(node->sockFd);
+        node->sockFd = -1;
+    }
+    if (node->sockFdV4 >= 0) {
+        close(node->sockFdV4);
+        node->sockFdV4 = -1;
+    }
+
+    pthread_mutex_destroy(&node->pingsMutex);
+}
+
+int UdpNode_SendPing(udp_node_t* node, const struct sockaddr_storage* dest) {
+    if (!node || !dest) {
+        return -1;
+    }
+    if (node->sockFd < 0 && node->sockFdV4 < 0) {
+        return -1;
+    }
+
+    uint64_t nonce = random_eight_byte();
+    uint64_t now = get_current_time_ms();
+
+    pthread_mutex_lock(&node->pingsMutex);
+
+    int slot = -1;
+    for (int i = 0; i < UDP_MAX_PENDING_PINGS; i++) {
+        if (!node->pendingPings[i].active) {
+            slot = i;
+            break;
+        }
+    }
+
+    if (slot < 0) {
+        pthread_mutex_unlock(&node->pingsMutex);
+        return -1;
+    }
+
+    node->pendingPings[slot].nonce = nonce;
+    node->pendingPings[slot].dest = *dest;
+    node->pendingPings[slot].lastSentMs = now;
+    node->pendingPings[slot].retries = 0;
+    node->pendingPings[slot].active = true;
+
+    pthread_mutex_unlock(&node->pingsMutex);
+
+    UdpNode_SendRawPing(node, nonce, dest);
+    return 0;
+}