Start doing TCP networking

CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.16)
 
-project(miniboinc
+project(skalacoin
     VERSION 0.1.0
     LANGUAGES C CXX
 )
@@ -44,10 +44,10 @@ if(NOT SECP256K1_FOUND)
 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
@@ -88,7 +88,7 @@ if(MINICOIN_ENABLE_AUTOLYKOS2_REF)
         OpenSSL::SSL
         OpenSSL::Crypto
     )
-    set(MINICOIN_AUTOLYKOS2_REF_AVAILABLE ON)
+    set(SKALACOIN_AUTOLYKOS2_REF_AVAILABLE ON)
 endif()
 
 # ---------------------------------------------------------
@@ -121,7 +121,7 @@ else()
     target_link_libraries(node PRIVATE ${SECP256K1_LIBRARY})
 endif()
 
-if(MINICOIN_AUTOLYKOS2_REF_AVAILABLE)
+if(SKALACOIN_AUTOLYKOS2_REF_AVAILABLE)
     target_link_libraries(node PRIVATE autolykos2_ref)
 endif()
 
@@ -136,6 +136,6 @@ 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>
 )
-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,15 @@
-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
+
+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" {
@@ -16,6 +17,7 @@ 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 +26,17 @@ 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_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 +44,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,

include/balance_sheet.h

@@ -2,10 +2,47 @@
 #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 <string.h>
+#include <uint256.h>
+
+typedef struct {
+    uint8_t bytes[32];
+} key32_t;
 
 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;
 
+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;
+}
+
+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();
+
 #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,16 +20,18 @@ 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);

include/block/chain.h

@@ -8,6 +8,8 @@
 #include <stdbool.h>
 #include <string.h>
 #include <uint256.h>
+#include <storage/block_table.h>
+#include <balance_sheet.h>
 
 typedef struct {
     DynArr* blocks;
@@ -24,7 +26,7 @@ void Chain_Wipe(blockchain_t* chain);
 
 // 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);
 
 // 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,17 @@
 #include <block/chain.h>
 #include <block/block.h>
 
+// Nets
+#define MAX_CONS 32 // Some baseline for now
+#define LISTEN_PORT 9393
+
+// 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 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
 
 // Reward schedule acceleration: 1 means normal-speed progression.
 #define EMISSION_ACCELERATION_FACTOR 1ULL
@@ -29,16 +34,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:
@@ -149,4 +153,64 @@ 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 = Chain_GetBlock(chain, Chain_Size(chain) - 1);
+    block_t* epochStartBlock = Chain_GetBlock(chain, (size_t)(Chain_Size(chain) - 1 - EPOCH_LENGTH));
+    if (!lastBlock || !epochStartBlock) {
+        return 0; // Invalid
+    }
+
+    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) {
+        return 0;
+    }
+
+    return (size_t)targetSize;
+}
+
+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 = Chain_GetBlock(chain, Chain_Size(chain) - 1);
+    if (!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
+        return;
+    }
+
+    Block_CalculateHash(prevBlock, outSeed);
+}
+
 #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/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/net_node.h

@@ -0,0 +1,29 @@
+#ifndef NET_NODE_H
+#define NET_NODE_H
+
+#ifndef _WIN32
+// POSIX
+#include <tcpd/tcpconnection.h>
+#include <tcpd/tcpserver.h>
+#endif
+
+#include <dynarr.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <constants.h>
+
+typedef struct {
+    tcp_server_t* server;
+    // TODO: Add the list of clients as well
+} net_node_t;
+
+net_node_t* Node_Create();
+void Node_Destroy(net_node_t* node);
+
+// 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);
+
+#endif

include/storage/block_table.h

@@ -0,0 +1,13 @@
+#ifndef BLOCK_TABLE_H
+#define BLOCK_TABLE_H
+
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct {
+    uint64_t blockNumber;
+    uint64_t byteNumber;
+    uint64_t blockSize;
+} block_table_entry_t;
+
+#endif

include/tcpd/tcpconnection.h

@@ -11,19 +11,19 @@
 
 #define MTU 1500
 
-struct TcpClient {
+struct tcp_connection_t {
     int clientFd;
     struct sockaddr_in clientAddr;
     uint32_t clientId;
 
     unsigned char dataBuf[MTU];
     ssize_t dataBufLen;
-    void (*on_data)(struct TcpClient* client);
+    void (*on_data)(struct tcp_connection_t* client);
-    void (*on_disconnect)(struct TcpClient* client);
+    void (*on_disconnect)(struct tcp_connection_t* client);
 
     pthread_t clientThread;
 };
 
-typedef struct TcpClient TcpClient;
+typedef struct tcp_connection_t tcp_connection_t;
 
 #endif

include/tcpd/tcpserver.h

@@ -10,7 +10,7 @@
 #include <pthread.h>
 #include <stdint.h>
 
-#include <tcpd/tcpclient.h>
+#include <tcpd/tcpconnection.h>
 #include <numgen.h>
 #include <dynarr.h>
 
@@ -20,37 +20,37 @@ typedef struct {
     int opt;
 
     // 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;
-    TcpClient** clientsArrPtr;
+    tcp_connection_t** clientsArrPtr;
 
     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);
+void TcpServer_Send(tcp_server_t* ptr, tcp_connection_t* cli, void* data, size_t len);
 void Generic_SendSocket(int sock, 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/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

src/autolykos2/autolykos2.c

@@ -16,10 +16,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 +29,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 +61,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 +75,180 @@ 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 seed32[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 (!seed32 || !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(seed32, nonce, height, round, laneCount, &laneIndex)) {
+            return false;
+        }
+
+        if (useContextDag) {
+            if (!ReadDagLaneFromContext(ctx, laneIndex, lane)) {
+                return false;
+            }
+        } else {
+            if (!ReadDagLaneFromSeed(seed32, 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(seed32, 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);
+    return Blake2b_Hash(finalInput, sizeof(finalInput), outHash, 32);
+}
+
 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 +259,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 +305,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 +354,75 @@ 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,
+        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,
+        32,
+        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 +430,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 +449,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,

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,115 @@
+#include <balance_sheet.h>
+
+khash_t(balance_sheet_map_m)* sheetMap = NULL;
+
+void BalanceSheet_Init() {
+    sheetMap = kh_init(balance_sheet_map_m);
+}
+
+int BalanceSheet_Insert(balance_sheet_entry_t entry) {
+    if (!sheetMap) { return -1; }
+
+    // Encapsulate key
+    key32_t key;
+    memcpy(key.bytes, entry.address, 32);
+
+    int ret;
+    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;
+}
+
+bool BalanceSheet_Lookup(uint8_t* address, balance_sheet_entry_t* out) {
+    if (!address || !out) { return false; }
+    
+    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));
+        return true;
+    }
+
+    return false;
+}
+
+bool BalanceSheet_SaveToFile(const char* outPath) {
+    if (!sheetMap) { return false; }
+
+    char outFile[512];
+    strcpy(outFile, outPath);
+    strcat(outFile, "/balance_sheet.data");
+    FILE* file = fopen(outFile, "wb");
+    if (!file) { 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);
+                return false;
+            }
+        }
+    }
+
+    fclose(file);
+    return true;
+}
+
+bool BalanceSheet_LoadFromFile(const char* inPath) {
+    if (!sheetMap) { return false; }
+
+    char inFile[512];
+    strcpy(inFile, inPath);
+    strcat(inFile, "/balance_sheet.data");
+    FILE* file = fopen(inFile, "rb");
+    if (!file) { return false; }
+
+    balance_sheet_entry_t entry;
+    while (fread(&entry, sizeof(balance_sheet_entry_t), 1, file) == 1) {
+        if (BalanceSheet_Insert(entry) < 0) {
+            fclose(file);
+            return false;
+        }
+    }
+
+    fclose(file);
+    return true;
+}
+
+void BalanceSheet_Print() {
+    if (!sheetMap) { return; }
+
+    // Iterate through every entry
+    khiter_t k;
+    size_t iter = 0;
+    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);
+
+            printf("Sheet entry %llu: mapkey=%02x%02x%02x%02x... address=%02x%02x%02x%02x... balance=%s\n",
+                (unsigned long long)(iter),
+                key.bytes[0], key.bytes[1], key.bytes[2], key.bytes[3],
+                val.address[0], val.address[1], val.address[2], val.address[3],
+                balanceStr,
+                iter++);
+        }
+    }
+}
+
+void BalanceSheet_Destroy() {
+    kh_destroy(balance_sheet_map_m, sheetMap);
+    sheetMap = NULL;
+}

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

@@ -7,6 +7,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 +23,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 +52,10 @@ block_t* Block_Create() {
         free(block);
         return NULL;
     }
+    
+    // Zero out padding
+    memset(block->header.reserved, 0, sizeof(block->header.reserved));
+
     return block;
 }
 
@@ -172,7 +199,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;
         }
@@ -271,9 +300,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,7 +321,13 @@ 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 {

src/block/chain.c

@@ -33,6 +33,65 @@ static bool BuildPath(char* out, size_t outSize, const char* dirpath, const char
     return written > 0 && (size_t)written < outSize;
 }
 
+static bool BuildSpendAmount(const signed_transaction_t* tx, uint256_t* outSpend) {
+    if (!tx || !outSpend) {
+        return false;
+    }
+
+    *outSpend = uint256_from_u64(0);
+    if (uint256_add_u64(outSpend, tx->transaction.amount1)) {
+        return false;
+    }
+    if (uint256_add_u64(outSpend, tx->transaction.amount2)) {
+        return false;
+    }
+    if (uint256_add_u64(outSpend, tx->transaction.fee)) {
+        return false;
+    }
+
+    return true;
+}
+
+static bool CreditAddress(const uint8_t address[32], uint64_t amount) {
+    if (!address || amount == 0) {
+        return true;
+    }
+
+    balance_sheet_entry_t entry;
+    if (BalanceSheet_Lookup((uint8_t*)address, &entry)) {
+        if (uint256_add_u64(&entry.balance, amount)) {
+            return false;
+        }
+    } else {
+        memset(&entry, 0, sizeof(entry));
+        memcpy(entry.address, address, 32);
+        entry.balance = uint256_from_u64(amount);
+    }
+
+    return BalanceSheet_Insert(entry) >= 0;
+}
+
+static bool DebitAddress(const uint8_t address[32], const uint256_t* amount) {
+    if (!address || !amount) {
+        return false;
+    }
+
+    balance_sheet_entry_t entry;
+    if (!BalanceSheet_Lookup((uint8_t*)address, &entry)) {
+        return false;
+    }
+
+    if (uint256_cmp(&entry.balance, amount) < 0) {
+        return false;
+    }
+
+    if (!uint256_subtract(&entry.balance, amount)) {
+        return false;
+    }
+
+    return BalanceSheet_Insert(entry) >= 0;
+}
+
 static void Chain_ClearBlocks(blockchain_t* chain) {
     if (!chain || !chain->blocks) {
         return;
@@ -73,15 +132,91 @@ void Chain_Destroy(blockchain_t* chain) {
 }
 
 bool Chain_AddBlock(blockchain_t* chain, block_t* block) {
-    if (chain && block && chain->blocks) {
+    if (!chain || !block || !chain->blocks) {
-        DynArr_push_back(chain->blocks, block);
+        return false;
-        chain->size++;
-        return true;
     }
 
+    if (!block->transactions) {
         return false;
     }
 
+    // First pass: ensure all non-coinbase senders can cover the full spend
+    // (amount1 + amount2 + fee) before mutating the chain or balance sheet.
+    size_t txCount = DynArr_size(block->transactions);
+    for (size_t i = 0; i < txCount; ++i) {
+        signed_transaction_t* tx = (signed_transaction_t*)DynArr_at(block->transactions, i);
+        if (!tx) {
+            return false;
+        }
+
+        if (Address_IsCoinbase(tx->transaction.senderAddress)) {
+            continue;
+        }
+
+        uint256_t spend;
+        if (!BuildSpendAmount(tx, &spend)) {
+            return false;
+        }
+
+        balance_sheet_entry_t senderEntry;
+        if (!BalanceSheet_Lookup(tx->transaction.senderAddress, &senderEntry)) {
+            fprintf(stderr, "Error: Sender address not found in balance sheet during block addition. Bailing!\n");
+            return false;
+        }
+
+        if (uint256_cmp(&senderEntry.balance, &spend) < 0) {
+            fprintf(stderr, "Error: Sender balance insufficient for block transaction. Bailing!\n");
+            return false;
+        }
+    }
+
+    // Push the block only after validation succeeds.
+    block_t* blk = (block_t*)DynArr_push_back(chain->blocks, block);
+    if (!blk) {
+        return false;
+    }
+    chain->size++;
+
+    // Second pass: apply the ledger changes.
+    if (blk->transactions) {
+        txCount = DynArr_size(blk->transactions);
+        for (size_t i = 0; i < txCount; ++i) {
+            signed_transaction_t* tx = (signed_transaction_t*)DynArr_at(blk->transactions, i);
+            if (!tx) {
+                continue;
+            }
+
+            if (!Address_IsCoinbase(tx->transaction.senderAddress)) {
+                uint256_t spend;
+                if (!BuildSpendAmount(tx, &spend) || !DebitAddress(tx->transaction.senderAddress, &spend)) {
+                    fprintf(stderr, "Error: Failed to debit sender balance during block addition. Bailing!\n");
+                    return false;
+                }
+            }
+
+            if (!CreditAddress(tx->transaction.recipientAddress1, tx->transaction.amount1)) {
+                fprintf(stderr, "Error: Failed to credit recipient1 balance during block addition. Bailing!\n");
+                return false;
+            }
+
+            if (tx->transaction.amount2 > 0) {
+                uint8_t zeroAddress[32] = {0};
+                if (memcmp(tx->transaction.recipientAddress2, zeroAddress, 32) == 0) {
+                    fprintf(stderr, "Error: amount2 is non-zero but recipient2 is empty during block addition. Bailing!\n");
+                    return false;
+                }
+
+                if (!CreditAddress(tx->transaction.recipientAddress2, tx->transaction.amount2)) {
+                    fprintf(stderr, "Error: Failed to credit recipient2 balance during block addition. Bailing!\n");
+                    return false;
+                }
+            }
+        }
+    }
+
+    return true;
+}
+
 block_t* Chain_GetBlock(blockchain_t* chain, size_t index) {
     if (chain) {
         return DynArr_at(chain->blocks, index);
@@ -122,6 +257,7 @@ bool Chain_IsValid(blockchain_t* chain) {
         // A potential issue is verifying PoW, since the chain read might only have header data without transactions.
         // A potnetial fix is verifying PoW as we go, when getting new blocks from peers, and only accepting blocks
         // with valid PoW, so that we can assume all blocks in the chain are valid in that regard.
+        // During the initial sync, we can verify the PoW, the validity of each transaction + coinbase, etc.
     }
     
     // Genesis needs special handling because the prevHash is always invalid (no previous block)
@@ -137,7 +273,7 @@ void Chain_Wipe(blockchain_t* chain) {
 
 bool Chain_SaveToFile(blockchain_t* chain, const char* dirpath, uint256_t currentSupply, uint64_t currentReward) {
     // To avoid stalling the chain from peers, write after every block addition (THAT IS VERIFIED)
-    // TODO: Write to one "db" file instead of one file per block - filesystems (and rm *) don't like millions of files :(
+    // TODO: Check fwrite() and fread() calls if they actually didn't error
 
     if (!chain || !chain->blocks || !EnsureDirectoryExists(dirpath)) {
         return false;
@@ -148,14 +284,25 @@ bool Chain_SaveToFile(blockchain_t* chain, const char* dirpath, uint256_t curren
         return false;
     }
 
-    // Find metadata file (create if not exists) to get the saved chain size (+ other things)
+    char chainPath[512];
-    FILE* metaFile = fopen(metaPath, "rb+");
+    if (!BuildPath(chainPath, sizeof(chainPath), dirpath, "chain.data")) {
-    if (!metaFile) {
-        metaFile = fopen(metaPath, "wb+");
-        if (!metaFile) {
         return false;
     }
     
+    char tablePath[512];
+    if (!BuildPath(tablePath, sizeof(tablePath), dirpath, "chain.table")) {
+        return false;
+    }
+    
+    // Find metadata file (create if not exists) to get the saved chain size (+ other things)
+    FILE* metaFile = fopen(metaPath, "rb+");
+    FILE* chainFile = fopen(chainPath, "rb+");
+    FILE* tableFile = fopen(tablePath, "rb+");
+    if (!metaFile || !chainFile || !tableFile) {
+        // Just overwrite everything
+        metaFile = fopen(metaPath, "wb+");
+        if (!metaFile) { return false; }
+
         // Initialize metadata with size 0
         size_t initialSize = 0;
         fwrite(&initialSize, sizeof(size_t), 1, metaFile);
@@ -169,6 +316,12 @@ bool Chain_SaveToFile(blockchain_t* chain, const char* dirpath, uint256_t curren
         uint64_t initialReward = 0;
         fwrite(&initialReward, sizeof(uint64_t), 1, metaFile);
 
+        chainFile = fopen(chainPath, "wb+");
+        if (!chainFile) { return false; }
+
+        tableFile = fopen(tablePath, "wb+");
+        if (!tableFile) { return false; }
+
         // TODO: Potentially some other things here, we'll see
     }
 
@@ -182,45 +335,63 @@ bool Chain_SaveToFile(blockchain_t* chain, const char* dirpath, uint256_t curren
     if (savedSize > DynArr_size(chain->blocks)) {
         // Saved chain is longer than current chain, this should not happen if we are always saving the current chain, but just in case, fail to save to avoid overwriting a potentially valid longer chain with a shorter one.
         fclose(metaFile);
+        fclose(chainFile);
+        fclose(tableFile);
         return false;
     }
 
-    // Filename formart: dirpath/block_{index}.dat
+    // Filename format: dirpath/chain.data
-    // File format: [block_header][num_transactions][transactions...] - since block_header is fixed size, LoadFromFile will only read those by default
+    // File format: ([block_header][num_transactions][transactions...])[*length] - since block_header is fixed size, LoadFromFile will only read those by default
+
+    fseek(chainFile, 0, SEEK_END); // Seek to the end of those files
+    fseek(tableFile, 0, SEEK_END);
+    long pos = ftell(chainFile);
+    if (pos < 0) {
+        fclose(metaFile);
+        fclose(chainFile);
+        fclose(tableFile);
+        return false;
+    }
+
+    uint64_t byteCount = (uint64_t)pos; // Get the size
 
     // Save blocks that are not yet saved
     for (size_t i = savedSize; i < DynArr_size(chain->blocks); i++) {
         block_t* blk = (block_t*)DynArr_at(chain->blocks, i);
         if (!blk) {
             fclose(metaFile);
+            fclose(chainFile);
+            fclose(tableFile);
             return false;
         }
 
+        uint64_t preIncrementByteSize = byteCount;
+
         // Construct file path
-        char filePath[256];
-        snprintf(filePath, sizeof(filePath), "%s/block_%zu.dat", dirpath, i);
-
-        FILE* blockFile = fopen(filePath, "wb");
-        if (!blockFile) {
-            fclose(metaFile);
-            return false;
-        }
-
         // Write block header
-        fwrite(&blk->header, sizeof(block_header_t), 1, blockFile);
+        fwrite(&blk->header, sizeof(block_header_t), 1, chainFile);
         size_t txSize = DynArr_size(blk->transactions);
-        fwrite(&txSize, sizeof(size_t), 1, blockFile); // Write number of transactions
+        fwrite(&txSize, sizeof(size_t), 1, chainFile); // Write number of transactions
+        byteCount += sizeof(block_header_t) + sizeof(size_t);
         // Write transactions
         for (size_t j = 0; j < txSize; j++) {
             signed_transaction_t* tx = (signed_transaction_t*)DynArr_at(blk->transactions, j);
-            if (fwrite(tx, sizeof(signed_transaction_t), 1, blockFile) != 1) {
+            if (fwrite(tx, sizeof(signed_transaction_t), 1, chainFile) != 1) {
-                fclose(blockFile);
+                fclose(chainFile);
                 fclose(metaFile);
+                fclose(tableFile);
                 return false;
             }
+
+            byteCount += sizeof(signed_transaction_t);
         }
 
-        fclose(blockFile);
+        // Create an entry in the block table
+        block_table_entry_t entry;
+        entry.blockNumber = i;
+        entry.byteNumber = preIncrementByteSize;
+        entry.blockSize = byteCount - preIncrementByteSize;
+        fwrite(&entry, sizeof(block_table_entry_t), 1, tableFile);
 
         DynArr_destroy(blk->transactions);
         blk->transactions = NULL; // Clear transactions to save memory since they're now saved on disk
@@ -240,13 +411,22 @@ bool Chain_SaveToFile(blockchain_t* chain, const char* dirpath, uint256_t curren
     uint32_t difficultyTarget = ((block_t*)DynArr_at(chain->blocks, newSize - 1))->header.difficultyTarget;
     fwrite(&difficultyTarget, sizeof(uint32_t), 1, metaFile);
     fwrite(&currentReward, sizeof(uint64_t), 1, metaFile);
+
+    // Safety
+    fflush(metaFile);
+    fflush(chainFile);
+    fflush(tableFile);
+
+    // Close all pointers
     fclose(metaFile);
+    fclose(chainFile);
+    fclose(tableFile);
 
     return true;
 }
 
-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) {
-    if (!chain || !chain->blocks || !dirpath || !outCurrentSupply) {
+    if (!chain || !chain->blocks || !dirpath || !outCurrentSupply || !outLastSavedHash) {
         return false;
     }
 
@@ -260,19 +440,58 @@ bool Chain_LoadFromFile(blockchain_t* chain, const char* dirpath, uint256_t* out
         return false;
     }
 
+    char chainPath[512];
+    if (!BuildPath(chainPath, sizeof(chainPath), dirpath, "chain.data")) {
+        return false;
+    }
+    
+    char tablePath[512];
+    if (!BuildPath(tablePath, sizeof(tablePath), dirpath, "chain.table")) {
+        return false;
+    }
+
     // Read metadata file to get saved chain size (+ other things)
-    FILE* metaFile = fopen(metaPath, "rb");
+    FILE* metaFile = fopen(metaPath, "rb+");
-    if (!metaFile) {
+    FILE* chainFile = fopen(chainPath, "rb+");
+    FILE* tableFile = fopen(tablePath, "rb+");
+    if (!metaFile || !chainFile || !tableFile) {
+        if (metaFile) fclose(metaFile);
+        if (chainFile) fclose(chainFile);
+        if (tableFile) fclose(tableFile);
         return false;
     }
 
     size_t savedSize = 0;
-    fread(&savedSize, sizeof(size_t), 1, metaFile);
+    if (fread(&savedSize, sizeof(size_t), 1, metaFile) != 1) {
-    uint8_t lastSavedHash[32];
+        fclose(metaFile);
-    fread(lastSavedHash, sizeof(uint8_t), 32, metaFile);
+        fclose(chainFile);
-    fread(outCurrentSupply, sizeof(uint256_t), 1, metaFile);
+        fclose(tableFile);
-    fread(outDifficultyTarget, sizeof(uint32_t), 1, metaFile);
+        return false;
-    fread(outCurrentReward, sizeof(uint64_t), 1, metaFile);
+    }
+    if (fread(outLastSavedHash, sizeof(uint8_t), 32, metaFile) != 32) {
+        fclose(metaFile);
+        fclose(chainFile);
+        fclose(tableFile);
+        return false;
+    }
+    if (fread(outCurrentSupply, sizeof(uint256_t), 1, metaFile) != 1) {
+        fclose(metaFile);
+        fclose(chainFile);
+        fclose(tableFile);
+        return false;
+    }
+    if (fread(outDifficultyTarget, sizeof(uint32_t), 1, metaFile) != 1) {
+        fclose(metaFile);
+        fclose(chainFile);
+        fclose(tableFile);
+        return false;
+    }
+    if (fread(outCurrentReward, sizeof(uint64_t), 1, metaFile) != 1) {
+        fclose(metaFile);
+        fclose(chainFile);
+        fclose(tableFile);
+        return false;
+    }
     fclose(metaFile);
 
     // TODO: Might add a flag to allow reading from a point onward, but just rewrite for now
@@ -280,34 +499,52 @@ bool Chain_LoadFromFile(blockchain_t* chain, const char* dirpath, uint256_t* out
 
     // Load blocks
     for (size_t i = 0; i < savedSize; i++) {
-        // Construct file path
+        // Get the table entry
-        char filePath[256];
+        //fseek(tableFile, sizeof(block_table_entry_t) * i, SEEK_SET); // I think that fread() should take care of this for us
-        snprintf(filePath, sizeof(filePath), "%s/block_%zu.dat", dirpath, i);
+        block_table_entry_t loc;
-
+        if (fread(&loc, sizeof(block_table_entry_t), 1, tableFile) != 1) {
-        block_t* blk = Block_Create();
+            fclose(chainFile);
-        if (!blk) {
+            fclose(tableFile);
             return false;
         }
 
-        FILE* blockFile = fopen(filePath, "rb");
+        if (loc.blockNumber != i) {
-        if (!blockFile) {
+            fclose(chainFile);
-            Block_Destroy(blk);
+            fclose(tableFile);
+            return false; // Mismatch
+        }
+
+        // Seek to that position
+        if (fseek(chainFile, loc.byteNumber, SEEK_SET) != 0) {
+            fclose(chainFile);
+            fclose(tableFile);
+            return false;
+        }
+
+        // Header-only load path: do not allocate per-block transaction arrays.
+        block_t* blk = (block_t*)calloc(1, sizeof(block_t));
+        if (!blk) {
+            fclose(chainFile);
+            fclose(tableFile);
             return false;
         }
 
         // Read block header and transactions
-        if (fread(&blk->header, sizeof(block_header_t), 1, blockFile) != 1) {
+        if (fread(&blk->header, sizeof(block_header_t), 1, chainFile) != 1) {
-            fclose(blockFile);
+            fclose(chainFile);
-            Block_Destroy(blk);
+            fclose(tableFile);
+            free(blk);
             return false;
         }
 
         size_t txSize = 0;
-        if (fread(&txSize, sizeof(size_t), 1, blockFile) != 1) {
+        if (fread(&txSize, sizeof(size_t), 1, chainFile) != 1) {
-            fclose(blockFile);
+            fclose(chainFile);
-            Block_Destroy(blk);
+            fclose(tableFile);
+            free(blk);
             return false;
         }
+        (void)txSize;
 
         /*for (size_t j = 0; j < txSize; j++) {
             signed_transaction_t tx;
@@ -318,16 +555,26 @@ bool Chain_LoadFromFile(blockchain_t* chain, const char* dirpath, uint256_t* out
             }
             Block_AddTransaction(blk, &tx);
         }*/ // Transactions are not read, we use the merkle root for validity
+        blk->transactions = NULL;
 
-        fclose(blockFile);
+        // Loading from disk currently restores headers only. Do not run Chain_AddBlock,
-        Chain_AddBlock(chain, blk);
+        // because it enforces transaction presence and mutates balances.
+        if (!DynArr_push_back(chain->blocks, blk)) {
+            fclose(chainFile);
+            fclose(tableFile);
+            free(blk);
+            return false;
+        }
+        chain->size++;
 
-        // Chain_AddBlock stores blocks by value, so the copied block now owns
+        // DynArr_push_back stores blocks by value, so the copied block now owns
-        // blk->transactions. Only free the temporary wrapper struct here.
+        // blk->transactions (NULL in header-only load mode). Free wrapper only.
         free(blk);
     }
 
     chain->size = savedSize;
+    fclose(chainFile);
+    fclose(tableFile);
 
     // After read, you SHOULD verify chain validity. We're not doing it here since returning false is a bit unclear if the read failed or if the chain is invalid.
     return true;

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
     );
@@ -59,6 +68,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,13 +82,9 @@ 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),
         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/main.c

@@ -9,8 +9,13 @@
 #include <string.h>
 #include <time.h>
 #include <signal.h>
+#include <balance_sheet.h>
 
 #include <constants.h>
+#include <autolykos2/autolykos2.h>
+#include <time.h>
+
+#include <nets/net_node.h>
 
 #ifndef CHAIN_DATA_DIR
 #define CHAIN_DATA_DIR "chain_data"
@@ -19,6 +24,7 @@
 void handle_sigint(int sig) {
     printf("Caught signal %d, exiting...\n", sig);
     Block_ShutdownPowContext();
+    BalanceSheet_Destroy();
     exit(0);
 }
 
@@ -27,6 +33,69 @@ uint32_t difficultyTarget = INITIAL_DIFFICULTY;
 // extern the currentReward from constants.h so we can update it as we mine blocks and save it to disk
 extern uint64_t currentReward;
 
+static void AddressFromCompressedPubkey(const uint8_t compressedPubkey[33], uint8_t outAddress[32]) {
+    if (!compressedPubkey || !outAddress) {
+        return;
+    }
+
+    SHA256(compressedPubkey, 33, outAddress);
+}
+
+static 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 int testCounts = 0;
+static void MakeTestRecipientAddress(uint8_t outAddress[32]) {
+    if (!outAddress) {
+        return;
+    }
+
+    const char* label = "skalacoin-test-recipient-address-";
+    char buffer[256];
+    snprintf(buffer, sizeof(buffer), "%s%d", label, testCounts);
+    SHA256((const unsigned char*)buffer, strlen(buffer), outAddress);
+    testCounts++;
+}
+
 static void Uint256ToDecimal(const uint256_t* value, char* out, size_t outSize) {
     if (!value || !out || outSize == 0) {
         return;
@@ -93,27 +162,55 @@ static bool MineBlock(block_t* block) {
 
 int main(int argc, char* argv[]) {
     signal(SIGINT, handle_sigint);
+    srand((unsigned int)time(NULL));
 
+    BalanceSheet_Init();
     const char* chainDataDir = CHAIN_DATA_DIR;
-    const uint64_t blocksToMine = 4000000;
+    const uint64_t blocksToMine = 1000;
     const double targetSeconds = TARGET_BLOCK_TIME;
 
     uint256_t currentSupply = uint256_from_u64(0);
 
+    net_node_t* node = Node_Create();
+    if (!node) {
+        BalanceSheet_Destroy();
+        return 1;
+    }
+
     blockchain_t* chain = Chain_Create();
     if (!chain) {
         fprintf(stderr, "failed to create chain\n");
         return 1;
     }
 
-    if (!Chain_LoadFromFile(chain, chainDataDir, &currentSupply, &difficultyTarget, &currentReward)) {
+    uint8_t lastSavedHash[32];
+    bool isFirstBlockOfLoadedChain = true;
+
+    if (!Chain_LoadFromFile(chain, chainDataDir, &currentSupply, &difficultyTarget, &currentReward, lastSavedHash)) {
         printf("No existing chain loaded from %s\n", chainDataDir);
     }
 
-    if (currentReward == 0) {
+    if (!BalanceSheet_LoadFromFile(chainDataDir)) {
+        printf("Failed to load the balance sheet or none existing\n");
+    }
+
+    const uint64_t effectivePhase1Blocks =
+        (PHASE1_TARGET_BLOCKS / EMISSION_ACCELERATION_FACTOR) > 0
+            ? (PHASE1_TARGET_BLOCKS / EMISSION_ACCELERATION_FACTOR)
+            : 1;
+
+    // During phase 1, reward is deterministic from (supply,height), so always recompute.
+    // This avoids using stale on-disk cached rewards (e.g. floor reward after genesis).
+    if ((uint64_t)Chain_Size(chain) < effectivePhase1Blocks || currentReward == 0) {
         currentReward = CalculateBlockReward(currentSupply, chain);
     }
 
+    {
+        uint8_t dagSeed[32];
+        GetNextDAGSeed(chain, dagSeed);
+        (void)Block_RebuildAutolykos2Dag(CalculateTargetDAGSize(chain), dagSeed);
+    }
+
     if (Chain_Size(chain) > 0) {
         if (Chain_IsValid(chain)) {
             printf("Loaded chain with %zu blocks from disk\n", Chain_Size(chain));
@@ -141,7 +238,15 @@ int main(int argc, char* argv[]) {
         printf("Mining %llu blocks with target time %.0fs...\n", (unsigned long long)blocksToMine, targetSeconds);
 
         uint8_t minerAddress[32];
-        SHA256((const unsigned char*)"minicoin-miner-1", strlen("minicoin-miner-1"), minerAddress);
+        uint8_t minerPrivateKey[32];
+        uint8_t minerCompressedPubkey[33];
+        if (!GenerateTestMinerIdentity(minerPrivateKey, minerCompressedPubkey, minerAddress)) {
+            fprintf(stderr, "failed to generate test miner keypair\n");
+            Chain_Destroy(chain);
+            Block_ShutdownPowContext();
+            BalanceSheet_Destroy();
+            return 1;
+        }
 
         for (uint64_t mined = 0; mined < blocksToMine; ++mined) {
             block_t* block = Block_Create();
@@ -155,12 +260,16 @@ int main(int argc, char* argv[]) {
             block->header.version = 1;
             block->header.blockNumber = (uint64_t)Chain_Size(chain);
             if (Chain_Size(chain) > 0) {
+                if (!isFirstBlockOfLoadedChain) {
                     block_t* lastBlock = Chain_GetBlock(chain, Chain_Size(chain) - 1);
                     if (lastBlock) {
                         Block_CalculateHash(lastBlock, block->header.prevHash);
                     } else {
                         memset(block->header.prevHash, 0, sizeof(block->header.prevHash));
                     }
+                } else {
+                    memcpy(block->header.prevHash, lastSavedHash, sizeof(lastSavedHash));
+                }
             } else {
                 memset(block->header.prevHash, 0, sizeof(block->header.prevHash));
             }
@@ -169,7 +278,7 @@ int main(int argc, char* argv[]) {
             block->header.nonce = 0;
 
             signed_transaction_t coinbaseTx;
-            memset(&coinbaseTx, 0, sizeof(coinbaseTx));
+            Transaction_Init(&coinbaseTx);
             coinbaseTx.transaction.version = 1;
             coinbaseTx.transaction.amount1 = currentReward;
             coinbaseTx.transaction.fee = 0;
@@ -222,23 +331,133 @@ int main(int argc, char* argv[]) {
 
             free(block); // chain stores blocks by value; transactions are owned by chain copy
 
-            // Save chain after each mined block; NOTE: In reality, blocks will appear every ~90s, so this won't be a realistic bottleneck on the mainnet
-            // TEMP
-            if (Chain_Size(chain) % 100 == 0) {
-                printf("Saving chain at height %zu...\n", Chain_Size(chain));
-                Chain_SaveToFile(chain, chainDataDir, currentSupply, currentReward);
-            }
-
             currentReward = CalculateBlockReward(currentSupply, chain); // Update the global currentReward for the next block
 
-            // TEST, disabled diff
+            // Save chain after each mined block; NOTE: In reality, blocks will appear every ~90s, so this won't be a realistic bottleneck on the mainnet
-            //if (Chain_Size(chain) % DIFFICULTY_ADJUSTMENT_INTERVAL == 0) {
+            // Persist the reward for the *next* block so restart behavior is correct.
-            //    difficultyTarget = Chain_ComputeNextTarget(chain, difficultyTarget);
+            printf("Saving chain at height %zu...\n", Chain_Size(chain));
-            //}
+            Chain_SaveToFile(chain, chainDataDir, currentSupply, currentReward);
+            
+            if (Chain_Size(chain) % DIFFICULTY_ADJUSTMENT_INTERVAL == 0) {
+                difficultyTarget = Chain_ComputeNextTarget(chain, difficultyTarget);
             }
 
-        if (!Chain_SaveToFile(chain, chainDataDir, currentSupply, currentReward)) {
+            if (Chain_Size(chain) % EPOCH_LENGTH == 0 && Chain_Size(chain) > 0) {
+                uint8_t dagSeed[32];
+                GetNextDAGSeed(chain, dagSeed);
+                (void)Block_RebuildAutolykos2Dag(CalculateTargetDAGSize(chain), dagSeed);
+            }
+
+            isFirstBlockOfLoadedChain = false;
+        }
+
+        // Post-loop test: spend some coins from the miner address to a different address.
+        // This validates sender balance checks, transaction signing, merkle root generation,
+        // and PoW mining for a non-coinbase transaction.
+        signed_transaction_t spends[100];
+        for (int i = 0; i < 100; i++) {
+            int rng = rand() % 10; // Random amount between 0 and 9 (inclusive)
+            const uint64_t spendAmount = rng * DECIMALS;
+            uint8_t recipientAddress[32];
+            MakeTestRecipientAddress(recipientAddress);
+
+            signed_transaction_t spendTx;
+            Transaction_Init(&spendTx);
+            spendTx.transaction.version = 1;
+            spendTx.transaction.fee = 0;
+            spendTx.transaction.amount1 = spendAmount;
+            spendTx.transaction.amount2 = 0;
+            memcpy(spendTx.transaction.senderAddress, minerAddress, sizeof(minerAddress));
+            memcpy(spendTx.transaction.recipientAddress1, recipientAddress, sizeof(recipientAddress));
+            memset(spendTx.transaction.recipientAddress2, 0, sizeof(spendTx.transaction.recipientAddress2));
+            memcpy(spendTx.transaction.compressedPublicKey, minerCompressedPubkey, sizeof(minerCompressedPubkey));
+
+            Transaction_Sign(&spendTx, minerPrivateKey);
+            spends[i] = spendTx;
+        }
+
+        block_t* spendBlock = Block_Create();
+        if (!spendBlock) {
+            fprintf(stderr, "failed to create test spend block\n");
+            Chain_Destroy(chain);
+            Block_ShutdownPowContext();
+            BalanceSheet_Destroy();
+            return 1;
+        }
+
+        spendBlock->header.version = 1;
+        spendBlock->header.blockNumber = (uint64_t)Chain_Size(chain);
+        if (Chain_Size(chain) > 0) {
+            block_t* lastBlock = Chain_GetBlock(chain, Chain_Size(chain) - 1);
+            if (lastBlock) {
+                Block_CalculateHash(lastBlock, spendBlock->header.prevHash);
+            } else {
+                memset(spendBlock->header.prevHash, 0, sizeof(spendBlock->header.prevHash));
+            }
+        } else {
+            memset(spendBlock->header.prevHash, 0, sizeof(spendBlock->header.prevHash));
+        }
+        spendBlock->header.timestamp = (uint64_t)time(NULL);
+        spendBlock->header.difficultyTarget = difficultyTarget;
+        spendBlock->header.nonce = 0;
+
+        signed_transaction_t testCoinbaseTx;
+        Transaction_Init(&testCoinbaseTx);
+        memset(&testCoinbaseTx, 0, sizeof(testCoinbaseTx));
+        testCoinbaseTx.transaction.version = 1;
+        testCoinbaseTx.transaction.amount1 = currentReward;
+        testCoinbaseTx.transaction.fee = 0;
+        memcpy(testCoinbaseTx.transaction.recipientAddress1, minerAddress, sizeof(minerAddress));
+        testCoinbaseTx.transaction.recipientAddress2[0] = 0;
+        testCoinbaseTx.transaction.amount2 = 0;
+        memset(testCoinbaseTx.transaction.compressedPublicKey, 0, sizeof(testCoinbaseTx.transaction.compressedPublicKey));
+        memset(testCoinbaseTx.transaction.senderAddress, 0xFF, sizeof(testCoinbaseTx.transaction.senderAddress));
+
+        Block_AddTransaction(spendBlock, &testCoinbaseTx);
+        for (int i = 0; i < 100; i++) {
+            Block_AddTransaction(spendBlock, &spends[i]);
+        }
+
+        uint8_t merkleRoot[32];
+        Block_CalculateMerkleRoot(spendBlock, merkleRoot);
+        memcpy(spendBlock->header.merkleRoot, merkleRoot, sizeof(spendBlock->header.merkleRoot));
+
+        if (!MineBlock(spendBlock)) {
+            fprintf(stderr, "failed to mine test spend block\n");
+            Block_Destroy(spendBlock);
+            Chain_Destroy(chain);
+            Block_ShutdownPowContext();
+            BalanceSheet_Destroy();
+            return 1;
+        }
+
+        if (!Chain_AddBlock(chain, spendBlock)) {
+            fprintf(stderr, "failed to append test spend block to chain\n");
+            Block_Destroy(spendBlock);
+            Chain_Destroy(chain);
+            Block_ShutdownPowContext();
+            BalanceSheet_Destroy();
+            return 1;
+        }
+
+        (void)uint256_add_u64(&currentSupply, testCoinbaseTx.transaction.amount1);
+        currentReward = CalculateBlockReward(currentSupply, chain);
+
+        //printf("Mined test spend block (height=%llu) sending %llu base units to a new address\n",
+        //    (unsigned long long)spendBlock->header.blockNumber,
+        //    (unsigned long long)spendAmount);
+
+        free(spendBlock);
+
+        bool chainSaved = Chain_SaveToFile(chain, chainDataDir, currentSupply, currentReward);
+        bool sheetSaved = BalanceSheet_SaveToFile(chainDataDir);
+        if (!chainSaved || !sheetSaved) {
+            if (!chainSaved) {
                 fprintf(stderr, "failed to save chain to %s\n", chainDataDir);
+            }
+            if (!sheetSaved) {
+                fprintf(stderr, "failed to save balance sheet to %s\n", chainDataDir);
+            }
         } else {
             char supplyStr[80];
             Uint256ToDecimal(&currentSupply, supplyStr, sizeof(supplyStr));
@@ -261,7 +480,15 @@ int main(int argc, char* argv[]) {
         }
     }*/
 
+    BalanceSheet_Print();
+    if (!BalanceSheet_SaveToFile(chainDataDir)) {
+        fprintf(stderr, "failed to save balance sheet to %s\n", chainDataDir);
+    }
+
     Chain_Destroy(chain);
     Block_ShutdownPowContext();
+
+    Node_Destroy(node);
+
     return 0;
 }

src/nets/net_node.c

@@ -0,0 +1,43 @@
+#include <nets/net_node.h>
+
+net_node_t* Node_Create() {
+    net_node_t* node = (net_node_t*)malloc(sizeof(net_node_t));
+    if (!node) { return NULL; }
+
+    node->server = TcpServer_Create();
+    if (!node->server) {
+        free(node);
+        return NULL;
+    }
+
+    TcpServer_Init(node->server, LISTEN_PORT, "0.0.0.0"); // All interfaces
+    
+    // Register callbacks before starting the server
+    node->server->on_connect = Node_Server_OnConnect;
+    node->server->on_data = Node_Server_OnData;
+    node->server->on_disconnect = Node_Server_OnDisconnect;
+    
+    TcpServer_Start(node->server, MAX_CONS);
+
+    return node;
+}
+
+void Node_Destroy(net_node_t* node) {
+    if (!node || !node->server) { return; }
+    TcpServer_Stop(node->server);
+    TcpServer_Destroy(node->server);
+
+    free(node);
+}
+
+void Node_Server_OnConnect(tcp_connection_t* client) {
+    printf("A node connected!\n");
+}
+
+void Node_Server_OnData(tcp_connection_t* client) {
+    printf("A node sent data!\n");
+}
+
+void Node_Server_OnDisconnect(tcp_connection_t* client) {
+    printf("A node disconnected!\n");
+}

src/tcpd/tcpserver.c

@@ -1,7 +1,9 @@
+#ifndef _WIN32
+
 #include <tcpd/tcpserver.h>
 
-TcpServer* TcpServer_Create() {
+tcp_server_t* TcpServer_Create() {
-    TcpServer* svr = (TcpServer*)malloc(sizeof(TcpServer));
+    tcp_server_t* svr = (tcp_server_t*)malloc(sizeof(tcp_server_t));
 
     if (!svr) {
         perror("tcpserver - creation failure");
@@ -20,7 +22,7 @@ TcpServer* TcpServer_Create() {
     return svr;
 }
 
-void TcpServer_Destroy(TcpServer* ptr) {
+void TcpServer_Destroy(tcp_server_t* ptr) {
     if (ptr) {
         if (ptr->clientsArrPtr) {
             for (size_t i = 0; i < ptr->clients; i++) {
@@ -37,7 +39,7 @@ void TcpServer_Destroy(TcpServer* 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) {
     if (ptr) {
         // Create socket
         ptr->sockFd = socket(AF_INET, SOCK_STREAM, 0);
@@ -74,8 +76,8 @@ void* TcpServer_clientthreadprocess(void* ptr) {
 
     tcpclient_thread_args* args = (tcpclient_thread_args*)ptr;
 
-    TcpClient* cli = args->clientPtr;
+    tcp_connection_t* cli = args->clientPtr;
-    TcpServer* svr = args->serverPtr;
+    tcp_server_t* svr = args->serverPtr;
 
     if (args) {
         free(args);
@@ -97,13 +99,15 @@ void* TcpServer_clientthreadprocess(void* ptr) {
         pthread_testcancel(); // Check for thread death
     }
 
+    if (cli->on_disconnect) {
         cli->on_disconnect(cli);
+    }
 
     // Close on exit
     close(cli->clientFd);
 
     // Destroy
-    TcpClient** arr = svr->clientsArrPtr;
+    tcp_connection_t** arr = svr->clientsArrPtr;
     size_t idx = Generic_FindClientInArrayByPtr(arr, cli, svr->clients);
     if (idx != SIZE_MAX) {
         if (arr[idx]) {
@@ -126,9 +130,9 @@ void* TcpServer_threadprocess(void* ptr) {
         return NULL;
     }
     
-    TcpServer* svr = (TcpServer*)ptr;
+    tcp_server_t* svr = (tcp_server_t*)ptr;
     while (1) {
-        TcpClient tempclient;
+        tcp_connection_t tempclient;
         socklen_t clientsize = sizeof(tempclient.clientAddr);
         int client = accept(svr->sockFd, (struct sockaddr*)&tempclient.clientAddr, &clientsize);
         if (client >= 0) {
@@ -137,7 +141,7 @@ void* TcpServer_threadprocess(void* ptr) {
             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)
-            TcpClient* heapCli = (TcpClient*)malloc(sizeof(TcpClient));
+            tcp_connection_t* heapCli = (tcp_connection_t*)malloc(sizeof(tcp_connection_t));
             if (!heapCli) {
                 perror("tcpserver - client failed to allocate");
                 exit(EXIT_FAILURE); // Wtf just happened???
@@ -193,7 +197,7 @@ void* TcpServer_threadprocess(void* ptr) {
     return NULL;
 }
 
-void TcpServer_Start(TcpServer* ptr, int maxcons) {
+void TcpServer_Start(tcp_server_t* ptr, int maxcons) {
     if (ptr) {
         if (listen(ptr->sockFd, maxcons) < 0) {
             perror("tcpserver - listen");
@@ -202,7 +206,7 @@ void TcpServer_Start(TcpServer* ptr, int maxcons) {
         }
 
         ptr->clients = maxcons;
-        ptr->clientsArrPtr = (TcpClient**)malloc(sizeof(TcpClient*) * maxcons);
+        ptr->clientsArrPtr = (tcp_connection_t**)malloc(sizeof(tcp_connection_t*) * maxcons);
 
         if (!ptr->clientsArrPtr) {
             perror("tcpserver - allocation of client space fatally errored");
@@ -219,7 +223,7 @@ void TcpServer_Start(TcpServer* ptr, int maxcons) {
     pthread_create(&ptr->svrThread, NULL, TcpServer_threadprocess, ptr);
 }
 
-void TcpServer_Stop(TcpServer* ptr) {
+void TcpServer_Stop(tcp_server_t* ptr) {
     if (ptr && ptr->svrThread != 0) {
         // Stop server
         pthread_cancel(ptr->svrThread);
@@ -227,7 +231,7 @@ void TcpServer_Stop(TcpServer* ptr) {
 
         // Disconnect clients
         for (size_t i = 0; i < ptr->clients; i++) {
-            TcpClient* cliPtr = ptr->clientsArrPtr[i];
+            tcp_connection_t* cliPtr = ptr->clientsArrPtr[i];
             if (cliPtr) {
                 close(cliPtr->clientFd);
                 pthread_cancel(cliPtr->clientThread);
@@ -238,7 +242,7 @@ void TcpServer_Stop(TcpServer* ptr) {
     }
 }
 
-void TcpServer_Send(TcpServer* ptr, TcpClient* cli, void* data, size_t len) {
+void TcpServer_Send(tcp_server_t* ptr, tcp_connection_t* cli, void* data, size_t len) {
     if (ptr && cli && data && len > 0) {
         size_t sent = 0;
         while (sent < len) {
@@ -267,7 +271,7 @@ void Generic_SendSocket(int sock, void* data, size_t len) {
     }
 }
 
-void TcpServer_Disconnect(TcpServer* ptr, TcpClient* cli) {
+void TcpServer_Disconnect(tcp_server_t* ptr, tcp_connection_t* cli) {
     if (ptr && cli) {
         close(cli->clientFd);
         pthread_cancel(cli->clientThread);
@@ -284,7 +288,7 @@ void TcpServer_Disconnect(TcpServer* ptr, TcpClient* cli) {
     }
 }
 
-void TcpServer_KillClient(TcpServer* ptr, TcpClient* cli) {
+void TcpServer_KillClient(tcp_server_t* ptr, tcp_connection_t* cli) {
     if (ptr && cli) {
         // RST the connection
         struct linger so_linger;
@@ -306,7 +310,7 @@ void TcpServer_KillClient(TcpServer* ptr, TcpClient* 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[i] == ptr) {
             return i;
@@ -315,3 +319,5 @@ size_t Generic_FindClientInArrayByPtr(TcpClient** arr, TcpClient* ptr, size_t le
 
     return SIZE_MAX; // Returns max unsigned, likely improbable to be correct
 }
+
+#endif