Merge pull request #115 from frstrtr/dgb/pool-layer-port

dgb: Phase B pool wire-message layer (messages, share_messages) — Scrypt-only

Author: frstrtr

src/impl/dgb/messages.hpp

@@ -0,0 +1,193 @@
+#pragma once
+// V36 DGB-Scrypt pool wire-message layer — namespace-only divergence from
+// src/impl/ltc/messages.hpp; message format byte-parity with p2pool-merged-v36.
+
+#include "coin/block.hpp"
+#include "coin/transaction.hpp"
+
+#include <string>
+
+#include <core/message.hpp>
+#include <core/message_macro.hpp>
+#include <sharechain/share.hpp>
+
+namespace dgb
+{
+
+// message_version
+BEGIN_MESSAGE(version)
+    MESSAGE_FIELDS
+    (
+        (uint32_t, m_version),
+        (uint64_t, m_services),
+        (addr_t , m_addr_to),
+        (addr_t, m_addr_from),
+        (uint64_t, m_nonce),
+        (std::string, m_subversion),
+        (uint32_t, m_mode), //# always 1 for legacy compatibility
+        (uint256, m_best_share)
+    )
+    {
+        READWRITE(obj.m_version, obj.m_services, obj.m_addr_to, obj.m_addr_from, obj.m_nonce, obj.m_subversion, obj.m_mode, obj.m_best_share);
+    }
+END_MESSAGE()
+
+// message_ping
+BEGIN_MESSAGE(ping)
+    WITHOUT_MESSAGE_FIELDS() { }
+END_MESSAGE()
+
+// message_addrme
+BEGIN_MESSAGE(addrme)
+    MESSAGE_FIELDS
+    (
+        (uint16_t, m_port)
+    )
+    {
+        READWRITE(obj.m_port);
+    }
+END_MESSAGE()
+
+// message_getaddrs
+BEGIN_MESSAGE(getaddrs)
+    MESSAGE_FIELDS
+    (
+        (uint32_t, m_count)
+    )
+    {
+        READWRITE(obj.m_count);
+    }
+END_MESSAGE()
+
+// message_addrs
+BEGIN_MESSAGE(addrs)
+    MESSAGE_FIELDS
+    (
+        (std::vector<addr_record_t>, m_addrs)
+    )
+    {
+        READWRITE(obj.m_addrs);
+    }
+END_MESSAGE()
+
+// message_shares
+BEGIN_MESSAGE(shares)
+    MESSAGE_FIELDS
+    (
+        (std::vector<chain::RawShare>, m_shares)
+    )
+    {
+        READWRITE(obj.m_shares);
+    }
+END_MESSAGE()
+
+// message_sharereq
+BEGIN_MESSAGE(sharereq)
+    MESSAGE_FIELDS
+    (
+        (uint256, m_id),
+        (std::vector<uint256>, m_hashes),
+        (uint64_t, m_parents),
+        (std::vector<uint256>, m_stops)
+    )
+    {
+        READWRITE(obj.m_id, obj.m_hashes, VarInt(obj.m_parents), obj.m_stops);
+    }
+END_MESSAGE()
+
+enum ShareReplyResult
+{
+    good = 0,
+    too_long = 1,
+    unk2 = 2,
+    unk3 = 3,
+    unk4 = 4,
+    unk5 = 5,
+    unk6 = 6
+};
+
+// message_sharereply
+BEGIN_MESSAGE(sharereply)
+    MESSAGE_FIELDS
+    (
+        (uint256, m_id),
+        (ShareReplyResult, m_result),
+        (std::vector<chain::RawShare>, m_shares)
+    )
+    {
+        READWRITE(obj.m_id, Using<EnumType<CompactFormat>>(obj.m_result), obj.m_shares);
+    }
+END_MESSAGE()
+
+// message_bestblock
+BEGIN_MESSAGE(bestblock)
+    MESSAGE_FIELDS
+    (
+        (coin::BlockHeaderType, m_header)
+    )
+    {
+        READWRITE(obj.m_header);
+    }
+END_MESSAGE()
+
+// message_have_tx
+BEGIN_MESSAGE(have_tx)
+    MESSAGE_FIELDS
+    (
+        (std::vector<uint256>, m_tx_hashes)
+    )
+    {
+        READWRITE(obj.m_tx_hashes);
+    }
+END_MESSAGE()
+
+// message_losing_tx
+BEGIN_MESSAGE(losing_tx)
+    MESSAGE_FIELDS
+    (
+        (std::vector<uint256>, m_tx_hashes)
+    )
+    {
+        READWRITE(obj.m_tx_hashes);
+    }
+END_MESSAGE()
+
+// message_forget_tx
+BEGIN_MESSAGE(forget_tx)
+    MESSAGE_FIELDS
+    (
+        (std::vector<uint256>, m_tx_hashes)
+    )
+    {
+        READWRITE(obj.m_tx_hashes);
+    }
+END_MESSAGE()
+
+// message_remember_tx
+BEGIN_MESSAGE(remember_tx)
+    MESSAGE_FIELDS
+    (
+        (std::vector<uint256>, m_tx_hashes),
+        (std::vector<coin::MutableTransaction>, m_txs)
+    )
+    {
+        READWRITE(obj.m_tx_hashes, coin::TX_WITH_WITNESS(obj.m_txs));
+    }
+END_MESSAGE()
+
+using Handler = MessageHandler<
+    message_ping,
+    message_addrme,
+    message_getaddrs,
+    message_addrs,
+    message_shares,
+    message_sharereq,
+    message_sharereply,
+    message_bestblock,
+    message_have_tx,
+    message_losing_tx,
+    message_forget_tx,
+    message_remember_tx
+>;
+
+} // namespace dgb

src/impl/dgb/peer.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "coin/transaction.hpp"
+
+#include <chrono>
+#include <set>
+#include <optional>
+#include <core/uint256.hpp>
+
+namespace dgb
+{
+
+struct Peer
+{
+    std::optional<uint32_t> m_other_version;
+    std::string m_other_subversion;
+    uint64_t m_other_services;
+    uint64_t m_nonce;
+    std::chrono::steady_clock::time_point m_connected_at{std::chrono::steady_clock::now()};
+
+    std::set<uint256> m_remote_txs; // hashes
+    // int32_t remote_remembered_txs_size = 0;
+
+    std::map<uint256, coin::Transaction> m_remembered_txs;
+    // int32_t remembered_txs_size = 0;
+    // const int32_t max_remembered_txs_size = 25000000;
+};
+
+}; // namespace dgb