Resolve conflicting files

src/core/mempool.zig

@@ -1,6 +1,6 @@
 const std = @import("std");
 const Config = @import("../config/config.zig").Config;
-const tx = @import("../types/transaction.zig");
+const tx = @import("../types/lib.zig");
 
 /// Transaction descriptor containing a transaction in the mempool along with additional metadata.
 const TxDesc = struct {
@@ -74,15 +74,15 @@ pub const Mempool = struct {
  .added_time = std.time.milliTimestamp(),
  .height = height,
  .fee = fee,
- .fee_per_kb = @divTrunc(fee * 1000, @as(i64, @intCast(transaction.virtual_size()))),
+ .fee_per_kb = @divTrunc(fee * 1000, @as(i64, @intCast(transaction.hintEncodedLen()))),
  .starting_priority = try self.calculatePriority(transaction, height),
  };
 
  // Add the transaction to the pool
  try self.pool.put(hash, tx_desc);
 
  // Add the transaction outpoints to the outpoints map
- for (transaction.inputs.items) |input| {
+ for (transaction.inputs) |input| {
  try self.outpoints.put(input.previous_outpoint, transaction);
  }
 
@@ -102,7 +102,7 @@ pub const Mempool = struct {
 
  if (remove_redeemers) {
  // Remove any transactions which rely on this one
- for (tx_desc.tx.outputs.items, 0..) |_, i| {
+ for (tx_desc.tx.outputs, 0..) |_, i| {
  const outpoint = tx.OutPoint{ .hash = hash, .index = @as(u32, @intCast(i)) };
  if (self.outpoints.get(outpoint)) |redeemer| {
  self.removeTransaction(redeemer.hash(), true);
@@ -114,7 +114,7 @@ pub const Mempool = struct {
  _ = self.pool.remove(hash);
 
  // Remove the outpoints from the outpoints map
- for (tx_desc.tx.inputs.items) |input| {
+ for (tx_desc.tx.inputs) |input| {
  _ = self.outpoints.remove(input.previous_outpoint);
  }
 
@@ -136,7 +136,7 @@ pub const Mempool = struct {
  fn calculatePriority(self: *Mempool, transaction: *tx.Transaction, height: i32) !f64 {
  _ = self;
  var priority: f64 = 0;
- for (transaction.inputs.items) |input| {
+ for (transaction.inputs) |input| {
  // TODO: Fetch the UTXO from the chain
  _ = input;
  const utxo = .{ .value = 1000, .height = 100 };
@@ -145,7 +145,7 @@ pub const Mempool = struct {
  priority += @as(f64, @floatFromInt(input_value)) * input_age;
  }
 
- priority /= @as(f64, @floatFromInt(transaction.virtual_size()));
+ priority /= @as(f64, @floatFromInt(transaction.hintEncodedLen()));
 
  return priority;
  }
@@ -197,7 +197,7 @@ test "Mempool" {
  // Create a mock transaction
  var transaction = try tx.Transaction.init(allocator);
  defer transaction.deinit();
- try transaction.addInput(tx.OutPoint{ .hash = tx.Hash.zero(), .index = 0 });
+ try transaction.addInput(tx.OutPoint{ .hash = tx.Hash.newZeroed(), .index = 0 });
  try transaction.addOutput(50000, try tx.Script.init(allocator));
 
  // Add the transaction to the mempool

src/network/peer.zig

@@ -127,7 +127,7 @@ pub const Peer = struct {
  // TODO: Implement logic to filter transactions based on the received feerate
  },
  // TODO: handle other messages correctly
- else => |m| {
+ else => |*m| {
  std.log.info("Peer {any} sent a `{s}` message", .{ self.address, m.name() });
  continue;
  },

src/network/protocol/lib.zig

@@ -1,6 +1,5 @@
 pub const messages = @import("./messages/lib.zig");
 pub const NetworkAddress = @import("NetworkAddress.zig");
-pub const BlockHeader = @import("../../types/BlockHeader.zig").BlockHeader;
 /// Network services
 pub const ServiceFlags = struct {
  pub const NODE_NETWORK: u64 = 0x1;

src/network/protocol/messages/block.zig

@@ -0,0 +1,185 @@
+const std = @import("std");
+const native_endian = @import("builtin").target.cpu.arch.endian();
+const protocol = @import("../lib.zig");
+
+const ServiceFlags = protocol.ServiceFlags;
+
+const readBytesExact = @import("../../../util/mem/read.zig").readBytesExact;
+
+const Endian = std.builtin.Endian;
+const Sha256 = std.crypto.hash.sha2.Sha256;
+
+const CompactSizeUint = @import("bitcoin-primitives").types.CompatSizeUint;
+const Types = @import("../../../types/lib.zig");
+const Transaction = Types.Transaction;
+const BlockHeader = Types.BlockHeader;
+
+/// BlockMessage represents the "block" message
+///
+/// https://developer.bitcoin.org/reference/p2p_networking.html#block
+pub const BlockMessage = struct {
+ block_header: BlockHeader,
+ txns: []Transaction,
+
+ const Self = @This();
+
+ pub inline fn name() *const [12]u8 {
+ return protocol.CommandNames.BLOCK ++ [_]u8{0} ** 7;
+ }
+
+ pub fn checksum(self: BlockMessage) [4]u8 {
+ var digest: [32]u8 = undefined;
+ var hasher = Sha256.init(.{});
+ const writer = hasher.writer();
+ self.serializeToWriter(writer) catch unreachable; // Sha256.write is infaible
+ hasher.final(&digest);
+
+ Sha256.hash(&digest, &digest, .{});
+
+ return digest[0..4].*;
+ }
+
+ pub fn deinit(self: *BlockMessage, allocator: std.mem.Allocator) void {
+ for (self.txns) |*txn| {
+ txn.deinit();
+ }
+ allocator.free(self.txns);
+ }
+
+ /// Serialize the message as bytes and write them to the Writer.
+ ///
+ /// `w` should be a valid `Writer`.
+ pub fn serializeToWriter(self: *const Self, w: anytype) !void {
+ comptime {
+ if (!std.meta.hasFn(@TypeOf(w), "writeInt")) @compileError("Expects r to have fn 'writeInt'.");
+ if (!std.meta.hasFn(@TypeOf(w), "writeAll")) @compileError("Expects r to have fn 'writeAll'.");
+ }
+
+ try self.block_header.serializeToWriter(w);
+
+ try CompactSizeUint.new(self.txns.len).encodeToWriter(w);
+
+ for (self.txns) |txn| {
+ try txn.serializeToWriter(w);
+ }
+ }
+
+ /// Serialize a message as bytes and write them to the buffer.
+ ///
+ /// buffer.len must be >= than self.hintSerializedLen()
+ pub fn serializeToSlice(self: *const Self, buffer: []u8) !void {
+ var fbs = std.io.fixedBufferStream(buffer);
+ try self.serializeToWriter(fbs.writer());
+ }
+
+ /// Serialize a message as bytes and return them.
+ pub fn serialize(self: *const BlockMessage, allocator: std.mem.Allocator) ![]u8 {
+ const serialized_len = self.hintSerializedLen();
+
+ const ret = try allocator.alloc(u8, serialized_len);
+ errdefer allocator.free(ret);
+
+ try self.serializeToSlice(ret);
+
+ return ret;
+ }
+
+ pub fn deserializeReader(allocator: std.mem.Allocator, r: anytype) !BlockMessage {
+ comptime {
+ if (!std.meta.hasFn(@TypeOf(r), "readInt")) @compileError("Expects r to have fn 'readInt'.");
+ if (!std.meta.hasFn(@TypeOf(r), "readNoEof")) @compileError("Expects r to have fn 'readNoEof'.");
+ if (!std.meta.hasFn(@TypeOf(r), "readAll")) @compileError("Expects r to have fn 'readAll'.");
+ if (!std.meta.hasFn(@TypeOf(r), "readByte")) @compileError("Expects r to have fn 'readByte'.");
+ }
+
+ var block_message: Self = undefined;
+
+ block_message.block_header = try BlockHeader.deserializeReader(r);
+
+ const txns_count = try CompactSizeUint.decodeReader(r);
+
+ block_message.txns = try allocator.alloc(Transaction, txns_count.value());
+ errdefer allocator.free(block_message.txns);
+
+ var i: usize = 0;
+ while (i < txns_count.value()) : (i += 1) {
+ const tx = try Transaction.deserializeReader(allocator, r);
+ block_message.txns[i] = tx;
+ }
+
+ return block_message;
+ }
+
+ /// Deserialize bytes into a `VersionMessage`
+ pub fn deserializeSlice(allocator: std.mem.Allocator, bytes: []const u8) !Self {
+ var fbs = std.io.fixedBufferStream(bytes);
+ return try Self.deserializeReader(allocator, fbs.reader());
+ }
+
+ pub fn hintSerializedLen(self: BlockMessage) usize {
+ const header_length = BlockHeader.serializedLen();
+ const txs_number_length = CompactSizeUint.new(self.txns.len).hint_encoded_len();
+ var txs_length: usize = 0;
+ for (self.txns) |txn| {
+ txs_length += txn.hintEncodedLen();
+ }
+ return header_length + txs_number_length + txs_length;
+ }
+};
+
+// TESTS
+
+test "ok_full_flow_BlockMessage" {
+ const OpCode = @import("../../../script/opcodes/constant.zig").Opcode;
+ const allocator = std.testing.allocator;
+ const OutPoint = Types.OutPoint;
+ const Hash = Types.Hash;
+ const Script = Types.Script;
+
+ {
+ var tx = try Transaction.init(allocator);
+
+ try tx.addInput(OutPoint{ .hash = Hash.newZeroed(), .index = 0 });
+
+ {
+ var script_pubkey = try Script.init(allocator);
+ defer script_pubkey.deinit();
+ try script_pubkey.push(&[_]u8{ OpCode.OP_DUP.toBytes(), OpCode.OP_0.toBytes(), OpCode.OP_1.toBytes() });
+ try tx.addOutput(50000, script_pubkey);
+ }
+
+ var txns = try allocator.alloc(Transaction, 1);
+ // errdefer allocator.free(txns);
+ txns[0] = tx;
+
+ var msg = BlockMessage{
+ .block_header = BlockHeader{
+ .version = 1,
+ .prev_block = [_]u8{0} ** 32,
+ .merkle_root = [_]u8{0} ** 32,
+ .timestamp = 1,
+ .nbits = 1,
+ .nonce = 1,
+ },
+ .txns = txns,
+ };
+ defer msg.deinit(allocator);
+
+ const payload = try msg.serialize(allocator);
+ defer allocator.free(payload);
+ var deserialized_msg = try BlockMessage.deserializeSlice(allocator, payload);
+ defer deserialized_msg.deinit(allocator);
+
+ try std.testing.expectEqual(msg.block_header.version, deserialized_msg.block_header.version);
+ try std.testing.expect(std.mem.eql(u8, &msg.block_header.prev_block, &deserialized_msg.block_header.prev_block));
+ try std.testing.expect(std.mem.eql(u8, &msg.block_header.merkle_root, &deserialized_msg.block_header.merkle_root));
+ try std.testing.expect(msg.block_header.timestamp == deserialized_msg.block_header.timestamp);
+ try std.testing.expect(msg.block_header.nbits == deserialized_msg.block_header.nbits);
+ try std.testing.expect(msg.block_header.nonce == deserialized_msg.block_header.nonce);
+
+ for (msg.txns, 0..) |txn, i| {
+ const deserialized_txn = deserialized_msg.txns[i];
+ try std.testing.expect(txn.eql(deserialized_txn));
+ }
+ }
+}

src/network/protocol/messages/filterload.zig

@@ -3,6 +3,7 @@ const protocol = @import("../lib.zig");
 
 const Sha256 = std.crypto.hash.sha2.Sha256;
 const CompactSizeUint = @import("bitcoin-primitives").types.CompatSizeUint;
+const genericChecksum = @import("lib.zig").genericChecksum;
 
 /// FilterLoadMessage represents the "filterload" message
 ///
@@ -21,15 +22,7 @@ pub const FilterLoadMessage = struct {
 
  /// Returns the message checksum
  pub fn checksum(self: *const Self) [4]u8 {
- var digest: [32]u8 = undefined;
- var hasher = Sha256.init(.{});
- const writer = hasher.writer();
- self.serializeToWriter(writer) catch unreachable; // Sha256.write is infaible
- hasher.final(&digest);
-
- Sha256.hash(&digest, &digest, .{});
-
- return digest[0..4].*;
+ return genericChecksum(self);
  }
 
  /// Serialize the message as bytes and write them to the Writer.

src/network/protocol/messages/getblocks.zig

@@ -26,7 +26,7 @@ pub const GetblocksMessage = struct {
  }
 
  /// Free the `header_hashes`
- pub fn deinit(self: GetblocksMessage, allocator: std.mem.Allocator) void {
+ pub fn deinit(self: *GetblocksMessage, allocator: std.mem.Allocator) void {
  allocator.free(self.header_hashes);
  }