Start IPv6 - Lord help me

Mining: blocks now include mempool txs, select spendable txs by fee, and pay coinbase as base reward + fees in main.c.
 - Consensus: block validation now enforces coinbase accounting and rejects invalid coinbase placement, including coinbase on amount2, in block.c and transaction.c.
 - Chain state: rollback now rebuilds currentSupply/currentReward, and block addition preflights spendability before mutating balances in chain.c.
 - Orphans/reorgs: orphan retry is safer, rollback-triggered sync reattaches orphans immediately, and transient orphan failures no longer drop blocks in orphan_pool.c and main.c.
 - Networking/mempool: node lifecycle now initializes the mempool, broadcasts can exclude one peer, and mempool snapshotting supports mining selection in net_node.c and txmempool.c.
 - Ledger simulation: added non-mutating spendable-transaction selection for block assembly in balance_sheet.c.

CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.16)
 
-project(miniboinc
+project(skalacoin
     VERSION 0.1.0
     LANGUAGES C CXX
 )
@@ -29,25 +29,101 @@ if(NOT OpenSSL_FOUND)
     find_package(OpenSSL REQUIRED)
 endif()
 
+# libcurl (required by autolykos2 vendored code)
+find_package(CURL QUIET)
+if(NOT CURL_FOUND)
+    message(STATUS "libcurl not found on system; attempting to fetch/build via FetchContent")
+    FetchContent_Declare(
+        curl
+        GIT_REPOSITORY https://github.com/curl/curl.git
+        GIT_TAG curl-8_4_0
+        GIT_SHALLOW TRUE
+    )
+    # Try to make it available (this will add_subdirectory if curl provides CMake)
+    FetchContent_MakeAvailable(curl)
+endif()
+
 # secp256k1 (Bitcoin Core library)
 find_package(PkgConfig QUIET)
 if(PkgConfig_FOUND)
     pkg_check_modules(SECP256K1 QUIET IMPORTED_TARGET libsecp256k1)
 endif()
 
+# Try pkg-config / system first, then fall back to find_*(). If still not found
+# attempt to fetch and build a bundled copy of libsecp256k1 using FetchContent.
 if(NOT SECP256K1_FOUND)
     find_path(SECP256K1_INCLUDE_DIR NAMES secp256k1.h)
     find_library(SECP256K1_LIBRARY NAMES secp256k1)
-    if(NOT SECP256K1_INCLUDE_DIR OR NOT SECP256K1_LIBRARY)
+    if(SECP256K1_INCLUDE_DIR AND SECP256K1_LIBRARY)
-        message(FATAL_ERROR "secp256k1 not found. Install with: brew install secp256k1")
+        set(SECP256K1_FOUND TRUE)
+    endif()
+endif()
+
+if(NOT SECP256K1_FOUND)
+    message(STATUS "secp256k1 not found on system; fetching and building a vendored copy")
+    include(FetchContent)
+    FetchContent_Declare(
+        secp256k1
+        GIT_REPOSITORY https://github.com/bitcoin-core/secp256k1.git
+        GIT_TAG master
+        GIT_SHALLOW TRUE
+    )
+    FetchContent_GetProperties(secp256k1)
+    if(NOT secp256k1_POPULATED)
+        FetchContent_Populate(secp256k1)
+        # Prefer a CMake build if present
+        if(EXISTS "${secp256k1_SOURCE_DIR}/CMakeLists.txt")
+            add_subdirectory(${secp256k1_SOURCE_DIR} ${secp256k1_BINARY_DIR})
+            if(TARGET secp256k1)
+                set(SECP256K1_FOUND TRUE)
+                set(SECP256K1_TARGET secp256k1)
+            elseif(TARGET libsecp256k1)
+                set(SECP256K1_FOUND TRUE)
+                set(SECP256K1_TARGET libsecp256k1)
+            endif()
+        else()
+            # Fall back to the autotools build path. Install into a private prefix
+            set(SECP256K1_INSTALL_DIR "${CMAKE_BINARY_DIR}/_deps/secp256k1/install")
+            file(MAKE_DIRECTORY ${SECP256K1_INSTALL_DIR})
+            execute_process(COMMAND ./autogen.sh
+                WORKING_DIRECTORY ${secp256k1_SOURCE_DIR}
+                RESULT_VARIABLE _secp_autogen_result
+                OUTPUT_QUIET ERROR_QUIET)
+            if(NOT _secp_autogen_result EQUAL 0)
+                message(FATAL_ERROR "Failed to run autogen.sh for secp256k1")
+            endif()
+            execute_process(COMMAND ./configure --enable-module-ecdh --enable-experimental --prefix=${SECP256K1_INSTALL_DIR}
+                WORKING_DIRECTORY ${secp256k1_SOURCE_DIR}
+                RESULT_VARIABLE _secp_configure_result
+                OUTPUT_QUIET ERROR_QUIET)
+            if(NOT _secp_configure_result EQUAL 0)
+                message(FATAL_ERROR "Failed to configure secp256k1")
+            endif()
+            execute_process(COMMAND make
+                WORKING_DIRECTORY ${secp256k1_SOURCE_DIR}
+                RESULT_VARIABLE _secp_make_result
+                OUTPUT_QUIET ERROR_QUIET)
+            if(NOT _secp_make_result EQUAL 0)
+                message(FATAL_ERROR "Failed to build secp256k1")
+            endif()
+            execute_process(COMMAND make install
+                WORKING_DIRECTORY ${secp256k1_SOURCE_DIR}
+                RESULT_VARIABLE _secp_make_install_result
+                OUTPUT_QUIET ERROR_QUIET)
+            set(SECP256K1_INCLUDE_DIR ${SECP256K1_INSTALL_DIR}/include)
+            set(SECP256K1_LIBRARY ${SECP256K1_INSTALL_DIR}/lib/libsecp256k1.a)
+            if(EXISTS ${SECP256K1_LIBRARY})
+                set(SECP256K1_FOUND TRUE)
+            endif()
+        endif()
     endif()
 endif()
 
 # Autolykos2 CPU reference backend (optional)
-option(MINICOIN_ENABLE_AUTOLYKOS2_REF "Enable Autolykos2 CPU reference backend" ON)
+option(SKALACOIN_ENABLE_AUTOLYKOS2_REF "Enable Autolykos2 CPU reference backend" ON)
-set(MINICOIN_AUTOLYKOS2_REF_AVAILABLE OFF)
+set(SKALACOIN_AUTOLYKOS2_REF_AVAILABLE OFF)
 
-if(MINICOIN_ENABLE_AUTOLYKOS2_REF)
+if(SKALACOIN_ENABLE_AUTOLYKOS2_REF)
     FetchContent_Declare(
         autolykos2_ref_src
         GIT_REPOSITORY https://github.com/mhssamadani/Autolykos2_NV_Miner.git
@@ -83,12 +159,24 @@ if(MINICOIN_ENABLE_AUTOLYKOS2_REF)
             $<$<COMPILE_LANGUAGE:CXX>:/FIstdlib.h>
         )
     endif()
+    if(TARGET CURL::libcurl)
         target_link_libraries(autolykos2_ref PRIVATE
             ${CMAKE_THREAD_LIBS_INIT}
             OpenSSL::SSL
             OpenSSL::Crypto
+            CURL::libcurl
         )
-    set(MINICOIN_AUTOLYKOS2_REF_AVAILABLE ON)
+    elseif(DEFINED CURL_LIBRARIES AND CURL_LIBRARIES)
+        target_link_libraries(autolykos2_ref PRIVATE
+            ${CMAKE_THREAD_LIBS_INIT}
+            OpenSSL::SSL
+            OpenSSL::Crypto
+            ${CURL_LIBRARIES}
+        )
+    else()
+        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)
 endif()
 
 # ---------------------------------------------------------
@@ -114,14 +202,18 @@ target_link_libraries(node PRIVATE
     OpenSSL::Crypto
 )
 
-if(SECP256K1_FOUND)
+if(TARGET PkgConfig::SECP256K1)
     target_link_libraries(node PRIVATE PkgConfig::SECP256K1)
-else()
+elseif(DEFINED SECP256K1_TARGET AND TARGET ${SECP256K1_TARGET})
+    target_link_libraries(node PRIVATE ${SECP256K1_TARGET})
+elseif(SECP256K1_FOUND AND SECP256K1_LIBRARY)
     target_include_directories(node PRIVATE ${SECP256K1_INCLUDE_DIR})
     target_link_libraries(node PRIVATE ${SECP256K1_LIBRARY})
+else()
+    message(FATAL_ERROR "secp256k1 not found and no vendored target available. Install libsecp256k1 or enable FetchContent builds.")
 endif()
 
-if(MINICOIN_AUTOLYKOS2_REF_AVAILABLE)
+if(SKALACOIN_AUTOLYKOS2_REF_AVAILABLE)
     target_link_libraries(node PRIVATE autolykos2_ref)
 endif()
 
@@ -136,6 +228,7 @@ target_compile_options(node PRIVATE
 )
 target_compile_definitions(node PRIVATE
     CHAIN_DATA_DIR="${CMAKE_BINARY_DIR}/chain_data"
-    $<$<BOOL:${MINICOIN_AUTOLYKOS2_REF_AVAILABLE}>:MINICOIN_AUTOLYKOS2_REF_AVAILABLE>
+    $<$<BOOL:${SKALACOIN_AUTOLYKOS2_REF_AVAILABLE}>:SKALACOIN_AUTOLYKOS2_REF_AVAILABLE>
+    $<$<BOOL:1>:_POSIX_C_SOURCE=200809L>
 )
-set_target_properties(node PROPERTIES OUTPUT_NAME "minicoin_node")
+set_target_properties(node PROPERTIES OUTPUT_NAME "skalacoin_node")

README.md

@@ -1,4 +1,4 @@
-# MiniCoin
+# Skalacoin
 
 Privacy coin made in C. One day hopefully with a purpose beyond "educational" :)
 
@@ -13,7 +13,7 @@ Build with clang/clang++ (I don't want to deal with the gcc/MSVC shenangans righ
 
 Use:
 ```bash
-./bin/minicoin_node <-mine>
+./bin/skalacoin_node <-mine>
 ```
 
 Main Hashing Algorithm: SHA256d (double SHA256) for now.

TODO.txt

@@ -1,11 +1,33 @@
-Move to a GPU algo. RandomX is a good candidate, but CPU mining is not that attractive to anyone but people who actually want to support the project.
+TODO:
-It won't incentivize people who want to profit, which let's be fair, is the majority of miners.
-
-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.
 
+Move the Networking Code to support win32 as well, as I'm just doing POSIX right now
+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.
+
+Move to a GPU algo. RandomX is a good candidate, but CPU mining is not that attractive to anyone but people who actually want to support the project.
+Sadly, CPUs won't incentivize people who want to profit, which let's be fair, is the majority of miners.

include/autolykos2/autolykos2.h

@@ -1,9 +1,10 @@
-#ifndef MINICOIN_AUTOLYKOS2_H
+#ifndef SKALACOIN_AUTOLYKOS2_H
-#define MINICOIN_AUTOLYKOS2_H
+#define SKALACOIN_AUTOLYKOS2_H
 
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
+#include <constants.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -11,11 +12,14 @@ extern "C" {
 
 typedef struct Autolykos2Context Autolykos2Context;
 
+extern uint64_t autolykos2_sleepBetweenHashOperationsMicroseconds;
+
 Autolykos2Context* Autolykos2_Create(void);
 void Autolykos2_Destroy(Autolykos2Context* ctx);
 
 bool Autolykos2_DagAllocate(Autolykos2Context* ctx, size_t bytes);
 bool Autolykos2_DagAppend(Autolykos2Context* ctx, const uint8_t* data, size_t len);
+bool Autolykos2_DagGenerate(Autolykos2Context* ctx, const uint8_t seed32[32]);
 void Autolykos2_DagClear(Autolykos2Context* ctx);
 size_t Autolykos2_DagSize(const Autolykos2Context* ctx);
 
@@ -24,15 +28,26 @@ bool Autolykos2_Hash(
 	const uint8_t* message,
 	size_t messageLen,
 	uint64_t nonce,
-	uint32_t height,
+	uint64_t height,
 	uint8_t outHash[32]
 );
 
+bool Autolykos2_LightHash(const uint8_t* seed, blockchain_t* chain, uint64_t nonce, uint8_t* out);
+bool Autolykos2_LightHashAtHeight(
+	const uint8_t seed32[32],
+	const uint8_t* message,
+	size_t messageLen,
+	uint64_t nonce,
+	uint64_t height,
+	size_t dagBytes,
+	uint8_t out[32]
+);
+
 bool Autolykos2_CheckTarget(
 	Autolykos2Context* ctx,
 	const uint8_t message32[32],
 	uint64_t nonce,
-	uint32_t height,
+	uint64_t height,
 	const uint8_t target32[32],
 	uint8_t outHash[32]
 );
@@ -40,7 +55,7 @@ bool Autolykos2_CheckTarget(
 bool Autolykos2_FindNonceSingleCore(
 	Autolykos2Context* ctx,
 	const uint8_t message32[32],
-	uint32_t height,
+	uint64_t height,
 	const uint8_t target32[32],
 	uint64_t startNonce,
 	uint64_t maxIterations,
@@ -48,6 +63,8 @@ bool Autolykos2_FindNonceSingleCore(
 	uint8_t outHash[32]
 );
 
+void Autolykos2_SetSleepBetweenHashOperations(uint64_t sleepMicroseconds);
+
 #ifdef __cplusplus
 }
 #endif

include/balance_sheet.h

@@ -2,10 +2,40 @@
 #define BALANCE_SHEET_H
 
 #include <stdint.h>
+#include <dynarr.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <khash/khash.h>
+#include <crypto/crypto.h>
+#include <block/transaction.h>
+#include <string.h>
+#include <utils.h>
+#include <uint256.h>
 
 typedef struct {
     uint8_t address[32]; // For now just the SHA-256 of the public key; allows representation in different encodings (base58, bech32, etc) without changing the underlying data structure
-    uint64_t balance;
+    uint256_t balance;
+    // TODO: Additional things
 } balance_sheet_entry_t;
 
+KHASH_INIT(balance_sheet_map_m, key32_t, balance_sheet_entry_t, 1, hash_key32, eq_key32)
+extern khash_t(balance_sheet_map_m)* sheetMap;
+
+void BalanceSheet_Init();
+int BalanceSheet_Insert(balance_sheet_entry_t entry);
+bool BalanceSheet_Lookup(uint8_t* address, balance_sheet_entry_t* out);
+bool BalanceSheet_SaveToFile(const char* outPath);
+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/blake2/blake2.h

@@ -1,12 +1,12 @@
-#ifndef MINICOIN_BLAKE2_H
+#ifndef SKALACOIN_BLAKE2_H
-#define MINICOIN_BLAKE2_H
+#define SKALACOIN_BLAKE2_H
 
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
 
-#define MINICOIN_BLAKE2B_OUTBYTES 64
+#define SKALACOIN_BLAKE2B_OUTBYTES 64
-#define MINICOIN_BLAKE2S_OUTBYTES 32
+#define SKALACOIN_BLAKE2S_OUTBYTES 32
 
 bool Blake2b_Hash(const uint8_t* input, size_t inputLen, uint8_t* out, size_t outLen);
 bool Blake2s_Hash(const uint8_t* input, size_t inputLen, uint8_t* out, size_t outLen);

include/block/block.h

@@ -9,6 +9,7 @@
 #include <string.h>
 #include <stdlib.h>
 
+#pragma pack(push, 1) // Ensure no padding for consistent file storage
 typedef struct {
     uint64_t blockNumber;
     uint64_t timestamp;
@@ -19,22 +20,29 @@ typedef struct {
     uint8_t version;
     uint8_t reserved[3];       // 3 bytes (Explicit padding for 8-byte alignment)
 } block_header_t;
+#pragma pack(pop)
 
 typedef struct {
     block_header_t header;
-    DynArr* transactions; // Array of signed_transaction_t
+    DynArr* transactions; // Array of signed_transaction_t, NOTE: Potentially move to a hashmap at some point for quick lookups.
 } block_t;
 
 block_t* Block_Create();
 void Block_CalculateHash(const block_t* block, uint8_t* outHash);
 void Block_CalculateMerkleRoot(const block_t* block, uint8_t* outHash);
 void Block_CalculateAutolykos2Hash(const block_t* block, uint8_t* outHash);
+bool Block_RebuildAutolykos2Dag(size_t dagBytes, const uint8_t seed32[32]);
 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

@@ -9,6 +9,7 @@
 #include <string.h>
 #include <uint256.h>
 #include <storage/block_table.h>
+#include <balance_sheet.h>
 
 typedef struct {
     DynArr* blocks;
@@ -23,9 +24,21 @@ 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);
+bool Chain_LoadFromFile(blockchain_t* chain, const char* dirpath, uint256_t* outCurrentSupply, uint32_t* outDifficultyTarget, uint64_t* outCurrentReward, uint8_t* outLastSavedHash, bool loadTransactions);
+bool Chain_LoadBlockFromFile(const char* dirpath, uint64_t blockNumber, bool loadTransactions, block_t** outBlock, size_t* outTxCount);
 
 // Difficulty
 uint32_t Chain_ComputeNextTarget(blockchain_t* chain, uint32_t currentTarget);

include/block/transaction.h

@@ -21,6 +21,7 @@ static inline bool Address_IsCoinbase(const uint8_t address[32]) {
 }
 
 // 160 bytes total for v1
+#pragma pack(push, 1) // Ensure no padding for consistent file storage
 typedef struct {
     uint64_t fee; // Rewarded to the miner; can be zero, but the miner may choose to ignore transactions with very low fees
     uint64_t amount1;
@@ -40,9 +41,9 @@ typedef struct {
     uint8_t version;
     uint8_t reserved[6]; // 6 bytes (Explicit padding for 8-byte alignment)
 } transaction_t;
+#pragma pack(pop)
 
 typedef struct {
-    uint8_t txHash[32];
     uint8_t signature[64]; // Signature of the hash
 } transaction_sig_t;
 
@@ -51,6 +52,7 @@ typedef struct {
     transaction_sig_t signature;
 } signed_transaction_t;
 
+void Transaction_Init(signed_transaction_t* tx);
 void Transaction_CalculateHash(const signed_transaction_t* tx, uint8_t* outHash);
 void Transaction_Sign(signed_transaction_t* tx, const uint8_t* privateKey);
 bool Transaction_Verify(const signed_transaction_t* tx);

include/constants.h

@@ -7,12 +7,38 @@
 #include <block/chain.h>
 #include <block/block.h>
 
+#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)
+#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).
+
+// Economics
 #define DECIMALS 1000000000000ULL
-#define DIFFICULTY_ADJUSTMENT_INTERVAL 960 // Every 960 blocks (roughly every 24 hours with a 90 second block time)
+#define DIFFICULTY_ADJUSTMENT_INTERVAL 3840 // Every 3840 blocks (roughly every 4 days with a 90 second block time)
                                            // Max adjustment per is x2. So if blocks are coming in too fast, the difficulty will at most double every 24 hours, and vice versa if they're coming in too slow.
 #define TARGET_BLOCK_TIME 90 // Target block time in seconds
 //#define INITIAL_DIFFICULTY 0x1f0c1422 // Default compact target used by Autolykos2 PoW (This is ridiculously low)
-#define INITIAL_DIFFICULTY 0x1d1b7c51 // This takes 90s on my machine with a single thread, good for testing
+#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
@@ -29,16 +55,15 @@
 
 // Future Autolykos2 constants:
 #define EPOCH_LENGTH 350000 // ~1 year at 90s
-#define BASE_DAG_SIZE (2ULL << 30) // 2 GB
+#define DAG_BASE_GROWTH (1ULL << 30) // 1 GB per epoch, adjusted by acceleration
-#define DAG_BASE_GROWTH (1ULL << 30) // 1 GB, calculated fully later
+//#define DAG_BASE_SIZE (6ULL << 30) // 6 GB, adjusted per cycle based off DAG_BASE_GROWTH
-#define DAG_BASE_CAP (8ULL << 30) // 8 GB, adjusted per cycle based off DAG_BASE_GROWTH
+#define DAG_BASE_SIZE (1ULL << 30) // TEMPORARY FOR TESTING
 // Swings - calculated as MIN(percentage, absolute GB) to prevent absurd swings from low hashrate or very large DAG growth
-#define DAG_MAX_UP_SWING_PERCENTAGE 1.3 // 30%
+#define DAG_MAX_UP_SWING_PERCENTAGE 1.15 // 15%
-#define DAG_MAX_DOWN_SWING_PERCENTAGE 0.85 // 15%
+#define DAG_MAX_DOWN_SWING_PERCENTAGE 0.90 // 10%
-#define DAG_MAX_UP_SWING_GB (4ULL << 30) // 4 GB
+#define DAG_MAX_UP_SWING_GB (2ULL << 30) // 2 GB
 #define DAG_MAX_DOWN_SWING_GB (1ULL << 30) // 1 GB
-#define KICKOUT_TARGET_PERCENTAGE 75
+#define DAG_GENESIS_SEED 0x00 // Genesis seed is zeroes, every epoch's seed is the hash of the previous block, therefore unpredictable until the block is mined
-#define KICKOUT_TARGET_BLOCK 30000 // 1 month at 90s block time
 
 /**
  * Each epoch has 2 phases, connected logarithmically:
@@ -48,11 +73,8 @@
 
 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
@@ -149,4 +171,77 @@ static inline uint64_t CalculateBlockReward(uint256_t currentSupply, blockchain_
     return GetInflationRateReward(currentSupply, chain);
 }
 
+// Hashing DAG
+#include <math.h>
+static inline size_t CalculateTargetDAGSize(blockchain_t* chain) {
+    // Base size plus (base growth * difficulty factor), adjusted by acceleration
+    if (!chain || !chain->blocks) { return 0; } // Invalid
+    uint64_t height = (uint64_t)Chain_Size(chain);
+    
+    if (height < EPOCH_LENGTH) {
+        return DAG_BASE_SIZE;
+    }
+
+    // Get the height - EPOCH_LENGTH block and the last block;
+    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;
+    int64_t growth = (DAG_BASE_GROWTH * difficultyDelta); // Can be negative if difficulty has decreased, which is why we use int64_t
+
+    // Clamp
+    if (growth > 0) {
+        // Difficulty increased -> Clamp the UPWARD swing
+        int64_t maxUp = (int64_t)((DAG_BASE_SIZE * 15) / 100); // 15%
+        if (growth > maxUp) growth = maxUp;
+        if (growth > (int64_t)DAG_MAX_UP_SWING_GB) growth = DAG_MAX_UP_SWING_GB;
+    } else {
+        // Difficulty decreased -> Clamp the DOWNWARD swing
+        int64_t maxDown = (int64_t)((DAG_BASE_SIZE * 10) / 100); // 10%
+        if (-growth > maxDown) growth = -maxDown;
+        if (-growth > (int64_t)DAG_MAX_DOWN_SWING_GB) growth = -(int64_t)DAG_MAX_DOWN_SWING_GB;
+    }
+    
+    int64_t targetSize = (int64_t)DAG_BASE_SIZE + growth;
+    if (targetSize <= 0) {
+        Block_Destroy(lastBlock);
+        Block_Destroy(epochStartBlock);
+        return 0;
+    }
+
+    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]) {
+    if (!chain || !chain->blocks || !outSeed) { return; } // Invalid
+    uint64_t height = (uint64_t)Chain_Size(chain);
+
+    if (height < EPOCH_LENGTH) {
+        memset(outSeed, DAG_GENESIS_SEED, 32);
+        return;
+    }
+
+    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/crypto/crypto.h

@@ -9,5 +9,6 @@
 
 bool Crypto_VerifySignature(const uint8_t* data, size_t len, const uint8_t* signature, const uint8_t* publicKey);
 void Crypto_SignData(const uint8_t* data, size_t len, const uint8_t* privateKey, uint8_t* outSignature);
+void to_hex(const uint8_t *in, char *out);
 
 #endif

include/dynarr.h

@@ -55,6 +55,9 @@ size_t DynArr_capacity(DynArr* p);
 
 void DynArr_destroy(DynArr* p);
 
+// Note: Make sure to not overread or overwrite
+void* DynArr_c_arr(DynArr* p);
+
 #define DYNARR_CREATE(T, initialCapacity) DynArr_create(sizeof(T), initialCapacity)
 
 #endif

include/khash/khash.h

@@ -0,0 +1,627 @@
+/* The MIT License
+
+   Copyright (c) 2008, 2009, 2011 by Attractive Chaos <attractor@live.co.uk>
+
+   Permission is hereby granted, free of charge, to any person obtaining
+   a copy of this software and associated documentation files (the
+   "Software"), to deal in the Software without restriction, including
+   without limitation the rights to use, copy, modify, merge, publish,
+   distribute, sublicense, and/or sell copies of the Software, and to
+   permit persons to whom the Software is furnished to do so, subject to
+   the following conditions:
+
+   The above copyright notice and this permission notice shall be
+   included in all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+   BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+   ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+   SOFTWARE.
+*/
+
+/*
+  An example:
+
+#include "khash.h"
+KHASH_MAP_INIT_INT(32, char)
+int main() {
+	int ret, is_missing;
+	khiter_t k;
+	khash_t(32) *h = kh_init(32);
+	k = kh_put(32, h, 5, &ret);
+	kh_value(h, k) = 10;
+	k = kh_get(32, h, 10);
+	is_missing = (k == kh_end(h));
+	k = kh_get(32, h, 5);
+	kh_del(32, h, k);
+	for (k = kh_begin(h); k != kh_end(h); ++k)
+		if (kh_exist(h, k)) kh_value(h, k) = 1;
+	kh_destroy(32, h);
+	return 0;
+}
+*/
+
+/*
+  2013-05-02 (0.2.8):
+
+	* Use quadratic probing. When the capacity is power of 2, stepping function
+	  i*(i+1)/2 guarantees to traverse each bucket. It is better than double
+	  hashing on cache performance and is more robust than linear probing.
+
+	  In theory, double hashing should be more robust than quadratic probing.
+	  However, my implementation is probably not for large hash tables, because
+	  the second hash function is closely tied to the first hash function,
+	  which reduce the effectiveness of double hashing.
+
+	Reference: http://research.cs.vt.edu/AVresearch/hashing/quadratic.php
+
+  2011-12-29 (0.2.7):
+
+    * Minor code clean up; no actual effect.
+
+  2011-09-16 (0.2.6):
+
+	* The capacity is a power of 2. This seems to dramatically improve the
+	  speed for simple keys. Thank Zilong Tan for the suggestion. Reference:
+
+	   - http://code.google.com/p/ulib/
+	   - http://nothings.org/computer/judy/
+
+	* Allow to optionally use linear probing which usually has better
+	  performance for random input. Double hashing is still the default as it
+	  is more robust to certain non-random input.
+
+	* Added Wang's integer hash function (not used by default). This hash
+	  function is more robust to certain non-random input.
+
+  2011-02-14 (0.2.5):
+
+    * Allow to declare global functions.
+
+  2009-09-26 (0.2.4):
+
+    * Improve portability
+
+  2008-09-19 (0.2.3):
+
+	* Corrected the example
+	* Improved interfaces
+
+  2008-09-11 (0.2.2):
+
+	* Improved speed a little in kh_put()
+
+  2008-09-10 (0.2.1):
+
+	* Added kh_clear()
+	* Fixed a compiling error
+
+  2008-09-02 (0.2.0):
+
+	* Changed to token concatenation which increases flexibility.
+
+  2008-08-31 (0.1.2):
+
+	* Fixed a bug in kh_get(), which has not been tested previously.
+
+  2008-08-31 (0.1.1):
+
+	* Added destructor
+*/
+
+
+#ifndef __AC_KHASH_H
+#define __AC_KHASH_H
+
+/*!
+  @header
+
+  Generic hash table library.
+ */
+
+#define AC_VERSION_KHASH_H "0.2.8"
+
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+
+/* compiler specific configuration */
+
+#if UINT_MAX == 0xffffffffu
+typedef unsigned int khint32_t;
+#elif ULONG_MAX == 0xffffffffu
+typedef unsigned long khint32_t;
+#endif
+
+#if ULONG_MAX == ULLONG_MAX
+typedef unsigned long khint64_t;
+#else
+typedef unsigned long long khint64_t;
+#endif
+
+#ifndef kh_inline
+#ifdef _MSC_VER
+#define kh_inline __inline
+#else
+#define kh_inline inline
+#endif
+#endif /* kh_inline */
+
+#ifndef klib_unused
+#if (defined __clang__ && __clang_major__ >= 3) || (defined __GNUC__ && __GNUC__ >= 3)
+#define klib_unused __attribute__ ((__unused__))
+#else
+#define klib_unused
+#endif
+#endif /* klib_unused */
+
+typedef khint32_t khint_t;
+typedef khint_t khiter_t;
+
+#define __ac_isempty(flag, i) ((flag[i>>4]>>((i&0xfU)<<1))&2)
+#define __ac_isdel(flag, i) ((flag[i>>4]>>((i&0xfU)<<1))&1)
+#define __ac_iseither(flag, i) ((flag[i>>4]>>((i&0xfU)<<1))&3)
+#define __ac_set_isdel_false(flag, i) (flag[i>>4]&=~(1ul<<((i&0xfU)<<1)))
+#define __ac_set_isempty_false(flag, i) (flag[i>>4]&=~(2ul<<((i&0xfU)<<1)))
+#define __ac_set_isboth_false(flag, i) (flag[i>>4]&=~(3ul<<((i&0xfU)<<1)))
+#define __ac_set_isdel_true(flag, i) (flag[i>>4]|=1ul<<((i&0xfU)<<1))
+
+#define __ac_fsize(m) ((m) < 16? 1 : (m)>>4)
+
+#ifndef kroundup32
+#define kroundup32(x) (--(x), (x)|=(x)>>1, (x)|=(x)>>2, (x)|=(x)>>4, (x)|=(x)>>8, (x)|=(x)>>16, ++(x))
+#endif
+
+#ifndef kcalloc
+#define kcalloc(N,Z) calloc(N,Z)
+#endif
+#ifndef kmalloc
+#define kmalloc(Z) malloc(Z)
+#endif
+#ifndef krealloc
+#define krealloc(P,Z) realloc(P,Z)
+#endif
+#ifndef kfree
+#define kfree(P) free(P)
+#endif
+
+static const double __ac_HASH_UPPER = 0.77;
+
+#define __KHASH_TYPE(name, khkey_t, khval_t) \
+	typedef struct kh_##name##_s { \
+		khint_t n_buckets, size, n_occupied, upper_bound; \
+		khint32_t *flags; \
+		khkey_t *keys; \
+		khval_t *vals; \
+	} kh_##name##_t;
+
+#define __KHASH_PROTOTYPES(name, khkey_t, khval_t)	 					\
+	extern kh_##name##_t *kh_init_##name(void);							\
+	extern void kh_destroy_##name(kh_##name##_t *h);					\
+	extern void kh_clear_##name(kh_##name##_t *h);						\
+	extern khint_t kh_get_##name(const kh_##name##_t *h, khkey_t key); 	\
+	extern int kh_resize_##name(kh_##name##_t *h, khint_t new_n_buckets); \
+	extern khint_t kh_put_##name(kh_##name##_t *h, khkey_t key, int *ret); \
+	extern void kh_del_##name(kh_##name##_t *h, khint_t x);
+
+#define __KHASH_IMPL(name, SCOPE, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) \
+	SCOPE kh_##name##_t *kh_init_##name(void) {							\
+		return (kh_##name##_t*)kcalloc(1, sizeof(kh_##name##_t));		\
+	}																	\
+	SCOPE void kh_destroy_##name(kh_##name##_t *h)						\
+	{																	\
+		if (h) {														\
+			kfree((void *)h->keys); kfree(h->flags);					\
+			kfree((void *)h->vals);										\
+			kfree(h);													\
+		}																\
+	}																	\
+	SCOPE void kh_clear_##name(kh_##name##_t *h)						\
+	{																	\
+		if (h && h->flags) {											\
+			memset(h->flags, 0xaa, __ac_fsize(h->n_buckets) * sizeof(khint32_t)); \
+			h->size = h->n_occupied = 0;								\
+		}																\
+	}																	\
+	SCOPE khint_t kh_get_##name(const kh_##name##_t *h, khkey_t key) 	\
+	{																	\
+		if (h->n_buckets) {												\
+			khint_t k, i, last, mask, step = 0; \
+			mask = h->n_buckets - 1;									\
+			k = __hash_func(key); i = k & mask;							\
+			last = i; \
+			while (!__ac_isempty(h->flags, i) && (__ac_isdel(h->flags, i) || !__hash_equal(h->keys[i], key))) { \
+				i = (i + (++step)) & mask; \
+				if (i == last) return h->n_buckets;						\
+			}															\
+			return __ac_iseither(h->flags, i)? h->n_buckets : i;		\
+		} else return 0;												\
+	}																	\
+	SCOPE int kh_resize_##name(kh_##name##_t *h, khint_t new_n_buckets) \
+	{ /* This function uses 0.25*n_buckets bytes of working space instead of [sizeof(key_t+val_t)+.25]*n_buckets. */ \
+		khint32_t *new_flags = 0;										\
+		khint_t j = 1;													\
+		{																\
+			kroundup32(new_n_buckets); 									\
+			if (new_n_buckets < 4) new_n_buckets = 4;					\
+			if (h->size >= (khint_t)(new_n_buckets * __ac_HASH_UPPER + 0.5)) j = 0;	/* requested size is too small */ \
+			else { /* hash table size to be changed (shrink or expand); rehash */ \
+				new_flags = (khint32_t*)kmalloc(__ac_fsize(new_n_buckets) * sizeof(khint32_t));	\
+				if (!new_flags) return -1;								\
+				memset(new_flags, 0xaa, __ac_fsize(new_n_buckets) * sizeof(khint32_t)); \
+				if (h->n_buckets < new_n_buckets) {	/* expand */		\
+					khkey_t *new_keys = (khkey_t*)krealloc((void *)h->keys, new_n_buckets * sizeof(khkey_t)); \
+					if (!new_keys) { kfree(new_flags); return -1; }		\
+					h->keys = new_keys;									\
+					if (kh_is_map) {									\
+						khval_t *new_vals = (khval_t*)krealloc((void *)h->vals, new_n_buckets * sizeof(khval_t)); \
+						if (!new_vals) { kfree(new_flags); return -1; }	\
+						h->vals = new_vals;								\
+					}													\
+				} /* otherwise shrink */								\
+			}															\
+		}																\
+		if (j) { /* rehashing is needed */								\
+			for (j = 0; j != h->n_buckets; ++j) {						\
+				if (__ac_iseither(h->flags, j) == 0) {					\
+					khkey_t key = h->keys[j];							\
+					khval_t val;										\
+					khint_t new_mask;									\
+					new_mask = new_n_buckets - 1; 						\
+					if (kh_is_map) val = h->vals[j];					\
+					__ac_set_isdel_true(h->flags, j);					\
+					while (1) { /* kick-out process; sort of like in Cuckoo hashing */ \
+						khint_t k, i, step = 0; \
+						k = __hash_func(key);							\
+						i = k & new_mask;								\
+						while (!__ac_isempty(new_flags, i)) i = (i + (++step)) & new_mask; \
+						__ac_set_isempty_false(new_flags, i);			\
+						if (i < h->n_buckets && __ac_iseither(h->flags, i) == 0) { /* kick out the existing element */ \
+							{ khkey_t tmp = h->keys[i]; h->keys[i] = key; key = tmp; } \
+							if (kh_is_map) { khval_t tmp = h->vals[i]; h->vals[i] = val; val = tmp; } \
+							__ac_set_isdel_true(h->flags, i); /* mark it as deleted in the old hash table */ \
+						} else { /* write the element and jump out of the loop */ \
+							h->keys[i] = key;							\
+							if (kh_is_map) h->vals[i] = val;			\
+							break;										\
+						}												\
+					}													\
+				}														\
+			}															\
+			if (h->n_buckets > new_n_buckets) { /* shrink the hash table */ \
+				h->keys = (khkey_t*)krealloc((void *)h->keys, new_n_buckets * sizeof(khkey_t)); \
+				if (kh_is_map) h->vals = (khval_t*)krealloc((void *)h->vals, new_n_buckets * sizeof(khval_t)); \
+			}															\
+			kfree(h->flags); /* free the working space */				\
+			h->flags = new_flags;										\
+			h->n_buckets = new_n_buckets;								\
+			h->n_occupied = h->size;									\
+			h->upper_bound = (khint_t)(h->n_buckets * __ac_HASH_UPPER + 0.5); \
+		}																\
+		return 0;														\
+	}																	\
+	SCOPE khint_t kh_put_##name(kh_##name##_t *h, khkey_t key, int *ret) \
+	{																	\
+		khint_t x;														\
+		if (h->n_occupied >= h->upper_bound) { /* update the hash table */ \
+			if (h->n_buckets > (h->size<<1)) {							\
+				if (kh_resize_##name(h, h->n_buckets - 1) < 0) { /* clear "deleted" elements */ \
+					*ret = -1; return h->n_buckets;						\
+				}														\
+			} else if (kh_resize_##name(h, h->n_buckets + 1) < 0) { /* expand the hash table */ \
+				*ret = -1; return h->n_buckets;							\
+			}															\
+		} /* TODO: to implement automatically shrinking; resize() already support shrinking */ \
+		{																\
+			khint_t k, i, site, last, mask = h->n_buckets - 1, step = 0; \
+			x = site = h->n_buckets; k = __hash_func(key); i = k & mask; \
+			if (__ac_isempty(h->flags, i)) x = i; /* for speed up */	\
+			else {														\
+				last = i; \
+				while (!__ac_isempty(h->flags, i) && (__ac_isdel(h->flags, i) || !__hash_equal(h->keys[i], key))) { \
+					if (__ac_isdel(h->flags, i)) site = i;				\
+					i = (i + (++step)) & mask; \
+					if (i == last) { x = site; break; }					\
+				}														\
+				if (x == h->n_buckets) {								\
+					if (__ac_isempty(h->flags, i) && site != h->n_buckets) x = site; \
+					else x = i;											\
+				}														\
+			}															\
+		}																\
+		if (__ac_isempty(h->flags, x)) { /* not present at all */		\
+			h->keys[x] = key;											\
+			__ac_set_isboth_false(h->flags, x);							\
+			++h->size; ++h->n_occupied;									\
+			*ret = 1;													\
+		} else if (__ac_isdel(h->flags, x)) { /* deleted */				\
+			h->keys[x] = key;											\
+			__ac_set_isboth_false(h->flags, x);							\
+			++h->size;													\
+			*ret = 2;													\
+		} else *ret = 0; /* Don't touch h->keys[x] if present and not deleted */ \
+		return x;														\
+	}																	\
+	SCOPE void kh_del_##name(kh_##name##_t *h, khint_t x)				\
+	{																	\
+		if (x != h->n_buckets && !__ac_iseither(h->flags, x)) {			\
+			__ac_set_isdel_true(h->flags, x);							\
+			--h->size;													\
+		}																\
+	}
+
+#define KHASH_DECLARE(name, khkey_t, khval_t)		 					\
+	__KHASH_TYPE(name, khkey_t, khval_t) 								\
+	__KHASH_PROTOTYPES(name, khkey_t, khval_t)
+
+#define KHASH_INIT2(name, SCOPE, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) \
+	__KHASH_TYPE(name, khkey_t, khval_t) 								\
+	__KHASH_IMPL(name, SCOPE, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal)
+
+#define KHASH_INIT(name, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) \
+	KHASH_INIT2(name, static kh_inline klib_unused, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal)
+
+/* --- BEGIN OF HASH FUNCTIONS --- */
+
+/*! @function
+  @abstract     Integer hash function
+  @param  key   The integer [khint32_t]
+  @return       The hash value [khint_t]
+ */
+#define kh_int_hash_func(key) (khint32_t)(key)
+/*! @function
+  @abstract     Integer comparison function
+ */
+#define kh_int_hash_equal(a, b) ((a) == (b))
+/*! @function
+  @abstract     64-bit integer hash function
+  @param  key   The integer [khint64_t]
+  @return       The hash value [khint_t]
+ */
+#define kh_int64_hash_func(key) (khint32_t)((key)>>33^(key)^(key)<<11)
+/*! @function
+  @abstract     64-bit integer comparison function
+ */
+#define kh_int64_hash_equal(a, b) ((a) == (b))
+/*! @function
+  @abstract     const char* hash function
+  @param  s     Pointer to a null terminated string
+  @return       The hash value
+ */
+static kh_inline khint_t __ac_X31_hash_string(const char *s)
+{
+	khint_t h = (khint_t)*s;
+	if (h) for (++s ; *s; ++s) h = (h << 5) - h + (khint_t)*s;
+	return h;
+}
+/*! @function
+  @abstract     Another interface to const char* hash function
+  @param  key   Pointer to a null terminated string [const char*]
+  @return       The hash value [khint_t]
+ */
+#define kh_str_hash_func(key) __ac_X31_hash_string(key)
+/*! @function
+  @abstract     Const char* comparison function
+ */
+#define kh_str_hash_equal(a, b) (strcmp(a, b) == 0)
+
+static kh_inline khint_t __ac_Wang_hash(khint_t key)
+{
+    key += ~(key << 15);
+    key ^=  (key >> 10);
+    key +=  (key << 3);
+    key ^=  (key >> 6);
+    key += ~(key << 11);
+    key ^=  (key >> 16);
+    return key;
+}
+#define kh_int_hash_func2(key) __ac_Wang_hash((khint_t)key)
+
+/* --- END OF HASH FUNCTIONS --- */
+
+/* Other convenient macros... */
+
+/*!
+  @abstract Type of the hash table.
+  @param  name  Name of the hash table [symbol]
+ */
+#define khash_t(name) kh_##name##_t
+
+/*! @function
+  @abstract     Initiate a hash table.
+  @param  name  Name of the hash table [symbol]
+  @return       Pointer to the hash table [khash_t(name)*]
+ */
+#define kh_init(name) kh_init_##name()
+
+/*! @function
+  @abstract     Destroy a hash table.
+  @param  name  Name of the hash table [symbol]
+  @param  h     Pointer to the hash table [khash_t(name)*]
+ */
+#define kh_destroy(name, h) kh_destroy_##name(h)
+
+/*! @function
+  @abstract     Reset a hash table without deallocating memory.
+  @param  name  Name of the hash table [symbol]
+  @param  h     Pointer to the hash table [khash_t(name)*]
+ */
+#define kh_clear(name, h) kh_clear_##name(h)
+
+/*! @function
+  @abstract     Resize a hash table.
+  @param  name  Name of the hash table [symbol]
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @param  s     New size [khint_t]
+ */
+#define kh_resize(name, h, s) kh_resize_##name(h, s)
+
+/*! @function
+  @abstract     Insert a key to the hash table.
+  @param  name  Name of the hash table [symbol]
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @param  k     Key [type of keys]
+  @param  r     Extra return code: -1 if the operation failed;
+                0 if the key is present in the hash table;
+                1 if the bucket is empty (never used); 2 if the element in
+				the bucket has been deleted [int*]
+  @return       Iterator to the inserted element [khint_t]
+ */
+#define kh_put(name, h, k, r) kh_put_##name(h, k, r)
+
+/*! @function
+  @abstract     Retrieve a key from the hash table.
+  @param  name  Name of the hash table [symbol]
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @param  k     Key [type of keys]
+  @return       Iterator to the found element, or kh_end(h) if the element is absent [khint_t]
+ */
+#define kh_get(name, h, k) kh_get_##name(h, k)
+
+/*! @function
+  @abstract     Remove a key from the hash table.
+  @param  name  Name of the hash table [symbol]
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @param  k     Iterator to the element to be deleted [khint_t]
+ */
+#define kh_del(name, h, k) kh_del_##name(h, k)
+
+/*! @function
+  @abstract     Test whether a bucket contains data.
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @param  x     Iterator to the bucket [khint_t]
+  @return       1 if containing data; 0 otherwise [int]
+ */
+#define kh_exist(h, x) (!__ac_iseither((h)->flags, (x)))
+
+/*! @function
+  @abstract     Get key given an iterator
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @param  x     Iterator to the bucket [khint_t]
+  @return       Key [type of keys]
+ */
+#define kh_key(h, x) ((h)->keys[x])
+
+/*! @function
+  @abstract     Get value given an iterator
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @param  x     Iterator to the bucket [khint_t]
+  @return       Value [type of values]
+  @discussion   For hash sets, calling this results in segfault.
+ */
+#define kh_val(h, x) ((h)->vals[x])
+
+/*! @function
+  @abstract     Alias of kh_val()
+ */
+#define kh_value(h, x) ((h)->vals[x])
+
+/*! @function
+  @abstract     Get the start iterator
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @return       The start iterator [khint_t]
+ */
+#define kh_begin(h) (khint_t)(0)
+
+/*! @function
+  @abstract     Get the end iterator
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @return       The end iterator [khint_t]
+ */
+#define kh_end(h) ((h)->n_buckets)
+
+/*! @function
+  @abstract     Get the number of elements in the hash table
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @return       Number of elements in the hash table [khint_t]
+ */
+#define kh_size(h) ((h)->size)
+
+/*! @function
+  @abstract     Get the number of buckets in the hash table
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @return       Number of buckets in the hash table [khint_t]
+ */
+#define kh_n_buckets(h) ((h)->n_buckets)
+
+/*! @function
+  @abstract     Iterate over the entries in the hash table
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @param  kvar  Variable to which key will be assigned
+  @param  vvar  Variable to which value will be assigned
+  @param  code  Block of code to execute
+ */
+#define kh_foreach(h, kvar, vvar, code) { khint_t __i;		\
+	for (__i = kh_begin(h); __i != kh_end(h); ++__i) {		\
+		if (!kh_exist(h,__i)) continue;						\
+		(kvar) = kh_key(h,__i);								\
+		(vvar) = kh_val(h,__i);								\
+		code;												\
+	} }
+
+/*! @function
+  @abstract     Iterate over the values in the hash table
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @param  vvar  Variable to which value will be assigned
+  @param  code  Block of code to execute
+ */
+#define kh_foreach_value(h, vvar, code) { khint_t __i;		\
+	for (__i = kh_begin(h); __i != kh_end(h); ++__i) {		\
+		if (!kh_exist(h,__i)) continue;						\
+		(vvar) = kh_val(h,__i);								\
+		code;												\
+	} }
+
+/* More convenient interfaces */
+
+/*! @function
+  @abstract     Instantiate a hash set containing integer keys
+  @param  name  Name of the hash table [symbol]
+ */
+#define KHASH_SET_INIT_INT(name)										\
+	KHASH_INIT(name, khint32_t, char, 0, kh_int_hash_func, kh_int_hash_equal)
+
+/*! @function
+  @abstract     Instantiate a hash map containing integer keys
+  @param  name  Name of the hash table [symbol]
+  @param  khval_t  Type of values [type]
+ */
+#define KHASH_MAP_INIT_INT(name, khval_t)								\
+	KHASH_INIT(name, khint32_t, khval_t, 1, kh_int_hash_func, kh_int_hash_equal)
+
+/*! @function
+  @abstract     Instantiate a hash set containing 64-bit integer keys
+  @param  name  Name of the hash table [symbol]
+ */
+#define KHASH_SET_INIT_INT64(name)										\
+	KHASH_INIT(name, khint64_t, char, 0, kh_int64_hash_func, kh_int64_hash_equal)
+
+/*! @function
+  @abstract     Instantiate a hash map containing 64-bit integer keys
+  @param  name  Name of the hash table [symbol]
+  @param  khval_t  Type of values [type]
+ */
+#define KHASH_MAP_INIT_INT64(name, khval_t)								\
+	KHASH_INIT(name, khint64_t, khval_t, 1, kh_int64_hash_func, kh_int64_hash_equal)
+
+typedef const char *kh_cstr_t;
+/*! @function
+  @abstract     Instantiate a hash map containing const char* keys
+  @param  name  Name of the hash table [symbol]
+ */
+#define KHASH_SET_INIT_STR(name)										\
+	KHASH_INIT(name, kh_cstr_t, char, 0, kh_str_hash_func, kh_str_hash_equal)
+
+/*! @function
+  @abstract     Instantiate a hash map containing const char* keys
+  @param  name  Name of the hash table [symbol]
+  @param  khval_t  Type of values [type]
+ */
+#define KHASH_MAP_INIT_STR(name, khval_t)								\
+	KHASH_INIT(name, kh_cstr_t, khval_t, 1, kh_str_hash_func, kh_str_hash_equal)
+
+#endif /* __AC_KHASH_H */

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

@@ -0,0 +1,74 @@
+#ifndef NET_NODE_H
+#define NET_NODE_H
+
+#ifndef _WIN32
+// POSIX
+#include <tcpd/tcpconnection.h>
+#include <tcpd/tcpclient.h>
+#include <tcpd/tcpserver.h>
+#endif
+
+#include <constants.h>
+#include <packettype.h>
+
+#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;
+} net_node_t;
+
+net_node_t* Node_Create();
+void Node_Destroy(net_node_t* node);
+
+void Node_SetCallbacks(
+    net_node_t* node,
+    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* user
+);
+
+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);
+void Node_Server_OnData(tcp_connection_t* client);
+void Node_Server_OnDisconnect(tcp_connection_t* client);
+void Node_Client_OnConnect(tcp_connection_t* client);
+void Node_Client_OnData(tcp_connection_t* client);
+void Node_Client_OnDisconnect(tcp_connection_t* client);
+
+#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

@@ -1,9 +1,24 @@
 #ifndef PACKETTYPE_H
 #define PACKETTYPE_H
 
+#include <stdint.h>
+
 typedef enum {
     PACKET_TYPE_NONE = 0,
-    // Add more here
+    PACKET_TYPE_HELLO = 1, // Hello, let's connect! Here's who I am, and what I have!
-} PacketType;
+    PACKET_TYPE_ACK_HELLO = 2, // I received your hello, here's who I am and what I have (response to hello)
+    PACKET_TYPE_FETCH_BLOCK = 3, // I want a Block
+    PACKET_TYPE_BLOCK_DATA = 4, // Here's a Block (response to fetch) - I don't care what you do with it, but you wanted it, so here it is!
+    PACKET_TYPE_BROADCAST_BLOCK = 5, // Here's a new Block I want to share with the network (unsolicited - e.g. just mined it)
+    PACKET_TYPE_ACK_BLOCK = 6, // I have received your block, here's what I did with it (response to broadcast)
+    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_t;
+
+static inline int PacketType_IsValid(uint8_t packetType) {
+    return packetType > PACKET_TYPE_NONE && packetType < PACKET_TYPE_MAX;
+}
 
 #endif

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

@@ -1,29 +1,36 @@
 #ifndef TCPCLIENT_H
 #define TCPCLIENT_H
 
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
 #include <arpa/inet.h>
-#include <pthread.h>
+#include <stddef.h>
 #include <stdint.h>
-#include <dynarr.h>
 
-#define MTU 1500
+#include <constants.h>
+#include <tcpd/tcpconnection.h>
 
-struct TcpClient {
+typedef struct {
-    int clientFd;
+    tcp_connection_t* connection;
-    struct sockaddr_in clientAddr;
+    void (*on_connect)(tcp_connection_t* conn);
-    uint32_t clientId;
+    void (*on_data)(tcp_connection_t* conn);
+    void (*on_disconnect)(tcp_connection_t* conn);
+    void* owner;
+    uint64_t peerBlockHeight;
+} tcp_client_t;
 
-    unsigned char dataBuf[MTU];
+int TcpClient_Init(tcp_client_t* client);
-    ssize_t dataBufLen;
+void TcpClient_Destroy(tcp_client_t* client);
-    void (*on_data)(struct TcpClient* client);
-    void (*on_disconnect)(struct TcpClient* client);
 
-    pthread_t clientThread;
+int TcpClient_Connect(
-};
+    tcp_client_t* client,
+    const char* peerIp,
+    unsigned short peerPort,
+    void (*on_connect)(tcp_connection_t* conn),
+    void (*on_data)(tcp_connection_t* conn),
+    void (*on_disconnect)(tcp_connection_t* conn),
+    void* owner
+);
 
-typedef struct TcpClient TcpClient;
+int TcpClient_Send(tcp_client_t* client, const void* data, size_t len);
+void TcpClient_Disconnect(tcp_client_t* client);
 
 #endif

include/tcpd/tcpconnection.h

@@ -0,0 +1,74 @@
+#ifndef TCPCONNECTION_H
+#define TCPCONNECTION_H
+
+#include <arpa/inet.h>
+#include <pthread.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#define TCP_IO_BUFFER_SIZE 1500
+#define TCP_FRAME_HEADER_SIZE 4U
+#define TCP_MAX_FRAME_PAYLOAD (1024U * 1024U)
+
+typedef enum {
+    TCP_CONNECTION_ROLE_INBOUND = 0,
+    TCP_CONNECTION_ROLE_OUTBOUND = 1
+} tcp_connection_role_t;
+
+typedef struct tcp_connection_t tcp_connection_t;
+
+struct tcp_connection_t {
+    // TODO: We should make it so only ONE of this needs to be available. 
+    // Because of my temporary "I just need something that works" horseshit that I'm about to write, you'll need IPv4 and IPv6 is optional.
+    // Note to self: Don't pull an IETF and some "NAT exists, we're fine" bullshit, because if we end up with our eqvivalent of Teredo or CGNAT, I'm gonna be fucking pissed.
+    // And no, the solution isn't "eh, just bind to 0.0.0.0 and ignore it", because if we do that, we'll inevitably end up with a host that only has IPv6 and then we'll be fucked.
+    // Honestly, I'm proud of whoever runs IPv6-only. Brave soul.
+    int sockFd;
+    struct sockaddr_in peerAddr;
+#ifdef USE_IPV6
+    int sockFd6; // For IPv6 support
+    struct sockaddr_in6 peerAddr6; // For IPv6 support
+#endif
+    uint32_t connectionId;
+    tcp_connection_role_t role;
+
+    pthread_t ioThread;
+    pthread_mutex_t sendLock;
+    pthread_mutex_t stateLock;
+
+    bool closing;
+    bool disconnectedNotified;
+
+    unsigned char* dataBuf;
+    size_t dataBufLen;
+    size_t dataBufCap;
+
+    unsigned char headerBuf[TCP_FRAME_HEADER_SIZE];
+    size_t headerBytesRead;
+    uint32_t expectedPayloadLen;
+    unsigned char* frameBuf;
+    size_t frameBytesRead;
+
+    void (*on_data)(tcp_connection_t* conn);
+    void (*on_disconnect)(tcp_connection_t* conn);
+    void* owner;
+};
+
+int TcpConnection_Init(tcp_connection_t* conn, int sockFd, const struct sockaddr_in* 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);
+
+void TcpConnection_ResetFramingState(tcp_connection_t* conn);
+int TcpConnection_FeedFramedData(tcp_connection_t* conn, const unsigned char* input, size_t inputLen);
+
+// This just takes a socket ID, so it's independent from the v4/v6 stuff. It works for both.
+int TcpConnection_SendRaw(int sockFd, const void* data, size_t len);
+int TcpConnection_SendFramed(tcp_connection_t* conn, const void* payload, size_t payloadLen);
+
+void TcpConnection_RequestClose(tcp_connection_t* conn);
+void TcpConnection_MarkDisconnectNotified(tcp_connection_t* conn);
+bool TcpConnection_IsDisconnectNotified(tcp_connection_t* conn);
+
+#endif

include/tcpd/tcpserver.h

@@ -1,56 +1,58 @@
 #ifndef TCPSERVER_H
 #define TCPSERVER_H
 
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
 #include <arpa/inet.h>
-#include <stdlib.h>
 #include <pthread.h>
-#include <stdint.h>
+#include <stddef.h>
+#include <constants.h>
 
-#include <tcpd/tcpclient.h>
+#include <tcpd/tcpconnection.h>
-#include <numgen.h>
-#include <dynarr.h>
 
 typedef struct {
     int sockFd;
     struct sockaddr_in addr;
+#ifdef USE_IPV6
+    int sockFd6; // IPv6 support
+    struct sockaddr_in6 addr6; // IPv6 support
+#endif
     int opt;
+    int opt6; // IPv6 support
+    int isRunning;
+    void* owner;
 
     // Called before the client thread runs
-    void (*on_connect)(TcpClient* client);
+    void (*on_connect)(tcp_connection_t* client);
     // Called when data is received
-    void (*on_data)(TcpClient* client);
+    void (*on_data)(tcp_connection_t* client);
     // Called before the socket and client thread are killed; Do NOT free client manually
-    void (*on_disconnect)(TcpClient* client);
+    void (*on_disconnect)(tcp_connection_t* client);
 
     // max clients
-    size_t clients;
+    size_t maxClients;
-    TcpClient** clientsArrPtr;
+    tcp_connection_t** clientsArrPtr;
+    pthread_mutex_t clientsMutex;
 
     pthread_t svrThread;
-} TcpServer;
+} tcp_server_t;
 
 struct tcpclient_thread_args {
-    TcpClient* clientPtr;
+    tcp_connection_t* clientPtr;
-    TcpServer* serverPtr;
+    tcp_server_t* serverPtr;
 };
 
 typedef struct tcpclient_thread_args tcpclient_thread_args;
 
-TcpServer* TcpServer_Create();
+tcp_server_t* TcpServer_Create();
-void TcpServer_Destroy(TcpServer* ptr);
+void TcpServer_Destroy(tcp_server_t* ptr);
 
-void TcpServer_Init(TcpServer* ptr, unsigned short port, const char* addr);
+void TcpServer_Init(tcp_server_t* ptr, unsigned short port, const char* addr);
-void TcpServer_Start(TcpServer* ptr, int maxcons);
+void TcpServer_Start(tcp_server_t* ptr, int maxcons);
-void TcpServer_Stop(TcpServer* ptr);
+void TcpServer_Stop(tcp_server_t* ptr);
-void TcpServer_Send(TcpServer* ptr, TcpClient* cli, void* data, size_t len);
+int TcpServer_Send(tcp_server_t* ptr, tcp_connection_t* cli, const void* data, size_t len);
-void Generic_SendSocket(int sock, void* data, size_t len);
+void Generic_SendSocket(int sock, const void* data, size_t len);
-void TcpServer_Disconnect(TcpServer* ptr, TcpClient* cli);
+void TcpServer_Disconnect(tcp_server_t* ptr, tcp_connection_t* cli);
-void TcpServer_KillClient(TcpServer* ptr, TcpClient* cli);
+void TcpServer_KillClient(tcp_server_t* ptr, tcp_connection_t* cli);
 
-size_t Generic_FindClientInArrayByPtr(TcpClient** arr, TcpClient* ptr, size_t len);
+size_t Generic_FindClientInArrayByPtr(tcp_connection_t** arr, tcp_connection_t* ptr, size_t len);
 
 #endif

include/txmempool.h

@@ -0,0 +1,22 @@
+#ifndef TXMEMPOOL_H
+#define TXMEMPOOL_H
+
+#include <block/transaction.h>
+#include <khash/khash.h>
+#include <utils.h>
+#include <uint256.h>
+
+KHASH_INIT(tx_mempool_map_m, key32_t, signed_transaction_t, 1, hash_key32, eq_key32)
+extern khash_t(tx_mempool_map_m)* txMempool;
+
+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/uint256.h

@@ -55,6 +55,53 @@ static inline bool uint256_add(uint256_t* a, const uint256_t* b) {
     return carry > 0;
 }
 
+static inline bool uint256_subtract_u64(uint256_t* balance, uint64_t amount) {
+    if (!balance) {
+        return false;
+    }
+
+    if (balance->limbs[0] >= amount) {
+        balance->limbs[0] -= amount;
+        return false;
+    }
+
+    uint64_t borrow = amount - balance->limbs[0];
+    balance->limbs[0] = UINT64_MAX - borrow + 1ULL;
+
+    for (int i = 1; i < 4; ++i) {
+        if (balance->limbs[i] > 0) {
+            balance->limbs[i]--;
+            return false;
+        }
+
+        balance->limbs[i] = UINT64_MAX;
+    }
+
+    return true; // underflow past 256 bits
+}
+
+static inline bool uint256_subtract(uint256_t* a, const uint256_t* b) {
+    // Check if a < b to prevent underflow
+    for (int i = 3; i >= 0; i--) {
+        if (a->limbs[i] > b->limbs[i]) break;
+        if (a->limbs[i] < b->limbs[i]) return false; // Underflow
+    }
+
+    uint64_t borrow = 0;
+    for (int i = 0; i < 4; i++) {
+        uint64_t old_a = a->limbs[i];
+        a->limbs[i] -= b->limbs[i] + borrow;
+
+        // Detect borrow: if we subtracted more than we had, or we were at zero and had a borrow
+        if (borrow) {
+            borrow = (a->limbs[i] >= old_a);
+        } else {
+            borrow = (a->limbs[i] > old_a);
+        }
+    }
+    return true;
+}
+
 /**
  * Compares two uint256_t values in a greater-than manner.
  * Returns [-1, 0, 1] if a > b, a < b, or a == b respectively.
@@ -67,4 +114,35 @@ static inline int uint256_cmp(const uint256_t* a, const uint256_t* b) {
     return 0;
 }
 
+static inline void uint256_serialize(const uint256_t* value, char* out) {
+    if (!value || !out) {
+        return;
+    }
+
+    // Convert into string of decimal digits for easier readability; max 78 digits for 256 bits
+    char digits[80];
+    size_t digitCount = 0;
+    uint256_t tmp = *value;
+    while (tmp.limbs[0] != 0 || tmp.limbs[1] != 0 || tmp.limbs[2] != 0 || tmp.limbs[3] != 0) {
+        uint64_t remainder = 0;
+        for (int i = 3; i >= 0; --i) {
+            __uint128_t cur = ((__uint128_t)remainder << 64) | tmp.limbs[i];
+            tmp.limbs[i] = (uint64_t)(cur / 10u);
+            remainder = (uint64_t)(cur % 10u);
+        }
+
+        if (digitCount < sizeof(digits) - 1) {
+            digits[digitCount++] = (char)('0' + remainder);
+        } else {
+            break;
+        }
+    }
+    digits[digitCount] = '\0';
+
+    for (size_t i = 0; i < digitCount; ++i) {
+        out[i] = digits[digitCount - 1 - i];
+    }
+    out[digitCount] = '\0';
+}
+
 #endif

include/utils.h

@@ -0,0 +1,349 @@
+#ifndef UTILS_H
+#define UTILS_H
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+#include <crypto/crypto.h>
+#include <uint256.h>
+#include <time.h>
+
+typedef struct {
+    uint8_t bytes[32];
+} key32_t;
+
+static inline uint32_t hash_key32(key32_t k) {
+    uint32_t hash = 2166136261u;
+    for (int i = 0; i < 32; i++) {
+        hash ^= k.bytes[i];
+        hash *= 16777619;
+    }
+    return hash;
+}
+
+static inline int eq_key32(key32_t a, key32_t b) {
+    return memcmp(a.bytes, b.bytes, 32) == 0;
+}
+
+static inline uint64_t get_current_time_ms(void) {
+    struct timespec spec;
+    if (clock_gettime(CLOCK_REALTIME, &spec) == -1) {
+        return 0; // Handle error
+    }
+    // Convert seconds to milliseconds and add nanoseconds converted to milliseconds
+    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;
+    }
+    to_hex(address, out);
+}
+
+static inline void AddressFromCompressedPubkey(const uint8_t compressedPubkey[33], uint8_t outAddress[32]) {
+    if (!compressedPubkey || !outAddress) {
+        return;
+    }
+
+    SHA256(compressedPubkey, 33, outAddress);
+}
+
+static inline void PrintHexBytes(const uint8_t* bytes, size_t length) {
+    if (!bytes) {
+        return;
+    }
+
+    for (size_t i = 0; i < length; ++i) {
+        printf("%02x", bytes[i]);
+    }
+}
+
+static inline int CompareHashToTarget(const uint8_t hash[32], const uint8_t target[32]) {
+    if (!hash || !target) {
+        return 1;
+    }
+
+    for (size_t i = 0; i < 32; ++i) {
+        if (hash[i] < target[i]) {
+            return -1;
+        }
+        if (hash[i] > target[i]) {
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
+static inline bool DecodeCompactTarget(uint32_t nBits, uint8_t target[32]) {
+    if (!target) {
+        return false;
+    }
+
+    memset(target, 0, 32);
+
+    uint32_t exponent = nBits >> 24;
+    uint32_t mantissa = nBits & 0x007fffff;
+    bool negative = (nBits & 0x00800000) != 0;
+
+    if (negative || mantissa == 0) {
+        return false;
+    }
+
+    if (exponent <= 3) {
+        mantissa >>= 8 * (3 - exponent);
+        target[29] = (uint8_t)((mantissa >> 16) & 0xffu);
+        target[30] = (uint8_t)((mantissa >> 8) & 0xffu);
+        target[31] = (uint8_t)(mantissa & 0xffu);
+    } else {
+        uint32_t byteIndex = exponent - 3;
+        if (byteIndex > 29) {
+            return false;
+        }
+
+        target[32 - byteIndex - 3] = (uint8_t)((mantissa >> 16) & 0xffu);
+        target[32 - byteIndex - 2] = (uint8_t)((mantissa >> 8) & 0xffu);
+        target[32 - byteIndex - 1] = (uint8_t)(mantissa & 0xffu);
+    }
+
+    return true;
+}
+
+static inline bool GenerateTestMinerIdentity(uint8_t privateKey[32], uint8_t compressedPubkey[33], uint8_t address[32]) {
+    if (!privateKey || !compressedPubkey || !address) {
+        return false;
+    }
+
+    secp256k1_context* ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN);
+    if (!ctx) {
+        return false;
+    }
+
+    uint8_t seed[64];
+    secp256k1_pubkey pubkey;
+
+    for (uint64_t counter = 0; counter < 1024; ++counter) {
+        const char* base = "skalacoin-test-miner-key";
+        size_t baseLen = strlen(base);
+        memcpy(seed, base, baseLen);
+        memcpy(seed + baseLen, &counter, sizeof(counter));
+        SHA256(seed, baseLen + sizeof(counter), privateKey);
+
+        if (!secp256k1_ec_seckey_verify(ctx, privateKey)) {
+            continue;
+        }
+
+        if (!secp256k1_ec_pubkey_create(ctx, &pubkey, privateKey)) {
+            continue;
+        }
+
+        size_t pubLen = 33;
+        if (!secp256k1_ec_pubkey_serialize(ctx, compressedPubkey, &pubLen, &pubkey, SECP256K1_EC_COMPRESSED) || pubLen != 33) {
+            continue;
+        }
+
+        AddressFromCompressedPubkey(compressedPubkey, address);
+        secp256k1_context_destroy(ctx);
+        return true;
+    }
+
+    secp256k1_context_destroy(ctx);
+    return false;
+}
+
+static inline bool GenerateRandomTestAddress(uint8_t outAddress[32], uint8_t outPrivateKey[32], uint8_t outCompressedPubkey[33]) {
+    if (!outAddress) {
+        return false;
+    }
+
+    uint8_t privateKey[32];
+    uint8_t compressedPubkey[33];
+    secp256k1_pubkey pubkey;
+
+    secp256k1_context* ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN);
+    if (!ctx) {
+        return false;
+    }
+
+    for (size_t attempt = 0; attempt < 4096; ++attempt) {
+        for (size_t i = 0; i < sizeof(privateKey); ++i) {
+            privateKey[i] = (uint8_t)(rand() & 0xFF);
+        }
+
+        if (!secp256k1_ec_seckey_verify(ctx, privateKey)) {
+            continue;
+        }
+
+        if (!secp256k1_ec_pubkey_create(ctx, &pubkey, privateKey)) {
+            continue;
+        }
+
+        size_t pubLen = sizeof(compressedPubkey);
+        if (!secp256k1_ec_pubkey_serialize(ctx, compressedPubkey, &pubLen, &pubkey, SECP256K1_EC_COMPRESSED) || pubLen != 33) {
+            continue;
+        }
+
+        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;
+}
+
+static inline bool ParseHexAddress32(const char* in, uint8_t outAddress[32]) {
+    if (!in || !outAddress) {
+        return false;
+    }
+
+    const char* p = in;
+    if (p[0] == '0' && (p[1] == 'x' || p[1] == 'X')) {
+        p += 2;
+    }
+
+    if (strlen(p) != 64) {
+        return false;
+    }
+
+    for (size_t i = 0; i < 32; ++i) {
+        char hi = p[i * 2];
+        char lo = p[i * 2 + 1];
+        int hiVal = (hi >= '0' && hi <= '9') ? (hi - '0') :
+                    (hi >= 'a' && hi <= 'f') ? (10 + hi - 'a') :
+                    (hi >= 'A' && hi <= 'F') ? (10 + hi - 'A') : -1;
+        int loVal = (lo >= '0' && lo <= '9') ? (lo - '0') :
+                    (lo >= 'a' && lo <= 'f') ? (10 + lo - 'a') :
+                    (lo >= 'A' && lo <= 'F') ? (10 + lo - 'A') : -1;
+
+        if (hiVal < 0 || loVal < 0) {
+            return false;
+        }
+
+        outAddress[i] = (uint8_t)((hiVal << 4) | loVal);
+    }
+
+    return true;
+}
+
+static inline bool IsValidIPv4(const char* ip) {
+    if (!ip || *ip == '\0') {
+        return false;
+    }
+
+    int octetCount = 0;
+    const char* p = ip;
+
+    while (*p != '\0') {
+        if (octetCount >= 4) {
+            return false;
+        }
+
+        if (*p < '0' || *p > '9') {
+            return false;
+        }
+
+        unsigned int value = 0;
+        int digits = 0;
+        while (*p >= '0' && *p <= '9') {
+            value = (value * 10u) + (unsigned int)(*p - '0');
+            if (value > 255u) {
+                return false;
+            }
+            ++digits;
+            if (digits > 3) {
+                return false;
+            }
+            ++p;
+        }
+
+        if (digits == 0) {
+            return false;
+        }
+
+        ++octetCount;
+        if (octetCount < 4) {
+            if (*p != '.') {
+                return false;
+            }
+            ++p;
+            if (*p == '\0') {
+                return false;
+            }
+        }
+    }
+
+    return octetCount == 4;
+}
+
+static inline void Uint256ToDecimal(const uint256_t* value, char* out, size_t outSize) {
+    if (!value || !out || outSize == 0) {
+        return;
+    }
+
+    uint64_t tmp[4] = {
+        value->limbs[0],
+        value->limbs[1],
+        value->limbs[2],
+        value->limbs[3]
+    };
+
+    if (tmp[0] == 0 && tmp[1] == 0 && tmp[2] == 0 && tmp[3] == 0) {
+        if (outSize >= 2) {
+            out[0] = '0';
+            out[1] = '\0';
+        } else {
+            out[0] = '\0';
+        }
+        return;
+    }
+
+    char digits[80];
+    size_t digitCount = 0;
+
+    while (tmp[0] != 0 || tmp[1] != 0 || tmp[2] != 0 || tmp[3] != 0) {
+        uint64_t remainder = 0;
+        for (int i = 3; i >= 0; --i) {
+            __uint128_t cur = ((__uint128_t)remainder << 64) | tmp[i];
+            tmp[i] = (uint64_t)(cur / 10u);
+            remainder = (uint64_t)(cur % 10u);
+        }
+
+        if (digitCount < sizeof(digits) - 1) {
+            digits[digitCount++] = (char)('0' + remainder);
+        } else {
+            break;
+        }
+    }
+
+    size_t writeLen = (digitCount < (outSize - 1)) ? digitCount : (outSize - 1);
+    for (size_t i = 0; i < writeLen; ++i) {
+        out[i] = digits[digitCount - 1 - i];
+    }
+    out[writeLen] = '\0';
+}
+
+#endif

src/autolykos2/autolykos2.c

@@ -4,6 +4,13 @@
 
 #include <stdlib.h>
 #include <string.h>
+#if defined(_WIN32) || defined(_WIN64)
+#include <windows.h>
+#else
+#include <unistd.h>
+#endif
+
+uint64_t autolykos2_sleepBetweenHashOperationsMicroseconds = 0;
 
 typedef struct {
     uint8_t* buf;
@@ -16,10 +23,10 @@ struct Autolykos2Context {
     void* backend;
 };
 
-#ifdef MINICOIN_AUTOLYKOS2_REF_AVAILABLE
+#ifdef SKALACOIN_AUTOLYKOS2_REF_AVAILABLE
-extern void* minicoin_autolykos2_ref_create(void);
+extern void* skalacoin_autolykos2_ref_create(void);
-extern void minicoin_autolykos2_ref_destroy(void* handle);
+extern void skalacoin_autolykos2_ref_destroy(void* handle);
-extern bool minicoin_autolykos2_ref_check_target(
+extern bool skalacoin_autolykos2_ref_check_target(
     void* handle,
     const uint8_t message32[32],
     uint64_t nonce,
@@ -29,32 +36,31 @@ extern bool minicoin_autolykos2_ref_check_target(
 #endif
 
 static bool Autolykos2_FallbackHash(
-    const Autolykos2Context* ctx,
+    const uint8_t seed32[32],
     const uint8_t* message,
     size_t messageLen,
     uint64_t nonce,
-    uint32_t height,
+    uint64_t height,
     uint8_t outHash[32]
 ) {
+    if (!seed32 || !outHash) {
+        return false;
+    }
+
     uint8_t nonceBytes[8];
-    uint8_t heightBytes[4];
+    uint8_t heightBytes[8];
     memcpy(nonceBytes, &nonce, sizeof(nonceBytes));
     memcpy(heightBytes, &height, sizeof(heightBytes));
 
-    size_t dagChunkLen = 0;
+    const size_t totalLen = 32 + messageLen + sizeof(nonceBytes) + sizeof(heightBytes);
-    const uint8_t* dagChunk = NULL;
-    if (ctx && ctx->dag.buf && ctx->dag.len > 0) {
-        dagChunk = ctx->dag.buf;
-        dagChunkLen = ctx->dag.len > 64 ? 64 : ctx->dag.len;
-    }
-
-    const size_t totalLen = messageLen + sizeof(nonceBytes) + sizeof(heightBytes) + dagChunkLen;
     uint8_t* material = (uint8_t*)malloc(totalLen == 0 ? 1 : totalLen);
     if (!material) {
         return false;
     }
 
     size_t off = 0;
+    memcpy(material + off, seed32, 32);
+    off += 32;
     if (messageLen > 0) {
         memcpy(material + off, message, messageLen);
         off += messageLen;
@@ -62,10 +68,6 @@ static bool Autolykos2_FallbackHash(
     memcpy(material + off, nonceBytes, sizeof(nonceBytes));
     off += sizeof(nonceBytes);
     memcpy(material + off, heightBytes, sizeof(heightBytes));
-    off += sizeof(heightBytes);
-    if (dagChunkLen > 0) {
-        memcpy(material + off, dagChunk, dagChunkLen);
-    }
 
     const bool ok = Blake2b_Hash(material, totalLen, outHash, 32);
     free(material);
@@ -80,14 +82,193 @@ static int Cmp256BE(const uint8_t a[32], const uint8_t b[32]) {
     return 0;
 }
 
+static void WriteU64LE(uint64_t v, uint8_t out[8]) {
+    out[0] = (uint8_t)(v & 0xffu);
+    out[1] = (uint8_t)((v >> 8) & 0xffu);
+    out[2] = (uint8_t)((v >> 16) & 0xffu);
+    out[3] = (uint8_t)((v >> 24) & 0xffu);
+    out[4] = (uint8_t)((v >> 32) & 0xffu);
+    out[5] = (uint8_t)((v >> 40) & 0xffu);
+    out[6] = (uint8_t)((v >> 48) & 0xffu);
+    out[7] = (uint8_t)((v >> 56) & 0xffu);
+}
+
+static void WriteU32LE(uint32_t v, uint8_t out[4]) {
+    out[0] = (uint8_t)(v & 0xffu);
+    out[1] = (uint8_t)((v >> 8) & 0xffu);
+    out[2] = (uint8_t)((v >> 16) & 0xffu);
+    out[3] = (uint8_t)((v >> 24) & 0xffu);
+}
+
+static bool DeriveSeedFromMessage(const uint8_t* message, size_t messageLen, uint8_t outSeed[32]) {
+    if (!message || !outSeed) {
+        return false;
+    }
+
+    return Blake2b_Hash(message, messageLen, outSeed, 32);
+}
+
+static bool ComputeLaneIndex(
+    const uint8_t seed32[32],
+    uint64_t nonce,
+    uint64_t height,
+    uint32_t round,
+    uint32_t laneCount,
+    uint32_t* outLane
+) {
+    if (!seed32 || !outLane || laneCount == 0) {
+        return false;
+    }
+
+    uint8_t input[32 + 8 + 8 + 4];
+    uint8_t digest[32];
+    uint8_t nonceBytes[8];
+    uint8_t heightBytes[8];
+    uint8_t roundBytes[4];
+
+    WriteU64LE(nonce, nonceBytes);
+    WriteU64LE(height, heightBytes);
+    WriteU32LE(round, roundBytes);
+
+    memcpy(input, seed32, 32);
+    memcpy(input + 32, nonceBytes, sizeof(nonceBytes));
+    memcpy(input + 40, heightBytes, sizeof(heightBytes));
+    memcpy(input + 48, roundBytes, sizeof(roundBytes));
+
+    if (!Blake2b_Hash(input, sizeof(input), digest, sizeof(digest))) {
+        return false;
+    }
+
+    uint32_t raw =
+        ((uint32_t)digest[0]) |
+        ((uint32_t)digest[1] << 8) |
+        ((uint32_t)digest[2] << 16) |
+        ((uint32_t)digest[3] << 24);
+    *outLane = raw % laneCount;
+    return true;
+}
+
+static bool ReadDagLaneFromContext(const Autolykos2Context* ctx, uint32_t laneIndex, uint8_t outLane[32]) {
+    if (!ctx || !ctx->dag.buf || !outLane) {
+        return false;
+    }
+
+    const size_t offset = (size_t)laneIndex * 32u;
+    if (ctx->dag.len < offset + 32u) {
+        return false;
+    }
+
+    memcpy(outLane, ctx->dag.buf + offset, 32);
+    return true;
+}
+
+static bool ReadDagLaneFromSeed(const uint8_t seed32[32], uint32_t laneIndex, uint8_t outLane[32]) {
+    if (!seed32 || !outLane) {
+        return false;
+    }
+
+    const uint64_t counter = (uint64_t)laneIndex / 2u;
+    const bool upperHalf = (laneIndex & 1u) != 0u;
+    uint8_t input[32 + 8];
+    uint8_t digest[64];
+    uint8_t counterBytes[8];
+
+    WriteU64LE(counter, counterBytes);
+    memcpy(input, seed32, 32);
+    memcpy(input + 32, counterBytes, sizeof(counterBytes));
+
+    if (!Blake2b_Hash(input, sizeof(input), digest, sizeof(digest))) {
+        return false;
+    }
+
+    memcpy(outLane, digest + (upperHalf ? 32 : 0), 32);
+    return true;
+}
+
+static bool Autolykos2_HashCore(
+    const uint8_t messageSeed32[32],
+    const uint8_t dagSeed32[32],
+    const uint8_t* message,
+    size_t messageLen,
+    uint64_t nonce,
+    uint64_t height,
+    uint32_t laneCount,
+    const Autolykos2Context* ctx,
+    bool useContextDag,
+    uint8_t outHash[32]
+) {
+    if (!messageSeed32 || !message || !outHash || laneCount == 0) {
+        return false;
+    }
+
+    uint8_t acc[32];
+    memset(acc, 0, sizeof(acc));
+
+    for (uint32_t round = 0; round < 32; ++round) {
+        uint32_t laneIndex = 0;
+        uint8_t lane[32];
+
+        if (!ComputeLaneIndex(messageSeed32, nonce, height, round, laneCount, &laneIndex)) {
+            return false;
+        }
+
+        if (useContextDag) {
+            if (!ReadDagLaneFromContext(ctx, laneIndex, lane)) {
+                return false;
+            }
+        } else {
+            if (!ReadDagLaneFromSeed(dagSeed32 ? dagSeed32 : messageSeed32, laneIndex, lane)) {
+                return false;
+            }
+        }
+
+        for (size_t i = 0; i < 32; ++i) {
+            acc[i] ^= lane[i];
+        }
+    }
+
+    uint8_t baseHash[32];
+    uint8_t accHash[32];
+    if (!Autolykos2_FallbackHash(messageSeed32, message, messageLen, nonce, height, baseHash)) {
+        return false;
+    }
+    if (!Blake2b_Hash(acc, sizeof(acc), accHash, sizeof(accHash))) {
+        return false;
+    }
+
+    uint8_t finalInput[32 + 32 + 8 + 8];
+    uint8_t nonceBytes[8];
+    uint8_t heightBytes[8];
+    WriteU64LE(nonce, nonceBytes);
+    WriteU64LE(height, heightBytes);
+
+    memcpy(finalInput, baseHash, 32);
+    memcpy(finalInput + 32, accHash, 32);
+    memcpy(finalInput + 64, nonceBytes, 8);
+    memcpy(finalInput + 72, heightBytes, 8);
+    bool ok = Blake2b_Hash(finalInput, sizeof(finalInput), outHash, 32);
+
+    // Throttle between hash operations if configured (applies to all hash paths).
+    if (autolykos2_sleepBetweenHashOperationsMicroseconds > 0) {
+#if defined(_WIN32) || defined(_WIN64)
+        DWORD ms = (DWORD)((autolykos2_sleepBetweenHashOperationsMicroseconds + 999) / 1000);
+        Sleep(ms);
+#else
+        sleep_for_microseconds(autolykos2_sleepBetweenHashOperationsMicroseconds);
+#endif
+    }
+
+    return ok;
+}
+
 Autolykos2Context* Autolykos2_Create(void) {
     Autolykos2Context* ctx = (Autolykos2Context*)calloc(1, sizeof(Autolykos2Context));
     if (!ctx) {
         return NULL;
     }
 
-#ifdef MINICOIN_AUTOLYKOS2_REF_AVAILABLE
+#ifdef SKALACOIN_AUTOLYKOS2_REF_AVAILABLE
-    ctx->backend = minicoin_autolykos2_ref_create();
+    ctx->backend = skalacoin_autolykos2_ref_create();
 #endif
 
     return ctx;
@@ -98,9 +279,9 @@ void Autolykos2_Destroy(Autolykos2Context* ctx) {
         return;
     }
 
-#ifdef MINICOIN_AUTOLYKOS2_REF_AVAILABLE
+#ifdef SKALACOIN_AUTOLYKOS2_REF_AVAILABLE
     if (ctx->backend) {
-        minicoin_autolykos2_ref_destroy(ctx->backend);
+        skalacoin_autolykos2_ref_destroy(ctx->backend);
         ctx->backend = NULL;
     }
 #endif
@@ -144,6 +325,38 @@ bool Autolykos2_DagAppend(Autolykos2Context* ctx, const uint8_t* data, size_t le
     return true;
 }
 
+bool Autolykos2_DagGenerate(Autolykos2Context* ctx, const uint8_t seed32[32]) {
+    if (!ctx || !seed32 || !ctx->dag.buf || ctx->dag.cap == 0) {
+        return false;
+    }
+
+    uint8_t input[32 + 8];
+    uint8_t digest[64];
+    size_t offset = 0;
+    uint64_t counter = 0;
+
+    while (offset < ctx->dag.cap) {
+        WriteU64LE(counter, input + 32);
+        memcpy(input, seed32, 32);
+
+        if (!Blake2b_Hash(input, sizeof(input), digest, sizeof(digest))) {
+            return false;
+        }
+
+        size_t chunk = ctx->dag.cap - offset;
+        if (chunk > sizeof(digest)) {
+            chunk = sizeof(digest);
+        }
+
+        memcpy(ctx->dag.buf + offset, digest, chunk);
+        offset += chunk;
+        ++counter;
+    }
+
+    ctx->dag.len = ctx->dag.cap;
+    return true;
+}
+
 void Autolykos2_DagClear(Autolykos2Context* ctx) {
     if (!ctx || !ctx->dag.buf) {
         return;
@@ -161,21 +374,114 @@ bool Autolykos2_Hash(
     const uint8_t* message,
     size_t messageLen,
     uint64_t nonce,
-    uint32_t height,
+    uint64_t height,
     uint8_t outHash[32]
 ) {
     if (!ctx || !message || !outHash) {
         return false;
     }
 
-    return Autolykos2_FallbackHash(ctx, message, messageLen, nonce, height, outHash);
+    if (!ctx->dag.buf || ctx->dag.len < 32 || (ctx->dag.len % 32) != 0) {
+        return false;
+    }
+
+    uint8_t seed32[32];
+    if (!DeriveSeedFromMessage(message, messageLen, seed32)) {
+        return false;
+    }
+
+    const size_t laneCount64 = ctx->dag.len / 32u;
+    if (laneCount64 == 0 || laneCount64 > UINT32_MAX) {
+        return false;
+    }
+
+    return Autolykos2_HashCore(
+        seed32,
+        NULL,
+        message,
+        messageLen,
+        nonce,
+        height,
+        (uint32_t)laneCount64,
+        ctx,
+        true,
+        outHash
+    );
+}
+
+bool Autolykos2_LightHash(const uint8_t* seed, blockchain_t* chain, uint64_t nonce, uint8_t* out) {
+    if (!seed || !chain || !out) {
+        return false;
+    }
+
+    const uint64_t height = (uint64_t)Chain_Size(chain);
+    const size_t dagBytes = CalculateTargetDAGSize(chain);
+    if (dagBytes < 32 || (dagBytes % 32) != 0) {
+        return false;
+    }
+
+    const size_t laneCount64 = dagBytes / 32u;
+    if (laneCount64 == 0 || laneCount64 > UINT32_MAX) {
+        return false;
+    }
+
+    // Light path derives the needed DAG lanes from seed on-demand, no large DAG allocation required.
+    return Autolykos2_HashCore(
+        seed,
+        seed,
+        seed,
+        32,
+        nonce,
+        height,
+        (uint32_t)laneCount64,
+        NULL,
+        false,
+        out
+    );
+}
+
+bool Autolykos2_LightHashAtHeight(
+    const uint8_t seed32[32],
+    const uint8_t* message,
+    size_t messageLen,
+    uint64_t nonce,
+    uint64_t height,
+    size_t dagBytes,
+    uint8_t out[32]
+) {
+    if (!seed32 || !message || !out || dagBytes < 32 || (dagBytes % 32) != 0) {
+        return false;
+    }
+
+    const size_t laneCount64 = dagBytes / 32u;
+    if (laneCount64 == 0 || laneCount64 > UINT32_MAX) {
+        return false;
+    }
+
+    uint8_t messageSeed32[32];
+    if (!DeriveSeedFromMessage(message, messageLen, messageSeed32)) {
+        return false;
+    }
+
+    return Autolykos2_HashCore(
+        messageSeed32,
+        seed32,
+        message,
+        messageLen,
+        nonce,
+        height,
+        (uint32_t)laneCount64,
+        NULL,
+        false,
+        out
+    );
 }
 
 bool Autolykos2_CheckTarget(
     Autolykos2Context* ctx,
     const uint8_t message32[32],
     uint64_t nonce,
-    uint32_t height,
+    uint64_t height,
     const uint8_t target32[32],
     uint8_t outHash[32]
 ) {
@@ -183,17 +489,17 @@ bool Autolykos2_CheckTarget(
         return false;
     }
 
-#ifdef MINICOIN_AUTOLYKOS2_REF_AVAILABLE
+#ifdef SKALACOIN_AUTOLYKOS2_REF_AVAILABLE
     if (ctx->backend) {
-        const bool ok = minicoin_autolykos2_ref_check_target(ctx->backend, message32, nonce, height, target32);
+        const bool ok = skalacoin_autolykos2_ref_check_target(ctx->backend, message32, nonce, height, target32);
-        if (Autolykos2_FallbackHash(ctx, message32, 32, nonce, height, outHash)) {
+        if (Autolykos2_Hash(ctx, message32, 32, nonce, height, outHash)) {
             return ok;
         }
         return false;
     }
 #endif
 
-    if (!Autolykos2_FallbackHash(ctx, message32, 32, nonce, height, outHash)) {
+    if (!Autolykos2_Hash(ctx, message32, 32, nonce, height, outHash)) {
         return false;
     }
     return Cmp256BE(outHash, target32) <= 0;
@@ -202,7 +508,7 @@ bool Autolykos2_CheckTarget(
 bool Autolykos2_FindNonceSingleCore(
     Autolykos2Context* ctx,
     const uint8_t message32[32],
-    uint32_t height,
+    uint64_t height,
     const uint8_t target32[32],
     uint64_t startNonce,
     uint64_t maxIterations,
@@ -223,3 +529,7 @@ bool Autolykos2_FindNonceSingleCore(
 
     return false;
 }
+
+void Autolykos2_SetSleepBetweenHashOperations(uint64_t sleepMicroseconds) {
+    autolykos2_sleepBetweenHashOperationsMicroseconds = sleepMicroseconds;
+}

src/autolykos2/autolykos2_ref_wrapper.cpp

@@ -28,27 +28,27 @@ uint32_t calcN(uint32_t Hblock) {
     return newN;
 }
 
-struct minicoin_autolykos2_ref_handle {
+struct skalacoin_autolykos2_ref_handle {
     AutolykosAlg* alg;
 };
 
-extern "C" void* minicoin_autolykos2_ref_create(void) {
+extern "C" void* skalacoin_autolykos2_ref_create(void) {
-    minicoin_autolykos2_ref_handle* h = new minicoin_autolykos2_ref_handle();
+    skalacoin_autolykos2_ref_handle* h = new skalacoin_autolykos2_ref_handle();
     h->alg = new AutolykosAlg();
     return h;
 }
 
-extern "C" void minicoin_autolykos2_ref_destroy(void* handle) {
+extern "C" void skalacoin_autolykos2_ref_destroy(void* handle) {
     if (!handle) {
         return;
     }
 
-    auto* h = static_cast<minicoin_autolykos2_ref_handle*>(handle);
+    auto* h = static_cast<skalacoin_autolykos2_ref_handle*>(handle);
     delete h->alg;
     delete h;
 }
 
-extern "C" bool minicoin_autolykos2_ref_check_target(
+extern "C" bool skalacoin_autolykos2_ref_check_target(
     void* handle,
     const uint8_t message32[32],
     uint64_t nonce,
@@ -59,7 +59,7 @@ extern "C" bool minicoin_autolykos2_ref_check_target(
         return false;
     }
 
-    auto* h = static_cast<minicoin_autolykos2_ref_handle*>(handle);
+    auto* h = static_cast<skalacoin_autolykos2_ref_handle*>(handle);
     if (!h->alg) {
         return false;
     }

src/balance_sheet.c

@@ -0,0 +1,340 @@
+#include <balance_sheet.h>
+#include <pthread.h>
+
+khash_t(balance_sheet_map_m)* sheetMap = NULL;
+static pthread_mutex_t g_sheetLock;
+
+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;
+}
+
+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;
+    }
+
+    key32_t key;
+    memcpy(key.bytes, entry.address, 32);
+
+    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);
+
+    khiter_t k = kh_get(balance_sheet_map_m, sheetMap, key);
+    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) {
+        pthread_mutex_unlock(&g_sheetLock);
+        return false;
+    }
+
+    khiter_t k;
+    for (k = kh_begin(sheetMap); k != kh_end(sheetMap); ++k) {
+        if (kh_exist(sheetMap, k)) {
+            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) {
+        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_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) {
+        if (kh_exist(sheetMap, k)) {
+            key32_t key = kh_key(sheetMap, k);
+            balance_sheet_entry_t val = kh_val(sheetMap, k);
+
+            char balanceStr[80];
+            uint256_serialize(&val.balance, balanceStr);
+
+            char addrHex[65];
+            AddressToHexString(key.bytes, addrHex);
+
+            // Print full address
+            printf("Address %s: balance=%s pebble(s)\n",
+                addrHex,
+                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/blake2/blake2.c

@@ -1,4 +1,4 @@
-#include "../../include/blake2/blake2.h"
+#include <blake2/blake2.h>
 
 #include <openssl/evp.h>
 #include <string.h>
@@ -42,9 +42,9 @@ static bool Blake2_HashInternal(
 }
 
 bool Blake2b_Hash(const uint8_t* input, size_t inputLen, uint8_t* out, size_t outLen) {
-    return Blake2_HashInternal(EVP_blake2b512(), MINICOIN_BLAKE2B_OUTBYTES, input, inputLen, out, outLen);
+    return Blake2_HashInternal(EVP_blake2b512(), SKALACOIN_BLAKE2B_OUTBYTES, input, inputLen, out, outLen);
 }
 
 bool Blake2s_Hash(const uint8_t* input, size_t inputLen, uint8_t* out, size_t outLen) {
-    return Blake2_HashInternal(EVP_blake2s256(), MINICOIN_BLAKE2S_OUTBYTES, input, inputLen, out, outLen);
+    return Blake2_HashInternal(EVP_blake2s256(), SKALACOIN_BLAKE2S_OUTBYTES, input, inputLen, out, outLen);
 }

src/block/block.c

@@ -1,5 +1,6 @@
 #include <block/block.h>
 #include <autolykos2/autolykos2.h>
+#include <utils.h>
 #include <stdlib.h>
 
 static Autolykos2Context* g_autolykos2Ctx = NULL;
@@ -7,6 +8,11 @@ static Autolykos2Context* g_autolykos2Ctx = NULL;
 static Autolykos2Context* GetAutolykos2Ctx(void) {
     if (!g_autolykos2Ctx) {
         g_autolykos2Ctx = Autolykos2_Create();
+        if (!g_autolykos2Ctx) {
+            fprintf(stderr, "Failed to create Autolykos2 context\n");
+            exit(1);
+        }
+        Autolykos2_DagAllocate(g_autolykos2Ctx, DAG_BASE_SIZE);
     }
     return g_autolykos2Ctx;
 }
@@ -18,6 +24,24 @@ void Block_ShutdownPowContext(void) {
     }
 }
 
+bool Block_RebuildAutolykos2Dag(size_t dagBytes, const uint8_t seed32[32]) {
+    if (!seed32 || dagBytes == 0) {
+        return false;
+    }
+
+    Autolykos2Context* ctx = GetAutolykos2Ctx();
+    if (!ctx) {
+        return false;
+    }
+
+    Autolykos2_DagClear(ctx);
+    if (!Autolykos2_DagAllocate(ctx, dagBytes)) {
+        return false;
+    }
+
+    return Autolykos2_DagGenerate(ctx, seed32);
+}
+
 block_t* Block_Create() {
     block_t* block = (block_t*)malloc(sizeof(block_t));
     if (!block) {
@@ -29,6 +53,10 @@ block_t* Block_Create() {
         free(block);
         return NULL;
     }
+    
+    // Zero out padding
+    memset(block->header.reserved, 0, sizeof(block->header.reserved));
+
     return block;
 }
 
@@ -58,79 +86,51 @@ void Block_CalculateMerkleRoot(const block_t* block, uint8_t* outHash) {
         return;
     }
 
-    // TODO: Make this not shit
+    uint8_t* current = (uint8_t*)malloc(txCount * 32u);
-    DynArr* hashes1 = DynArr_create(sizeof(uint8_t) * 32, 1);
+    uint8_t* next = (uint8_t*)malloc(txCount * 32u);
-    DynArr* hashes2 = DynArr_create(sizeof(uint8_t) * 32, 1);
+    if (!current || !next) {
-    if (!hashes1 || !hashes2) {
+        free(current);
-        if (hashes1) DynArr_destroy(hashes1);
+        free(next);
-        if (hashes2) DynArr_destroy(hashes2);
+        memset(outHash, 0, 32);
         return;
     }
 
-    // Handle the transactions
+    for (size_t i = 0; i < txCount; ++i) {
-    for (size_t i = 0; i < txCount - 1; i++) {
         signed_transaction_t* tx = (signed_transaction_t*)DynArr_at(block->transactions, i);
-        signed_transaction_t* txNext = (signed_transaction_t*)DynArr_at(block->transactions, i + 1);
+        if (!tx) {
-        uint8_t buf1[32] = {0}; uint8_t buf2[32] = {0}; // Zeroed out
+            free(current);
-
+            free(next);
-        // Unless if by some miracle the hash just so happens to be all zeros,
-        // I think we can safely assume that a 1 : 2^256 chance will NEVER be hit
-        Transaction_CalculateHash(tx, buf1);
-        Transaction_CalculateHash(txNext, buf2);
-
-        // Concat the two hashes
-        uint8_t dataInBuffer[64] = {0};
-        uint8_t* nextStart = dataInBuffer;
-        nextStart += 32;
-        memcpy(dataInBuffer, buf1, 32);
-        if (txNext) { memcpy(nextStart, buf2, 32); }
-
-        // Double hash that tx set
-        uint8_t outHash[32];
-        SHA256((const unsigned char*)dataInBuffer, 64, outHash);
-        SHA256(outHash, 32, outHash);
-
-        // Copy to the hashes dynarr
-        DynArr_push_back(hashes1, outHash);
-    }
-
-    // Move to hashing the existing ones until only one remains
-    do {
-        for (size_t i = 0; i < DynArr_size(hashes1) - 1; i++) {
-            uint8_t* hash1 = (uint8_t*)DynArr_at(hashes1, i); uint8_t* hash2 = (uint8_t*)DynArr_at(hashes1, i + 1);
-
-            // Concat the two hashes
-            uint8_t dataInBuffer[64] = {0};
-            uint8_t* nextStart = dataInBuffer;
-            nextStart += 32;
-            memcpy(dataInBuffer, hash1, 32);
-            memcpy(nextStart, hash2, 32);
-
-            // Double hash that tx set
-            uint8_t outHash[32];
-            SHA256((const unsigned char*)dataInBuffer, 64, outHash);
-            SHA256(outHash, 32, outHash);
-
-            DynArr_push_back(hashes2, outHash);
-        }
-
-        DynArr_erase(hashes1);
-        for (size_t i = 0; i < DynArr_size(hashes2); i++) {
-            DynArr_push_back(hashes1, (uint8_t*)DynArr_at(hashes2, i));
-        }
-        DynArr_erase(hashes2);
-    } while (DynArr_size(hashes1) > 1);
-
-    // Final Merkle
-    uint8_t* merkle = (uint8_t*)DynArr_at(hashes1, 0);
-    if (merkle) {
-        memcpy(outHash, merkle, 32);
-    } else {
             memset(outHash, 0, 32);
+            return;
+        }
+        Transaction_CalculateHash(tx, current + (i * 32u));
     }
 
-    DynArr_destroy(hashes1);
+    size_t levelCount = txCount;
-    DynArr_destroy(hashes2);
+    while (levelCount > 1) {
+        size_t nextCount = 0;
+        for (size_t i = 0; i < levelCount; i += 2) {
+            const uint8_t* left = current + (i * 32u);
+            const uint8_t* right = (i + 1 < levelCount) ? current + ((i + 1) * 32u) : left;
+
+            uint8_t dataInBuffer[64];
+            memcpy(dataInBuffer, left, 32);
+            memcpy(dataInBuffer + 32, right, 32);
+
+            SHA256((const unsigned char*)dataInBuffer, 64, next + (nextCount * 32u));
+            SHA256(next + (nextCount * 32u), 32, next + (nextCount * 32u));
+            ++nextCount;
+        }
+
+        uint8_t* swap = current;
+        current = next;
+        next = swap;
+        levelCount = nextCount;
+    }
+
+    memcpy(outHash, current, 32);
+    free(current);
+    free(next);
 }
 
 void Block_CalculateAutolykos2Hash(const block_t* block, uint8_t* outHash) {
@@ -172,7 +172,9 @@ void Block_RemoveTransaction(block_t* block, uint8_t* txHash) {
 
     for (size_t i = 0; i < DynArr_size(block->transactions); i++) {
         signed_transaction_t* currentTx = (signed_transaction_t*)DynArr_at(block->transactions, i);
-        if (memcmp(currentTx->signature.txHash, txHash, 32) == 0) {
+        uint8_t currentTxHash[32];
+        Transaction_CalculateHash(currentTx, currentTxHash);
+        if (memcmp(currentTxHash, txHash, 32) == 0) {
             DynArr_remove(block->transactions, i);
             return;
         }
@@ -187,39 +189,6 @@ static int Uint256_CompareBE(const uint8_t a[32], const uint8_t b[32]) {
     return 0;
 }
 
-static bool DecodeCompactTarget(uint32_t nBits, uint8_t target[32]) {
-    memset(target, 0, 32);
-
-    uint32_t exponent = nBits >> 24;
-    uint32_t mantissa = nBits & 0x007fffff;  // ignore sign bit for now
-    bool negative = (nBits & 0x00800000) != 0;
-
-    if (negative || mantissa == 0) {
-        return false;
-    }
-
-    // Compute: target = mantissa * 256^(exponent - 3)
-    if (exponent <= 3) {
-        mantissa >>= 8 * (3 - exponent);
-
-        target[29] = (mantissa >> 16) & 0xff;
-        target[30] = (mantissa >> 8) & 0xff;
-        target[31] = mantissa & 0xff;
-    } else {
-        uint32_t byte_index = exponent - 3;  // number of zero-bytes appended on right
-
-        if (byte_index > 29) {
-            return false; // overflow 256 bits
-        }
-
-        target[32 - byte_index - 3] = (mantissa >> 16) & 0xff;
-        target[32 - byte_index - 2] = (mantissa >> 8) & 0xff;
-        target[32 - byte_index - 1] = mantissa & 0xff;
-    }
-
-    return true;
-}
-
 bool Block_HasValidProofOfWork(const block_t* block) {
     if (!block) {
         return false;
@@ -245,21 +214,97 @@ 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.
+        }
+    }
+
+    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;
     }
 
-    return true && hasCoinbase && DynArr_size(block->transactions) > 0; // Every block must have at least one transaction (the coinbase)
+    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) {
@@ -271,9 +316,9 @@ void Block_Destroy(block_t* block) {
 void Block_Print(const block_t* block) {
     if (!block) return;
 
-    printf("Block #%llu\n", block->header.blockNumber);
+    printf("Block #%llu\n", (unsigned long long)block->header.blockNumber);
-    printf("Timestamp: %llu\n", block->header.timestamp);
+    printf("Timestamp: %llu\n", (unsigned long long)block->header.timestamp);
-    printf("Nonce: %llu\n", block->header.nonce);
+    printf("Nonce: %llu\n", (unsigned long long)block->header.nonce);
     printf("Difficulty Target: 0x%08x\n", block->header.difficultyTarget);
     printf("Version: %u\n", block->header.version);
     printf("Previous Hash: ");
@@ -292,10 +337,61 @@ void Block_Print(const block_t* block) {
             signed_transaction_t* tx = (signed_transaction_t*)DynArr_at(block->transactions, i);
             if (tx) {
                 printf("  Tx #%zu: 1: %llu -> %02x%02x...%02x%02x, fee %llu\n           2: %llu -> %02x%02x...%02x%02x, fee %llu\n", 
-                    i, tx->transaction.amount1, tx->transaction.recipientAddress1[0], tx->transaction.recipientAddress1[1], tx->transaction.recipientAddress1[30], tx->transaction.recipientAddress1[31], tx->transaction.fee, tx->transaction.amount2, tx->transaction.recipientAddress2[0], tx->transaction.recipientAddress2[1], tx->transaction.recipientAddress2[30], tx->transaction.recipientAddress2[31], tx->transaction.fee);
+                    i,
+                    (unsigned long long)tx->transaction.amount1,
+                    tx->transaction.recipientAddress1[0], tx->transaction.recipientAddress1[1], tx->transaction.recipientAddress1[30], tx->transaction.recipientAddress1[31],
+                    (unsigned long long)tx->transaction.fee,
+                    (unsigned long long)tx->transaction.amount2,
+                    tx->transaction.recipientAddress2[0], tx->transaction.recipientAddress2[1], tx->transaction.recipientAddress2[30], tx->transaction.recipientAddress2[31],
+                    (unsigned long long)tx->transaction.fee);
             }
         }
     } else {
         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/transaction.c

@@ -1,6 +1,14 @@
 #include <block/transaction.h>
 #include <string.h>
 
+void Transaction_Init(signed_transaction_t* tx) {
+    if (!tx) { return; }
+    // Zero out everything
+    memset(tx, 0, sizeof(signed_transaction_t));
+
+    // NOTE: Other things might be added here
+}
+
 void Transaction_CalculateHash(const signed_transaction_t* tx, uint8_t* outHash) {
     if (!tx || !outHash) {
         return;
@@ -18,10 +26,11 @@ void Transaction_Sign(signed_transaction_t* tx, const uint8_t* privateKey) {
         return;
     }
 
-    Transaction_CalculateHash(tx, tx->signature.txHash);
+    uint8_t txHash[32];
+    Transaction_CalculateHash(tx, txHash);
     Crypto_SignData(
-        (const uint8_t*)&tx->transaction,
+        txHash,
-        sizeof(transaction_t),
+        32,
         privateKey,
         tx->signature.signature
     );
@@ -33,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;
     }
 
@@ -59,6 +84,9 @@ bool Transaction_Verify(const signed_transaction_t* tx) {
         return false; // Cannot send to coinbase address
     }
 
+    // Balance checks are stateful and are handled when a block is added to the chain.
+    // Transaction_Verify only checks transaction structure, addresses, and signature material.
+
     if (tx->transaction.amount2 == 0) {
         // If amount2 is zero, address2 must be all zeros
         uint8_t zeroAddress[32] = {0};
@@ -70,14 +98,10 @@ bool Transaction_Verify(const signed_transaction_t* tx) {
     uint8_t txHash[32];
     Transaction_CalculateHash(tx, txHash);
 
-    if (memcmp(txHash, tx->signature.txHash, 32) != 0) {
-        return false; // Hash does not match signature hash
-    }
-
     // If all checks pass, verify the signature
     return Crypto_VerifySignature(
-        (const uint8_t*)&tx->transaction,
+        txHash,
-        sizeof(transaction_t),
+        32,
         tx->signature.signature,
         tx->transaction.compressedPublicKey
     );

src/crypto/crypto.c

@@ -75,3 +75,13 @@ void Crypto_SignData(const uint8_t* data, size_t len, const uint8_t* privateKey,
     secp256k1_ecdsa_signature_serialize_compact(ctx, outSignature, &sig);
     secp256k1_context_destroy(ctx);
 }
+
+void to_hex(const uint8_t *in, char *out) {
+    static const char hex[] = "0123456789abcdef";
+
+    for (int i = 0; i < 32; i++) {
+        out[i * 2]     = hex[in[i] >> 4];
+        out[i * 2 + 1] = hex[in[i] & 0x0F];
+    }
+    out[64] = '\0';
+}

src/dynarr.c

@@ -173,3 +173,7 @@ void DynArr_destroy(DynArr* p) {
     free(p->data);
     free(p);
 }
+
+void* DynArr_c_arr(DynArr* p) {
+    return p->data;
+}

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/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

@@ -0,0 +1,221 @@
+#ifndef _WIN32
+
+#include <tcpd/tcpclient.h>
+
+#include <errno.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;
+    if (!client || !client->connection) {
+        return NULL;
+    }
+
+    tcp_connection_t* conn = client->connection;
+    unsigned char ioBuf[TCP_IO_BUFFER_SIZE];
+
+    while (1) {
+        ssize_t n = recv(conn->sockFd, ioBuf, sizeof(ioBuf), 0);
+        if (n == 0) {
+            break;
+        }
+        if (n < 0) {
+            if (errno == EINTR) {
+                continue;
+            }
+            break;
+        }
+
+        if (TcpConnection_FeedFramedData(conn, ioBuf, (size_t)n) != 0) {
+            break;
+        }
+    }
+
+    if (!TcpConnection_IsDisconnectNotified(conn) && conn->on_disconnect) {
+        TcpConnection_MarkDisconnectNotified(conn);
+        conn->on_disconnect(conn);
+    }
+
+    return NULL;
+}
+
+int TcpClient_Init(tcp_client_t* client) {
+    if (!client) {
+        return -1;
+    }
+
+    memset(client, 0, sizeof(*client));
+    client->connection = NULL;
+    client->peerBlockHeight = 0;
+    return 0;
+}
+
+void TcpClient_Destroy(tcp_client_t* client) {
+    if (!client) {
+        return;
+    }
+
+    TcpClient_Disconnect(client);
+}
+
+int TcpClient_Connect(
+    tcp_client_t* client,
+    const char* peerIp,
+    unsigned short peerPort,
+    void (*on_connect)(tcp_connection_t* conn),
+    void (*on_data)(tcp_connection_t* conn),
+    void (*on_disconnect)(tcp_connection_t* conn),
+    void* owner
+) {
+    if (!client || !peerIp) {
+        return -1;
+    }
+
+    if (client->connection) {
+        return -1;
+    }
+
+    int sockFd = socket(AF_INET, 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);
+
+    if (inet_pton(AF_INET, peerIp, &peerAddr.sin_addr) <= 0) {
+        close(sockFd);
+        return -1;
+    }
+
+    // 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);
+
+    int rc = connect(sockFd, (struct sockaddr*)&peerAddr, sizeof(peerAddr));
+    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;
+        }
+    }
+
+    // Restore blocking mode
+    fcntl(sockFd, F_SETFL, flags & ~O_NONBLOCK);
+
+    tcp_connection_t* conn = (tcp_connection_t*)malloc(sizeof(*conn));
+    if (!conn) {
+        close(sockFd);
+        return -1;
+    }
+
+    if (TcpConnection_Init(conn, sockFd, &peerAddr, TCP_CONNECTION_ROLE_OUTBOUND) != 0) {
+        free(conn);
+        close(sockFd);
+        return -1;
+    }
+
+    conn->connectionId = random_four_byte();
+    conn->on_data = on_data;
+    conn->on_disconnect = on_disconnect;
+    conn->owner = owner;
+
+    client->connection = conn;
+    client->on_connect = on_connect;
+    client->on_data = on_data;
+    client->on_disconnect = on_disconnect;
+    client->owner = owner;
+
+    if (client->on_connect) {
+        client->on_connect(conn);
+    }
+
+    pthread_attr_t attr;
+    pthread_attr_init(&attr);
+    pthread_attr_setstacksize(&attr, TCP_THREAD_STACK_SIZE);
+
+    if (pthread_create(&conn->ioThread, &attr, TcpClient_ThreadProc, client) != 0) {
+        TcpConnection_Destroy(conn);
+        free(conn);
+        client->connection = NULL;
+        pthread_attr_destroy(&attr);
+        return -1;
+    }
+    pthread_attr_destroy(&attr);
+
+    return 0;
+}
+
+int TcpClient_Send(tcp_client_t* client, const void* data, size_t len) {
+    if (!client || !client->connection) {
+        return -1;
+    }
+
+    return TcpConnection_SendFramed(client->connection, data, len);
+}
+
+void TcpClient_Disconnect(tcp_client_t* client) {
+    if (!client || !client->connection) {
+        return;
+    }
+
+    tcp_connection_t* conn = client->connection;
+
+    TcpConnection_RequestClose(conn);
+
+    if (!pthread_equal(conn->ioThread, pthread_self())) {
+        pthread_join(conn->ioThread, NULL);
+    }
+
+    if (!TcpConnection_IsDisconnectNotified(conn) && conn->on_disconnect) {
+        TcpConnection_MarkDisconnectNotified(conn);
+        conn->on_disconnect(conn);
+    }
+
+    TcpConnection_Destroy(conn);
+    free(conn);
+
+    client->connection = NULL;
+}
+
+#endif

src/tcpd/tcpconnection.c

@@ -0,0 +1,285 @@
+#ifndef _WIN32
+
+#include <tcpd/tcpconnection.h>
+
+#include <arpa/inet.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#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) {
+    if (!conn || sockFd < 0 || !peerAddr) {
+        return -1;
+    }
+
+    memset(conn, 0, sizeof(*conn));
+    conn->sockFd = sockFd;
+    conn->peerAddr = *peerAddr;
+    conn->role = role;
+
+    if (pthread_mutex_init(&conn->sendLock, NULL) != 0) {
+        return -1;
+    }
+
+    if (pthread_mutex_init(&conn->stateLock, NULL) != 0) {
+        pthread_mutex_destroy(&conn->sendLock);
+        return -1;
+    }
+
+    conn->closing = false;
+    conn->disconnectedNotified = false;
+    conn->dataBuf = NULL;
+    conn->dataBufLen = 0;
+    conn->dataBufCap = 0;
+
+    TcpConnection_ResetFramingState(conn);
+
+    return 0;
+}
+
+void TcpConnection_Destroy(tcp_connection_t* conn) {
+    if (!conn) {
+        return;
+    }
+
+    if (conn->sockFd >= 0) {
+        close(conn->sockFd);
+        conn->sockFd = -1;
+    }
+
+    free(conn->dataBuf);
+    conn->dataBuf = NULL;
+    conn->dataBufLen = 0;
+    conn->dataBufCap = 0;
+
+    free(conn->frameBuf);
+    conn->frameBuf = NULL;
+    conn->frameBytesRead = 0;
+
+    pthread_mutex_destroy(&conn->stateLock);
+    pthread_mutex_destroy(&conn->sendLock);
+}
+
+int TcpConnection_SetDataBuffer(tcp_connection_t* conn, const unsigned char* data, size_t len) {
+    if (!conn || (!data && len > 0)) {
+        return -1;
+    }
+
+    if (len > conn->dataBufCap) {
+        unsigned char* resized = (unsigned char*)realloc(conn->dataBuf, len);
+        if (!resized) {
+            return -1;
+        }
+
+        conn->dataBuf = resized;
+        conn->dataBufCap = len;
+    }
+
+    if (len > 0) {
+        memcpy(conn->dataBuf, data, len);
+    }
+    conn->dataBufLen = len;
+
+    return 0;
+}
+
+void TcpConnection_ResetFramingState(tcp_connection_t* conn) {
+    if (!conn) {
+        return;
+    }
+
+    memset(conn->headerBuf, 0, sizeof(conn->headerBuf));
+    conn->headerBytesRead = 0;
+    conn->expectedPayloadLen = 0;
+    conn->frameBytesRead = 0;
+
+    free(conn->frameBuf);
+    conn->frameBuf = NULL;
+}
+
+int TcpConnection_FeedFramedData(tcp_connection_t* conn, const unsigned char* input, size_t inputLen) {
+    if (!conn || (!input && inputLen > 0)) {
+        return -1;
+    }
+
+    size_t offset = 0;
+
+    while (offset < inputLen) {
+        if (conn->headerBytesRead < TCP_FRAME_HEADER_SIZE) {
+            size_t needed = TCP_FRAME_HEADER_SIZE - conn->headerBytesRead;
+            size_t take = (inputLen - offset < needed) ? (inputLen - offset) : needed;
+
+            memcpy(conn->headerBuf + conn->headerBytesRead, input + offset, take);
+            conn->headerBytesRead += take;
+            offset += take;
+
+            if (conn->headerBytesRead < TCP_FRAME_HEADER_SIZE) {
+                continue;
+            }
+
+            uint32_t beLen = 0;
+            memcpy(&beLen, conn->headerBuf, sizeof(beLen));
+            conn->expectedPayloadLen = ntohl(beLen);
+
+            if (conn->expectedPayloadLen > TCP_MAX_FRAME_PAYLOAD) {
+                TcpConnection_ResetFramingState(conn);
+                return -1;
+            }
+
+            if (conn->expectedPayloadLen == 0) {
+                if (TcpConnection_SetDataBuffer(conn, NULL, 0) != 0) {
+                    TcpConnection_ResetFramingState(conn);
+                    return -1;
+                }
+
+                if (conn->on_data) {
+                    conn->on_data(conn);
+                }
+
+                conn->headerBytesRead = 0;
+                conn->expectedPayloadLen = 0;
+                continue;
+            }
+
+            conn->frameBuf = (unsigned char*)malloc(conn->expectedPayloadLen);
+            if (!conn->frameBuf) {
+                TcpConnection_ResetFramingState(conn);
+                return -1;
+            }
+            conn->frameBytesRead = 0;
+        }
+
+        size_t frameRemaining = conn->expectedPayloadLen - conn->frameBytesRead;
+        size_t take = (inputLen - offset < frameRemaining) ? (inputLen - offset) : frameRemaining;
+
+        memcpy(conn->frameBuf + conn->frameBytesRead, input + offset, take);
+        conn->frameBytesRead += take;
+        offset += take;
+
+        if (conn->frameBytesRead == conn->expectedPayloadLen) {
+            if (TcpConnection_SetDataBuffer(conn, conn->frameBuf, conn->expectedPayloadLen) != 0) {
+                TcpConnection_ResetFramingState(conn);
+                return -1;
+            }
+
+            if (conn->on_data) {
+                conn->on_data(conn);
+            }
+
+            conn->headerBytesRead = 0;
+            conn->expectedPayloadLen = 0;
+            conn->frameBytesRead = 0;
+            free(conn->frameBuf);
+            conn->frameBuf = NULL;
+        }
+    }
+
+    return 0;
+}
+
+int TcpConnection_SendRaw(int sockFd, const void* data, size_t len) {
+    if (sockFd < 0 || (!data && len > 0)) {
+        return -1;
+    }
+
+    size_t totalSent = 0;
+    const unsigned char* ptr = (const unsigned char*)data;
+
+    while (totalSent < len) {
+        ssize_t sent = send(sockFd, ptr + totalSent, len - totalSent, 0);
+        if (sent < 0) {
+            if (errno == EINTR) {
+                continue;
+            }
+            return -1;
+        }
+        if (sent == 0) {
+            return -1;
+        }
+
+        totalSent += (size_t)sent;
+    }
+
+    return 0;
+}
+
+int TcpConnection_SendFramed(tcp_connection_t* conn, const void* payload, size_t payloadLen) {
+    if (!conn || (!payload && payloadLen > 0) || payloadLen > TCP_MAX_FRAME_PAYLOAD) {
+        return -1;
+    }
+
+    uint32_t beLen = htonl((uint32_t)payloadLen);
+
+    pthread_mutex_lock(&conn->sendLock);
+
+#ifdef USE_IPV6
+    int sock;
+    if (conn->sockFd6 >= 0) {
+        // IPv6 is available, attempt to send on it. If it fails, we'll fall back to IPv4 if available.
+        sock = conn->sockFd6;
+    } else {
+        // IPv4 fallback
+        sock = conn->sockFd;
+    }
+
+    int rc = TcpConnection_SendRaw(sock, &beLen, sizeof(beLen));
+    if (rc == 0 && payloadLen > 0) {
+        rc = TcpConnection_SendRaw(sock, payload, payloadLen);
+    }
+#else
+    int rc = TcpConnection_SendRaw(conn->sockFd, &beLen, sizeof(beLen));
+    if (rc == 0 && payloadLen > 0) {
+        rc = TcpConnection_SendRaw(conn->sockFd, payload, payloadLen);
+    }
+#endif
+
+    pthread_mutex_unlock(&conn->sendLock);
+
+    return rc;
+}
+
+void TcpConnection_RequestClose(tcp_connection_t* conn) {
+    if (!conn) {
+        return;
+    }
+
+    pthread_mutex_lock(&conn->stateLock);
+    if (!conn->closing) {
+        conn->closing = true;
+        if (conn->sockFd >= 0) {
+            shutdown(conn->sockFd, SHUT_RDWR);
+        }
+#ifdef USE_IPV6
+        if (conn->sockFd6 >= 0) {
+            shutdown(conn->sockFd6, SHUT_RDWR);
+        }
+#endif
+    }
+    pthread_mutex_unlock(&conn->stateLock);
+}
+
+void TcpConnection_MarkDisconnectNotified(tcp_connection_t* conn) {
+    if (!conn) {
+        return;
+    }
+
+    pthread_mutex_lock(&conn->stateLock);
+    conn->disconnectedNotified = true;
+    pthread_mutex_unlock(&conn->stateLock);
+}
+
+bool TcpConnection_IsDisconnectNotified(tcp_connection_t* conn) {
+    if (!conn) {
+        return true;
+    }
+
+    pthread_mutex_lock(&conn->stateLock);
+    bool notified = conn->disconnectedNotified;
+    pthread_mutex_unlock(&conn->stateLock);
+
+    return notified;
+}
+
+#endif

src/tcpd/tcpserver.c

@@ -1,317 +1,407 @@
+#ifndef _WIN32
+
 #include <tcpd/tcpserver.h>
 
-TcpServer* TcpServer_Create() {
+#include <errno.h>
-    TcpServer* svr = (TcpServer*)malloc(sizeof(TcpServer));
+#include <numgen.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <unistd.h>
 
-    if (!svr) {
+static void TcpServer_RemoveClientByPtrUnlocked(tcp_server_t* svr, tcp_connection_t* cli) {
-        perror("tcpserver - creation failure");
+    if (!svr || !svr->clientsArrPtr || !cli) {
-        exit(1);
+        return;
     }
 
-    svr->sockFd = -1;
+    size_t idx = Generic_FindClientInArrayByPtr(svr->clientsArrPtr, cli, svr->maxClients);
-    svr->svrThread = 0;
-    svr->on_connect = NULL;
-    svr->on_data = NULL;
-    svr->on_disconnect = NULL;
-
-    svr->clients = 0;
-    svr->clientsArrPtr = NULL;
-
-    return svr;
-}
-
-void TcpServer_Destroy(TcpServer* ptr) {
-    if (ptr) {
-        if (ptr->clientsArrPtr) {
-            for (size_t i = 0; i < ptr->clients; i++) {
-                if (ptr->clientsArrPtr[i]) {
-                    free(ptr->clientsArrPtr[i]);
-                }
-            }
-
-            free(ptr->clientsArrPtr);
-        }
-
-        close(ptr->sockFd);
-        free(ptr);
-    }
-}
-
-void TcpServer_Init(TcpServer* ptr, unsigned short port, const char* addr) {
-    if (ptr) {
-        // Create socket
-        ptr->sockFd = socket(AF_INET, SOCK_STREAM, 0);
-        if (ptr->sockFd < 0) {
-            perror("tcpserver - socket");
-            exit(EXIT_FAILURE);
-        }
-
-        // Allow quick port resue
-        ptr->opt = 1;
-        setsockopt(ptr->sockFd, SOL_SOCKET, SO_REUSEADDR, &ptr->opt, sizeof(int));
-
-        // Fill address structure
-        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);
-
-        // Bind
-        if (bind(ptr->sockFd, (struct sockaddr*)&ptr->addr, sizeof(ptr->addr)) < 0) {
-            perror("tcpserver - bind");
-            close(ptr->sockFd);
-            exit(EXIT_FAILURE);
-        }
-    }
-}
-
-// Do not call outside of func.
-void* TcpServer_clientthreadprocess(void* ptr) {
-    if (!ptr) {
-        perror("Client ptr is null!\n");
-        return NULL;
-    }
-
-    tcpclient_thread_args* args = (tcpclient_thread_args*)ptr;
-
-    TcpClient* cli = args->clientPtr;
-    TcpServer* svr = args->serverPtr;
-
-    if (args) {
-        free(args);
-    }
-
-    while (1) {
-        memset(cli->dataBuf, 0, MTU); // Reset buffer
-        ssize_t n = recv(cli->clientFd, cli->dataBuf, MTU, 0);
-        cli->dataBufLen = n;
-
-        if (n == 0) {
-            break; // Client disconnected
-        } else if (n > 0) {
-            if (cli->on_data) {
-                cli->on_data(cli);
-            }
-        }
-
-        pthread_testcancel(); // Check for thread death
-    }
-
-    cli->on_disconnect(cli);
-
-    // Close on exit
-    close(cli->clientFd);
-
-    // Destroy
-    TcpClient** arr = svr->clientsArrPtr;
-    size_t idx = Generic_FindClientInArrayByPtr(arr, cli, svr->clients);
     if (idx != SIZE_MAX) {
-        if (arr[idx]) {
+        svr->clientsArrPtr[idx] = NULL;
-            free(arr[idx]);
-            arr[idx] = NULL;
     }
-    } else {
-        perror("tcpserver (client thread) - something already freed the client!");
-    }
-    
-    //free(ptr);
-
-    return NULL;
 }
 
-// Do not call outside of func.
+static void* TcpServer_clientthreadprocess(void* ptr) {
-void* TcpServer_threadprocess(void* ptr) {
+    tcpclient_thread_args* args = (tcpclient_thread_args*)ptr;
-    if (!ptr) {
+    if (!args || !args->clientPtr || !args->serverPtr) {
-        perror("Client ptr is null!\n");
+        free(args);
         return NULL;
     }
 
-    TcpServer* svr = (TcpServer*)ptr;
+    tcp_connection_t* cli = args->clientPtr;
-    while (1) {
+    tcp_server_t* svr = args->serverPtr;
-        TcpClient tempclient;
+    free(args);
-        socklen_t clientsize = sizeof(tempclient.clientAddr);
-        int client = accept(svr->sockFd, (struct sockaddr*)&tempclient.clientAddr, &clientsize);
-        if (client >= 0) {
-            tempclient.clientFd = client;
-            tempclient.on_data = svr->on_data;
-            tempclient.on_disconnect = svr->on_disconnect;
 
-            // I'm lazy, so I'm just copying the data for now (I should probably make this a better way)
+    unsigned char ioBuf[TCP_IO_BUFFER_SIZE];
-            TcpClient* heapCli = (TcpClient*)malloc(sizeof(TcpClient));
+
-            if (!heapCli) {
+    while (1) {
-                perror("tcpserver - client failed to allocate");
+        ssize_t n = recv(cli->sockFd, ioBuf, sizeof(ioBuf), 0);
-                exit(EXIT_FAILURE); // Wtf just happened???
+        if (n == 0) {
+            break;
         }
 
-            heapCli->clientAddr = tempclient.clientAddr;
+        if (n < 0) {
-            heapCli->clientFd = tempclient.clientFd;
+            if (errno == EINTR) {
-            heapCli->on_data = tempclient.on_data;
+                continue;
-            heapCli->on_disconnect = tempclient.on_disconnect;
+            }
-            heapCli->clientId = random_four_byte();
+            break;
-            heapCli->dataBufLen = 0;
+        }
 
-            size_t i;
+        if (TcpConnection_FeedFramedData(cli, ioBuf, (size_t)n) != 0) {
-            for (i = 0; i < svr->clients; i++) {
-                if (svr->clientsArrPtr[i] == NULL) {
-                    // Make use of that space
-                    svr->clientsArrPtr[i] = heapCli; // We have now transfered the ownership :)
             break;
         }
     }
 
-            if (i == svr->clients) {
+    TcpConnection_RequestClose(cli);
-                // Not found
-                // RST; Thread doesn't exist yet
-                struct linger so_linger;
-                so_linger.l_onoff = 1;
-                so_linger.l_linger = 0;
-                setsockopt(heapCli->clientFd, SOL_SOCKET, SO_LINGER, &so_linger, sizeof(so_linger));
-                close(heapCli->clientFd);
 
-                free(heapCli);
+    if (!TcpConnection_IsDisconnectNotified(cli) && cli->on_disconnect) {
-                heapCli = NULL;
+        TcpConnection_MarkDisconnectNotified(cli);
-                //svr->clientsArrPtr[i] = NULL;
+        cli->on_disconnect(cli);
+    }
 
+    pthread_mutex_lock(&svr->clientsMutex);
+    TcpServer_RemoveClientByPtrUnlocked(svr, cli);
+    pthread_mutex_unlock(&svr->clientsMutex);
+
+    TcpConnection_Destroy(cli);
+    free(cli);
+
+    return NULL;
+}
+
+static void* TcpServer_threadprocess(void* ptr) {
+    tcp_server_t* svr = (tcp_server_t*)ptr;
+    if (!svr) {
+        return NULL;
+    }
+
+    while (svr->isRunning) {
+        struct sockaddr_in clientAddr;
+        socklen_t clientSize = sizeof(clientAddr);
+        int clientFd = accept(svr->sockFd, (struct sockaddr*)&clientAddr, &clientSize);
+
+        if (clientFd < 0) {
+            if (!svr->isRunning) {
+                break;
+            }
+            if (errno == EINTR) {
+                continue;
+            }
             continue;
         }
 
-            tcpclient_thread_args* arg = (tcpclient_thread_args*)malloc(sizeof(tcpclient_thread_args));
+        tcp_connection_t* heapCli = (tcp_connection_t*)malloc(sizeof(*heapCli));
-            arg->clientPtr = heapCli;
+        if (!heapCli) {
-            arg->serverPtr = svr;
+            close(clientFd);
+            continue;
+        }
+
+        if (TcpConnection_Init(heapCli, clientFd, &clientAddr, TCP_CONNECTION_ROLE_INBOUND) != 0) {
+            close(clientFd);
+            free(heapCli);
+            continue;
+        }
+
+        heapCli->connectionId = random_four_byte();
+        heapCli->on_data = svr->on_data;
+        heapCli->on_disconnect = svr->on_disconnect;
+        heapCli->owner = svr->owner;
+
+        pthread_mutex_lock(&svr->clientsMutex);
+
+        size_t insertIdx = SIZE_MAX;
+        for (size_t i = 0; i < svr->maxClients; ++i) {
+            if (svr->clientsArrPtr[i] == NULL) {
+                insertIdx = i;
+                break;
+            }
+        }
+
+        if (insertIdx == SIZE_MAX) {
+            pthread_mutex_unlock(&svr->clientsMutex);
+            struct linger so_linger;
+            so_linger.l_onoff = 1;
+            so_linger.l_linger = 0;
+            setsockopt(heapCli->sockFd, SOL_SOCKET, SO_LINGER, &so_linger, sizeof(so_linger));
+            TcpConnection_Destroy(heapCli);
+            free(heapCli);
+            continue;
+        }
+
+        svr->clientsArrPtr[insertIdx] = heapCli;
+        pthread_mutex_unlock(&svr->clientsMutex);
 
         if (svr->on_connect) {
             svr->on_connect(heapCli);
         }
 
-            pthread_create(&heapCli->clientThread, NULL, TcpServer_clientthreadprocess, arg);
+        tcpclient_thread_args* arg = (tcpclient_thread_args*)malloc(sizeof(*arg));
-            pthread_detach(heapCli->clientThread); // May not work :(
+        if (!arg) {
+            TcpServer_Disconnect(svr, heapCli);
+            continue;
         }
 
-        pthread_testcancel(); // Check for thread death
+        arg->clientPtr = heapCli;
+        arg->serverPtr = svr;
+
+        pthread_attr_t attr;
+        pthread_attr_init(&attr);
+        pthread_attr_setstacksize(&attr, TCP_THREAD_STACK_SIZE);
+
+        if (pthread_create(&heapCli->ioThread, &attr, TcpServer_clientthreadprocess, arg) != 0) {
+            free(arg);
+            TcpServer_Disconnect(svr, heapCli);
+            pthread_attr_destroy(&attr);
+            continue;
+        }
+        pthread_attr_destroy(&attr);
     }
 
     return NULL;
 }
 
-void TcpServer_Start(TcpServer* ptr, int maxcons) {
+tcp_server_t* TcpServer_Create() {
-    if (ptr) {
+    tcp_server_t* svr = (tcp_server_t*)malloc(sizeof(*svr));
-        if (listen(ptr->sockFd, maxcons) < 0) {
+    if (!svr) {
-            perror("tcpserver - listen");
+        return NULL;
+    }
+
+    memset(svr, 0, sizeof(*svr));
+    svr->sockFd = -1;
+    svr->svrThread = 0;
+    svr->isRunning = 0;
+    svr->maxClients = 0;
+    svr->clientsArrPtr = NULL;
+#ifdef USE_IPV6
+    svr->sockFd6 = -1;
+#endif
+
+    if (pthread_mutex_init(&svr->clientsMutex, NULL) != 0) {
+        free(svr);
+        return NULL;
+    }
+
+    return svr;
+}
+
+void TcpServer_Destroy(tcp_server_t* ptr) {
+    if (!ptr) {
+        return;
+    }
+
+    TcpServer_Stop(ptr);
+
+    free(ptr->clientsArrPtr);
+    ptr->clientsArrPtr = NULL;
+
+    pthread_mutex_destroy(&ptr->clientsMutex);
+    free(ptr);
+}
+
+void TcpServer_Init(tcp_server_t* ptr, unsigned short port, const char* addr) {
+    if (!ptr || !addr) {
+        return;
+    }
+
+    ptr->sockFd = socket(AF_INET, SOCK_STREAM, 0);
+    if (ptr->sockFd < 0) {
+        return;
+    }
+
+    ptr->opt = 1;
+    setsockopt(ptr->sockFd, SOL_SOCKET, SO_REUSEADDR, &ptr->opt, sizeof(int));
+
+    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);
+
+    if (bind(ptr->sockFd, (struct sockaddr*)&ptr->addr, sizeof(ptr->addr)) < 0) {
         close(ptr->sockFd);
-            exit(EXIT_FAILURE);
+        ptr->sockFd = -1;
     }
 
-        ptr->clients = maxcons;
+#ifdef USE_IPV6
-        ptr->clientsArrPtr = (TcpClient**)malloc(sizeof(TcpClient*) * maxcons);
+    // IPv6 support
+    ptr->sockFd6 = socket(AF_INET6, SOCK_STREAM, 0);
+    if (ptr->sockFd6 >= 0) {
+        ptr->opt6 = 1;
+        setsockopt(ptr->sockFd6, SOL_SOCKET, SO_REUSEADDR, &ptr->opt6, sizeof(int));
+        memset(&ptr->addr6, 0, sizeof(ptr->addr6));
+        ptr->addr6.sin6_family = AF_INET6;
+        ptr->addr6.sin6_port = htons(port);
+        inet_pton(AF_INET6, addr, &ptr->addr6.sin6_addr);
+        if (bind(ptr->sockFd6, (struct sockaddr*)&ptr->addr6, sizeof(ptr->addr6)) < 0) {
+            close(ptr->sockFd6);
+            ptr->sockFd6 = -1;
+        }
+    } else {
+        ptr->sockFd6 = -1; // IPv6 is optional, so if it isn't available, we just set it to -1
+    }
+#else
+    // Safety for my future "I forgot the ifdef guard" self
+    ptr->sockFd6 = -1; // IPv6 not supported in this build
+#endif
+}
 
+void TcpServer_Start(tcp_server_t* ptr, int maxcons) {
+    if (!ptr || ptr->sockFd < 0 || maxcons <= 0 || ptr->isRunning) {
+        return;
+    }
+
+    if (listen(ptr->sockFd, maxcons) < 0) {
+        return;
+    }
+
+#ifdef USE_IPV6
+    if (ptr->sockFd6 >= 0) {
+        if (listen(ptr->sockFd6, maxcons) < 0) {
+            close(ptr->sockFd6);
+            ptr->sockFd6 = -1;
+        }
+    }
+#endif
+
+    pthread_mutex_lock(&ptr->clientsMutex);
+
+    ptr->maxClients = (size_t)maxcons;
+    ptr->clientsArrPtr = (tcp_connection_t**)malloc(sizeof(tcp_connection_t*) * ptr->maxClients);
     if (!ptr->clientsArrPtr) {
-            perror("tcpserver - allocation of client space fatally errored");
+        ptr->maxClients = 0;
-            exit(EXIT_FAILURE);
+        pthread_mutex_unlock(&ptr->clientsMutex);
+        return;
     }
 
-        // Fucking null out everything
+    for (size_t i = 0; i < ptr->maxClients; ++i) {
-        for (int i = 0; i < maxcons; i++) {
         ptr->clientsArrPtr[i] = NULL;
     }
-    }
 
-    // Spawn server thread
+    ptr->isRunning = 1;
-    pthread_create(&ptr->svrThread, NULL, TcpServer_threadprocess, ptr);
+    pthread_mutex_unlock(&ptr->clientsMutex);
+
+    if (pthread_create(&ptr->svrThread, NULL, TcpServer_threadprocess, ptr) != 0) {
+        pthread_mutex_lock(&ptr->clientsMutex);
+        ptr->isRunning = 0;
+        free(ptr->clientsArrPtr);
+        ptr->clientsArrPtr = NULL;
+        ptr->maxClients = 0;
+        pthread_mutex_unlock(&ptr->clientsMutex);
+    }
 }
 
-void TcpServer_Stop(TcpServer* ptr) {
+void TcpServer_Stop(tcp_server_t* ptr) {
-    if (ptr && ptr->svrThread != 0) {
+    if (!ptr || !ptr->isRunning) {
-        // Stop server
+        return;
-        pthread_cancel(ptr->svrThread);
+    }
+
+    ptr->isRunning = 0;
+
+    if (ptr->sockFd >= 0) {
+        shutdown(ptr->sockFd, SHUT_RDWR);
+        close(ptr->sockFd);
+        ptr->sockFd = -1;
+    }
+
+#ifdef USE_IPV6
+    if (ptr->sockFd6 >= 0) {
+        shutdown(ptr->sockFd6, SHUT_RDWR);
+        close(ptr->sockFd6);
+        ptr->sockFd6 = -1;
+    }
+#endif
+
+    if (ptr->svrThread != 0 && !pthread_equal(ptr->svrThread, pthread_self())) {
         pthread_join(ptr->svrThread, NULL);
-
-        // Disconnect clients
-        for (size_t i = 0; i < ptr->clients; i++) {
-            TcpClient* cliPtr = ptr->clientsArrPtr[i];
-            if (cliPtr) {
-                close(cliPtr->clientFd);
-                pthread_cancel(cliPtr->clientThread);
     }
-        }
-
     ptr->svrThread = 0;
+
+    pthread_mutex_lock(&ptr->clientsMutex);
+    size_t maxClients = ptr->maxClients;
+    tcp_connection_t** local = ptr->clientsArrPtr;
+    pthread_mutex_unlock(&ptr->clientsMutex);
+
+    for (size_t i = 0; i < maxClients; ++i) {
+        tcp_connection_t* cli = local[i];
+        if (!cli) {
+            continue;
+        }
+
+        TcpConnection_RequestClose(cli);
+    }
+
+    for (size_t i = 0; i < maxClients; ++i) {
+        tcp_connection_t* cli = local[i];
+        if (!cli) {
+            continue;
+        }
+
+        if (!pthread_equal(cli->ioThread, pthread_self())) {
+            pthread_join(cli->ioThread, NULL);
+        }
+    }
+
+    pthread_mutex_lock(&ptr->clientsMutex);
+    free(ptr->clientsArrPtr);
+    ptr->clientsArrPtr = NULL;
+    ptr->maxClients = 0;
+    pthread_mutex_unlock(&ptr->clientsMutex);
+}
+
+int TcpServer_Send(tcp_server_t* ptr, tcp_connection_t* cli, const void* data, size_t len) {
+    if (!ptr || !cli || !data || len == 0) {
+        return -1;
+    }
+
+    return TcpConnection_SendFramed(cli, data, len);
+}
+
+void Generic_SendSocket(int sock, const void* data, size_t len) {
+    (void)TcpConnection_SendRaw(sock, data, len);
+}
+
+void TcpServer_Disconnect(tcp_server_t* ptr, tcp_connection_t* cli) {
+    if (!ptr || !cli) {
+        return;
+    }
+
+    TcpConnection_RequestClose(cli);
+
+    if (!pthread_equal(cli->ioThread, pthread_self())) {
+        pthread_join(cli->ioThread, NULL);
     }
 }
 
-void TcpServer_Send(TcpServer* ptr, TcpClient* cli, void* data, size_t len) {
+void TcpServer_KillClient(tcp_server_t* ptr, tcp_connection_t* cli) {
-    if (ptr && cli && data && len > 0) {
+    if (!ptr || !cli) {
-        size_t sent = 0;
+        return;
-        while (sent < len) {
-            // Ensure that all data is sent. TCP can split sends.
-            ssize_t n = send(cli->clientFd, (unsigned char*)data + sent, len - sent, 0);
-            if (n < 0) {
-                perror("tcpserver - send error");
-                break;
     }
-            sent += n;
-        }
-    }
-}
 
-void Generic_SendSocket(int sock, void* data, size_t len) {
-    if (sock > 0 && data && len > 0) {
-        size_t sent = 0;
-        while (sent < len) {
-            ssize_t n = send(sock, (unsigned char*)data + sent, len - sent, 0);
-            if (n < 0) {
-                perror("generic - send socket error");
-                break;
-            }
-            sent += n;
-        }
-    }
-}
-
-void TcpServer_Disconnect(TcpServer* ptr, TcpClient* cli) {
-    if (ptr && cli) {
-        close(cli->clientFd);
-        pthread_cancel(cli->clientThread);
-
-        size_t idx = Generic_FindClientInArrayByPtr(ptr->clientsArrPtr, cli, ptr->clients);
-        if (idx != SIZE_MAX) {
-            if (ptr->clientsArrPtr[idx]) {
-                free(ptr->clientsArrPtr[idx]);
-            }
-            ptr->clientsArrPtr[idx] = NULL;
-        } else {
-            perror("tcpserver - didn't find client to disconnect in array!");
-        }
-    }
-}
-
-void TcpServer_KillClient(TcpServer* ptr, TcpClient* cli) {
-    if (ptr && cli) {
-        // RST the connection
     struct linger so_linger;
     so_linger.l_onoff = 1;
     so_linger.l_linger = 0;
-        setsockopt(cli->clientFd, SOL_SOCKET, SO_LINGER, &so_linger, sizeof(so_linger));
+    setsockopt(cli->sockFd, SOL_SOCKET, SO_LINGER, &so_linger, sizeof(so_linger));
-        close(cli->clientFd);
-        pthread_cancel(cli->clientThread);
 
-        size_t idx = Generic_FindClientInArrayByPtr(ptr->clientsArrPtr, cli, ptr->clients);
+#ifdef USE_IPV6
-        if (idx != SIZE_MAX) {
+    if (cli->sockFd6 >= 0) {
-            if (ptr->clientsArrPtr[idx]) {
+        setsockopt(cli->sockFd6, SOL_SOCKET, SO_LINGER, &so_linger, sizeof(so_linger));
-                free(ptr->clientsArrPtr[idx]);
-            }
-            ptr->clientsArrPtr[idx] = NULL;
-        } else {
-            perror("tcpserver - didn't find client to kill in array!");
-        }
     }
+#endif
+
+    TcpServer_Disconnect(ptr, cli);
 }
 
-size_t Generic_FindClientInArrayByPtr(TcpClient** arr, TcpClient* ptr, size_t len) {
+size_t Generic_FindClientInArrayByPtr(tcp_connection_t** arr, tcp_connection_t* ptr, size_t len) {
-    for (size_t i = 0; i < len; i++) {
+    if (!arr || !ptr) {
+        return SIZE_MAX;
+    }
+
+    for (size_t i = 0; i < len; ++i) {
         if (arr[i] == ptr) {
             return i;
         }
     }
 
-    return SIZE_MAX; // Returns max unsigned, likely improbable to be correct
+    return SIZE_MAX;
 }
+
+#endif

src/txmempool.c

@@ -0,0 +1,159 @@
+#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);
+
+    key32_t key;
+    memcpy(key.bytes, txHash, 32);
+
+    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);
+
+    khiter_t k = kh_get(tx_mempool_map_m, txMempool, key);
+    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)) {
+            signed_transaction_t tx = kh_val(txMempool, k);
+            char senderHex[65];
+            char recipient1Hex[65];
+            char recipient2Hex[65];
+            AddressToHexString(tx.transaction.senderAddress, senderHex);
+            AddressToHexString(tx.transaction.recipientAddress1, recipient1Hex);
+            AddressToHexString(tx.transaction.recipientAddress2, recipient2Hex);
+            printf("TX in mempool: sender=%s recipient1=%s recipient2=%s amount1=%llu amount2=%llu fee=%llu\n",
+                senderHex, recipient1Hex, recipient2Hex,
+                (unsigned long long)tx.transaction.amount1,
+                (unsigned long long)tx.transaction.amount2,
+                (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;
+}