chore: remove buggy logger

src/main.zig

@@ -11,7 +11,6 @@
 
 //==== Imports ====//
 const std = @import("std");
-const logger = @import("util/trace/log.zig");
 
 const Config = @import("config/config.zig").Config;
 const Mempool = @import("core/mempool.zig").Mempool;
@@ -35,13 +34,6 @@ pub fn main() !void {
  const allocator = gpa_state.allocator();
  defer _ = gpa_state.deinit();
 
- // Set up logger
- var our_logger = logger.Logger.init(allocator, .debug);
- defer our_logger.deinit();
- our_logger.spawn();
-
- logger.default_logger.* = our_logger;
-
  // Parse command-line arguments
  const args = try std.process.argsAlloc(allocator);
  defer std.process.argsFree(allocator, args);
@@ -171,12 +163,12 @@ fn runNodeCommand(program: *Program) !void {
  defer mempool.deinit();
  var storage = try Storage.init(&config);
  defer storage.deinit();
- var p2p = try P2P.init(program.allocator, &config, logger.default_logger.*);
+ var p2p = try P2P.init(program.allocator, &config);
  defer p2p.deinit();
- var rpc = try RPC.init(program.allocator, &config, &mempool, &storage, logger.default_logger.*);
+ var rpc = try RPC.init(program.allocator, &config, &mempool, &storage);
  defer rpc.deinit();
 
- var node = try Node.init(program.allocator, logger.default_logger.*, &mempool, &storage, &p2p, &rpc);
+ var node = try Node.init(program.allocator, &mempool, &storage, &p2p, &rpc);
  defer node.deinit();
 
  // Start the node

src/network/p2p.zig

@@ -6,7 +6,6 @@ const net = std.net;
 const posix = std.posix;
 const Config = @import("../config/config.zig").Config;
 const Peer = @import("peer.zig").Peer;
-const Logger = @import("../util/trace/log.zig").Logger;
 const wire = @import("wire/lib.zig");
 const protocol = @import("protocol/lib.zig");
 const VersionMessage = protocol.messages.VersionMessage;
@@ -22,21 +21,19 @@ pub const P2P = struct {
  peers: std.ArrayList(*Peer),
  /// Listener.
  listener: ?net.Server,
- logger: Logger,
 
  /// Initialize the P2P network handler.
  /// # Arguments
  /// - `allocator`: Allocator.
  /// - `config`: Configuration.
  /// # Returns
  /// - `P2P`: P2P network handler.
- pub fn init(allocator: std.mem.Allocator, config: *const Config, logger: Logger) !P2P {
+ pub fn init(allocator: std.mem.Allocator, config: *const Config) !P2P {
  return P2P{
  .allocator = allocator,
  .config = config,
  .peers = std.ArrayList(*Peer).init(allocator),
  .listener = null,
- .logger = logger,
  };
  }
 
@@ -51,7 +48,7 @@ pub const P2P = struct {
 
  /// Start the P2P network handler.
  pub fn start(self: *P2P) !void {
- self.logger.infof("Starting P2P network on port {}", .{self.config.p2p_port});
+ std.log.info("Starting P2P network on port {}", .{self.config.p2p_port});
 
  for (self.config.dnsSeeds()) |seed| {
  const address_list = try std.net.getAddressList(self.allocator, seed.inner, 8333);
@@ -62,62 +59,4 @@ pub const P2P = struct {
  }
  }
  }
- /// Accept incoming connections.
- /// The P2P network handler will accept incoming connections and handle them in a separate thread.
- fn acceptConnections(self: *P2P) !void {
- while (true) {
- const connection = self.listener.?.accept() catch |err| {
- self.logger.errf("Failed to accept connection: {}", .{err});
- continue;
- };
-
- // Handle the new connection in a separate thread
- // TODO: Error handling
- _ = try std.Thread.spawn(.{}, handleConnection, .{ self, connection });
- }
- }
-
- /// Handle a new connection.
- /// # Arguments
- /// - `self`: P2P network handler.
- /// - `connection`: Connection.
- fn handleConnection(self: *P2P, connection: net.Server.Connection) void {
- const peer = Peer.init(self.allocator, connection) catch |err| {
- self.logger.errf("Failed to initialize peer: {}", .{err});
- connection.stream.close();
- return;
- };
-
- // Add the peer to the list of peers
- self.peers.append(peer) catch |err| {
- self.logger.errf("Failed to add peer: {}", .{err});
- peer.deinit();
- return;
- };
-
- // Start the peer in a new thread
- peer.start() catch |err| {
- self.logger.errf("Peer encountered an error: {}", .{err});
- _ = self.peers.swapRemove(self.peers.items.len - 1);
- peer.deinit();
- };
- }
-
- /// Connect to seed nodes.
- fn connectToSeedNodes(self: *P2P) !void {
- // If no seed nodes are configured, do nothing
- if (self.config.seednode.len == 0) {
- return;
- }
-
- const address = try net.Address.parseIp4(self.config.seednode, 8333);
- const stream = try net.tcpConnectToAddress(address);
-
- const peer = try Peer.init(self.allocator, .{ .stream = stream, .address = address });
- try self.peers.append(peer);
-
- // Start the peer in a new thread
- // TODO: Error handling
- _ = try std.Thread.spawn(.{}, Peer.start, .{peer});
- }
 };

src/network/rpc.zig

@@ -6,7 +6,6 @@ const Config = @import("../config/config.zig").Config;
 const Mempool = @import("../core/mempool.zig").Mempool;
 const Storage = @import("../storage/storage.zig").Storage;
 const httpz = @import("httpz");
-const Logger = @import("../util/trace/log.zig").Logger;
 
 /// RPC Server handler.
 ///
@@ -21,7 +20,6 @@ pub const RPC = struct {
  mempool: *Mempool,
  /// Blockchain storage.
  storage: *Storage,
- logger: Logger,
  /// Initialize the RPC server.
  /// # Arguments
  /// - `allocator`: Allocator.
@@ -35,14 +33,12 @@ pub const RPC = struct {
  config: *const Config,
  mempool: *Mempool,
  storage: *Storage,
- logger: Logger,
  ) !RPC {
  const rpc = RPC{
  .allocator = allocator,
  .config = config,
  .mempool = mempool,
  .storage = storage,
- .logger = logger,
  };
 
  return rpc;
@@ -57,7 +53,7 @@ pub const RPC = struct {
  /// Start the RPC server.
  /// The RPC server will start a HTTP server and listen on the RPC port.
  pub fn start(self: *RPC) !void {
- self.logger.infof("Starting RPC server on port {}", .{self.config.rpc_port});
+ std.log.info("Starting RPC server on port {}", .{self.config.rpc_port});
  var handler = Handler{};
 
  var server = try httpz.Server(*Handler).init(self.allocator, .{ .port = self.config.rpc_port }, &handler);
@@ -66,7 +62,7 @@ pub const RPC = struct {
  router.get("/", index, .{});
  router.get("/error", @"error", .{});
 
- self.logger.infof("RPC server listening on http://localhost:{d}/\n", .{self.config.rpc_port});
+ std.log.info("RPC server listening on http://localhost:{d}/\n", .{self.config.rpc_port});
 
  // Starts the server, this is blocking.
  // TODO: Make it non-blocking. cc @StringNick

src/node/ibd.zig

@@ -2,61 +2,15 @@ const std = @import("std");
 const P2P = @import("../network/p2p.zig").P2P;
 const Block = @import("../types/block.zig").Block;
 const Transaction = @import("../types/transaction.zig").Transaction;
-const Logger = @import("../util/trace/log.zig").Logger;
 
 pub const IBD = struct {
  p2p: *P2P,
- logger: Logger,
 
- pub fn init(p2p: *P2P, logger: Logger) IBD {
+ pub fn init(p2p: *P2P) IBD {
  return .{
  .p2p = p2p,
- .logger = logger,
  };
  }
 
- pub fn start(self: *IBD) !void {
- self.logger.info("Starting Initial Block Download...");
-
- try self.connectToPeers();
- try self.downloadBlocks();
- try self.validateBlocks();
-
- // Simulate catching up to the tip after 10 seconds
- std.time.sleep(std.time.ns_per_s * 10);
- self.logger.info("Caught up to the tip of the chain!");
- }
-
- fn connectToPeers(self: *IBD) !void {
- self.logger.info("Connecting to initial set of peers...");
- // Simulate connecting to peers
- std.time.sleep(std.time.ns_per_s * 2);
- self.logger.info("Connected to 8 peers.");
- }
-
- fn downloadBlocks(self: *IBD) !void {
- self.logger.info("Downloading blocks...");
- // Simulate block download
- }
-
- fn simulateBlockDownload(self: *IBD) !Block {
- _ = self;
- // Simulate network delay
- std.time.sleep(std.time.ns_per_ms * 10);
- return Block{ .height = 0, .hash = [_]u8{0} ** 32 };
- }
-
- fn processBlock(self: *IBD, block: Block) !void {
- _ = self;
- // Simulate block processing
- std.time.sleep(std.time.ns_per_ms * 5);
- _ = block;
- }
-
- fn validateBlocks(self: *IBD) !void {
- self.logger.info("Validating downloaded blocks...");
- // Simulate block validation
- std.time.sleep(std.time.ns_per_s * 3);
- self.logger.info("All blocks validated successfully.");
- }
+ pub fn start(_: *IBD) !void {}
 };

src/node/node.zig

@@ -6,7 +6,6 @@ const Mempool = @import("../core/mempool.zig").Mempool;
 const Storage = @import("../storage/storage.zig").Storage;
 const P2P = @import("../network/p2p.zig").P2P;
 const RPC = @import("../network/rpc.zig").RPC;
-const Logger = @import("../util/trace/log.zig").Logger;
 const IBD = @import("ibd.zig").IBD;
 const Block = @import("../types/block.zig").Block;
 const Transaction = @import("../types/transaction.zig").Transaction;
@@ -28,8 +27,6 @@ pub const Node = struct {
  started: std.Thread.Condition,
  /// Mutex to synchronize access to the node.
  mutex: std.Thread.Mutex,
- /// Logger.
- logger: Logger,
  /// IBD handler.
  ibd: IBD,
 
@@ -40,18 +37,17 @@ pub const Node = struct {
  /// - `storage`: Blockchain storage.
  /// - `p2p`: P2P network handler.
  /// - `rpc`: RPC server.
- pub fn init(allocator: std.mem.Allocator, logger: Logger, mempool: *Mempool, storage: *Storage, p2p: *P2P, rpc: *RPC) !Node {
+ pub fn init(allocator: std.mem.Allocator, mempool: *Mempool, storage: *Storage, p2p: *P2P, rpc: *RPC) !Node {
  return Node{
  .allocator = allocator,
- .logger = logger,
  .mempool = mempool,
  .storage = storage,
  .p2p = p2p,
  .rpc = rpc,
  .stopped = false,
  .started = std.Thread.Condition{},
  .mutex = std.Thread.Mutex{},
- .ibd = IBD.init(p2p, logger),
+ .ibd = IBD.init(p2p),
  };
  }
 
@@ -69,7 +65,7 @@ pub const Node = struct {
  /// - `p2p`: P2P network handler.
  /// - `rpc`: RPC server.
  pub fn start(self: *Node) !void {
- self.logger.info("Starting btczee node...");
+ std.log.info("Starting btczee node...", .{});
  self.mutex.lock();
  defer self.mutex.unlock();
 
@@ -86,81 +82,8 @@ pub const Node = struct {
 
  // Main event loop
  while (!self.stopped) {
- self.mutex.unlock();
- self.logger.debug("Processing new blocks and transactions...");
- try self.processNewBlocksAndTransactions();
  std.time.sleep(5 * std.time.ns_per_s);
- self.mutex.lock();
  }
- self.logger.info("Node stopped");
- }
-
- fn processNewBlocksAndTransactions(self: *Node) !void {
- // Simulate processing of new blocks and transactions
- const new_block = try self.simulateNewBlock();
- try self.validateBlock(new_block);
- try self.addBlockToChain(new_block);
-
- var new_tx = try self.simulateNewTransaction();
- defer {
- new_tx.deinit();
- self.allocator.destroy(new_tx);
- }
- try self.validateTransaction(new_tx);
- try self.addTransactionToMempool(new_tx);
- }
-
- fn simulateNewBlock(self: *Node) !Block {
- _ = self;
- return Block{ .height = 0, .hash = [_]u8{0} ** 32 };
- }
-
- fn validateBlock(self: *Node, _: Block) !void {
- self.logger.debug("Validating block...");
- // Implement block validation logic here
- }
-
- fn addBlockToChain(self: *Node, _: Block) !void {
- self.logger.debug("Adding block to chain.");
- // Implement logic to add block to the chain
- }
-
- fn simulateNewTransaction(self: *Node) !*Transaction {
- var tx = try self.allocator.create(Transaction);
- errdefer self.allocator.destroy(tx);
-
- tx.* = try Transaction.init(self.allocator);
- errdefer tx.deinit();
-
- return tx;
- }
-
- fn validateTransaction(self: *Node, tx: *Transaction) !void {
- self.logger.debug("Validating transaction");
- // Implement transaction validation logic here
- _ = tx;
- }
-
- fn addTransactionToMempool(self: *Node, tx: *Transaction) !void {
- self.logger.debug("Adding transaction to mempool");
- _ = try self.mempool.addTransaction(tx, 42, 1000);
- }
-
- /// Stop the node.
- pub fn stop(self: *Node) void {
- self.mutex.lock();
- defer self.mutex.unlock();
-
- self.logger.info("Stopping node...");
- self.stopped = true;
- self.logger.info("Node stop signal sent");
- }
-
- /// Wait for the node to start.
- pub fn waitForStart(self: *Node) void {
- self.mutex.lock();
- defer self.mutex.unlock();
-
- self.started.wait(&self.mutex);
+ std.log.info("Node stopped", .{});
  }
 };