Skip to content

Commit 5931990

Browse files
frstrtrfrstrtr
authored
Merge pull request #166 from frstrtr/dgb/won-block-broadcaster
dgb(#82): dual-path won-block broadcaster + dispatch contract test
2 parents 0c28591 + 984eb3c commit 5931990

5 files changed

Lines changed: 351 additions & 0 deletions

File tree

‎.github/workflows/build.yml‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -71,6 +71,7 @@ jobs:
7171
dgb_gentx_coinbase_test nmc_auxpow_merkle_test dgb_gentx_share_path_test dgb_other_tx_resolver_test \
7272
dgb_other_tx_assembler_test dgb_reconstruct_won_block_test dgb_gentx_unpack_test \
7373
rpc_request_test softfork_check_test genesis_check_test algo_select_test digishield_walk_test header_chain_test \
74+
dgb_coin_node_seam_test dgb_block_broadcast_test \
7475
v37_test \
7576
-j$(nproc)
7677
@@ -203,6 +204,7 @@ jobs:
203204
dgb_gentx_coinbase_test nmc_auxpow_merkle_test dgb_gentx_share_path_test dgb_other_tx_resolver_test \
204205
dgb_other_tx_assembler_test dgb_reconstruct_won_block_test dgb_gentx_unpack_test \
205206
rpc_request_test softfork_check_test genesis_check_test algo_select_test digishield_walk_test header_chain_test \
207+
dgb_coin_node_seam_test dgb_block_broadcast_test \
206208
test_coin_broadcaster test_multiaddress_pplns test_pplns_stress \
207209
v37_test \
208210
-j$(nproc)

‎src/impl/dgb/coin/block_broadcast.hpp‎

Lines changed: 106 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,106 @@
1+
#pragma once
2+
// ---------------------------------------------------------------------------
3+
// dgb::coin::broadcast_won_block -- the DGB dual-path won-block dispatcher.
4+
//
5+
// 1:1 contract mirror of bch::coin::EmbeddedDaemon::broadcast_won_block
6+
// (src/impl/bch/coin/embedded_daemon.hpp @90a35536): on a won block it fires
7+
// BOTH broadcast sinks --
8+
// PRIMARY : embedded P2P relay (fastest propagation), supplied by the
9+
// run-loop as a sink fn (DGB has no submit_block_p2p_raw on
10+
// coin::Node yet -- the EmbeddedDaemon/NodeP2P port binds this).
11+
// FALLBACK : external digibyted submitblock via the CoinNode seam
12+
// (core::coin::ICoinNode::submit_block_hex) -- fired ALWAYS, per
13+
// the broadcaster-gate dual-path rule, NOT a P2P-only path with
14+
// RPC as a catch. A duplicate on the RPC leg after a P2P accept
15+
// still proves both paths reached the node; landed_first records
16+
// which won the race. ignore_failure=true so an already-have on
17+
// the fallback never masks the P2P win.
18+
//
19+
// This is the sink the DGB pool node wires tracker().m_on_block_found to so an
20+
// in-operation win emits immediately (the remaining #82 run-loop slice; the
21+
// pool-node wiring mirrors bch @9fed4955). Decoupled from the (not-yet-ported)
22+
// DGB EmbeddedDaemon by taking the P2P sink as a std::function and the seam as
23+
// an ICoinNode*, so it is build-verifiable now and the run-loop binds the live
24+
// objects when NodeP2P lands.
25+
//
26+
// DGB-Scrypt is a STANDALONE parent in the V36 default build -- no merged-
27+
// coinbase leg (DOGE aux is -DAUX_DOGE=ON stretch, a separate parent path).
28+
// p2pool-merged-v36 surface: NONE -- block dispatch only, no PoW hash, share
29+
// format, coinbase commitment, or PPLNS math is touched. Per-coin isolation:
30+
// src/impl/dgb/coin/ only.
31+
// ---------------------------------------------------------------------------
32+
33+
#include <cstdint>
34+
#include <functional>
35+
#include <string>
36+
#include <vector>
37+
38+
#include <core/coin/node_iface.hpp>
39+
#include <core/log.hpp>
40+
41+
namespace dgb
42+
{
43+
namespace coin
44+
{
45+
46+
// Embedded P2P relay sink: the run-loop binds this to NodeP2P::submit_block_p2p_raw
47+
// once the embedded daemon is stood up. Empty == no embedded P2P sink present.
48+
using P2pRelaySink = std::function<void(const std::vector<unsigned char>&)>;
49+
50+
// Outcome of a won-block broadcast: which of the two sinks fired and whether
51+
// the external node acked. P2P is primary; the submitblock RPC fallback fires
52+
// ALWAYS (dual-path rule). landed_first records which path won the race.
53+
struct BlockBroadcast
54+
{
55+
bool p2p_sent = false; // embedded P2P relay issued (sink present)
56+
bool rpc_ok = false; // submitblock returned ok OR duplicate
57+
const char* landed_first = "none"; // "p2p" | "rpc" | "none"
58+
bool any() const { return p2p_sent || rpc_ok; }
59+
};
60+
61+
// Fire a won block down BOTH broadcast paths. `block_bytes` is the pre-
62+
// serialized block blob the embedded P2P relay sends; `block_hex` is the same
63+
// block hex for the external submitblock fallback. `p2p_relay` may be empty
64+
// (no embedded sink yet); `seam` may be null or RPC-less -- each leg is guarded
65+
// so the dispatcher never throws or dereferences a null sink.
66+
inline BlockBroadcast broadcast_won_block(const P2pRelaySink& p2p_relay,
67+
core::coin::ICoinNode* seam,
68+
const std::vector<unsigned char>& block_bytes,
69+
const std::string& block_hex)
70+
{
71+
BlockBroadcast r;
72+
73+
// PRIMARY: embedded P2P relay (fastest propagation).
74+
if (p2p_relay) {
75+
p2p_relay(block_bytes);
76+
r.p2p_sent = true;
77+
r.landed_first = "p2p";
78+
LOG_INFO << "[EMB-DGB] won-block P2P relay issued (" << block_bytes.size()
79+
<< " bytes) -- primary path.";
80+
} else {
81+
LOG_WARNING << "[EMB-DGB] won-block: no embedded P2P sink; relying on RPC fallback.";
82+
}
83+
84+
// FALLBACK (always fired): external digibyted submitblock. A duplicate here
85+
// after a P2P accept is success, not failure -- ignore_failure=true so a
86+
// duplicate/already-have does not mask the P2P win.
87+
if (seam && seam->has_rpc()) {
88+
r.rpc_ok = seam->submit_block_hex(block_hex, /*ignore_failure=*/true);
89+
if (r.rpc_ok && !r.p2p_sent) r.landed_first = "rpc";
90+
LOG_INFO << "[EMB-DGB] won-block submitblock RPC fallback "
91+
<< (r.rpc_ok ? "ok/duplicate" : "no-ack") << ".";
92+
} else {
93+
LOG_WARNING << "[EMB-DGB] won-block: no external digibyted-RPC fallback sink wired.";
94+
}
95+
96+
if (!r.any())
97+
LOG_ERROR << "[EMB-DGB] won-block had NEITHER broadcast sink -- block NOT relayed!";
98+
else
99+
LOG_INFO << "[EMB-DGB] won-block broadcast: p2p=" << (r.p2p_sent ? "sent" : "off")
100+
<< " rpc=" << (r.rpc_ok ? "ok" : "off")
101+
<< " landed_first=" << r.landed_first << ".";
102+
return r;
103+
}
104+
105+
} // namespace coin
106+
} // namespace dgb

‎src/impl/dgb/test/CMakeLists.txt‎

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -135,4 +135,29 @@ if (BUILD_TESTING AND GTest_FOUND)
135135
GTest::gtest_main GTest::gtest nlohmann_json::nlohmann_json)
136136
gtest_add_tests(${dgb_guard} "" AUTO)
137137
endforeach()
138+
# --- #82 broadcaster-gate: CoinNode submit/seam contract -----------------
139+
# Links the dgb OBJECT lib (coin_node.cpp) like dgb_share_test so the live
140+
# CoinNode::submit_block_hex !m_rpc guard + embedded WorkView slice are
141+
# build- and run-verified. Pins the external-digibyted RPC fallback half of
142+
# the won-block dispatch (web_server -> ICoinNode::submit_block_hex).
143+
add_executable(dgb_coin_node_seam_test coin_node_seam_test.cpp)
144+
target_link_libraries(dgb_coin_node_seam_test PRIVATE
145+
GTest::gtest_main GTest::gtest
146+
core dgb
147+
c2pool_payout c2pool_merged_mining c2pool_hashrate c2pool_storage
148+
dgb_coin pool sharechain)
149+
gtest_add_tests(dgb_coin_node_seam_test "" AUTO)
150+
151+
# --- #82 dual-path won-block broadcaster contract ----------------------
152+
# Header-only contract test for coin/block_broadcast.hpp (the dispatcher the
153+
# run-loop wires tracker().m_on_block_found to). Links core for the ICoinNode
154+
# seam + LOG_* symbols; needs no dgb OBJECT lib (uses a fake ICoinNode).
155+
add_executable(dgb_block_broadcast_test block_broadcast_test.cpp)
156+
target_link_libraries(dgb_block_broadcast_test PRIVATE
157+
GTest::gtest_main GTest::gtest
158+
core dgb
159+
c2pool_payout c2pool_merged_mining c2pool_hashrate c2pool_storage
160+
dgb_coin pool sharechain)
161+
gtest_add_tests(dgb_block_broadcast_test "" AUTO)
162+
138163
endif()

‎src/impl/dgb/test/block_broadcast_test.cpp‎

Lines changed: 124 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,124 @@
1+
// ---------------------------------------------------------------------------
2+
// dgb::coin::broadcast_won_block dual-path dispatcher test (#82 broadcaster-
3+
// gate, dispatcher half).
4+
//
5+
// Offline contract slice mirroring src/impl/bch/test/embedded_block_broadcast_test.cpp
6+
// (@90a35536). Locks the dual-path rule the DGB run-loop depends on when it
7+
// wires tracker().m_on_block_found to this dispatcher: BOTH the embedded P2P
8+
// relay (PRIMARY) and the external digibyted submitblock (FALLBACK, fired
9+
// ALWAYS) are attempted, each leg is guarded, landed_first records the race
10+
// winner, and with NEITHER sink live the call is a safe no-op (any()=false,
11+
// no throw). Uses a fake ICoinNode so the dispatch contract is verified without
12+
// the real NodeRPC transport (deferred). p2pool-merged-v36 surface: NONE.
13+
//
14+
// MUST appear in BOTH test/CMakeLists.txt AND the build.yml --target allowlist
15+
// or it becomes a #143-style NOT_BUILT sentinel that reds master.
16+
// ---------------------------------------------------------------------------
17+
18+
#include <gtest/gtest.h>
19+
20+
#include <string>
21+
#include <vector>
22+
23+
#include "../coin/block_broadcast.hpp"
24+
25+
namespace {
26+
27+
// Controllable external-RPC seam: lets each case set has_rpc() and the
28+
// submit_block_hex() ack independently, and records the call so the "always
29+
// fired" rule is observable.
30+
class FakeSeam : public core::coin::ICoinNode {
31+
public:
32+
bool rpc_present = true;
33+
bool submit_ack = true;
34+
int submit_calls = 0;
35+
bool last_ignore_failure = false;
36+
37+
core::coin::WorkView get_work_view() override { return {}; }
38+
39+
bool submit_block_hex(const std::string&, bool ignore_failure) override {
40+
++submit_calls;
41+
last_ignore_failure = ignore_failure;
42+
return submit_ack;
43+
}
44+
45+
bool is_embedded() const override { return false; }
46+
bool has_rpc() const override { return rpc_present; }
47+
};
48+
49+
const std::vector<unsigned char> kBytes(120, 0x42);
50+
const std::string kHex = "00112233";
51+
52+
} // namespace
53+
54+
// 1) NEITHER sink live -> safe no-op: any()=false, landed_first="none", no throw,
55+
// and a null seam is never dereferenced.
56+
TEST(DgbBlockBroadcast, NoSinkLiveIsSafeNoOp) {
57+
auto r = dgb::coin::broadcast_won_block(/*p2p_relay=*/{}, /*seam=*/nullptr,
58+
kBytes, kHex);
59+
EXPECT_FALSE(r.p2p_sent);
60+
EXPECT_FALSE(r.rpc_ok);
61+
EXPECT_FALSE(r.any());
62+
EXPECT_STREQ(r.landed_first, "none");
63+
}
64+
65+
// 2) P2P-only: relay sink present, no RPC -> p2p wins, fallback skipped cleanly.
66+
TEST(DgbBlockBroadcast, P2pOnly) {
67+
bool relayed = false;
68+
std::vector<unsigned char> seen;
69+
auto relay = [&](const std::vector<unsigned char>& b) { relayed = true; seen = b; };
70+
71+
FakeSeam seam; seam.rpc_present = false;
72+
auto r = dgb::coin::broadcast_won_block(relay, &seam, kBytes, kHex);
73+
74+
EXPECT_TRUE(relayed);
75+
EXPECT_EQ(seen, kBytes);
76+
EXPECT_TRUE(r.p2p_sent);
77+
EXPECT_FALSE(r.rpc_ok);
78+
EXPECT_TRUE(r.any());
79+
EXPECT_STREQ(r.landed_first, "p2p");
80+
EXPECT_EQ(seam.submit_calls, 0); // no RPC sink -> fallback not attempted
81+
}
82+
83+
// 3) RPC-only: no embedded P2P sink, RPC acks -> fallback wins the race.
84+
TEST(DgbBlockBroadcast, RpcOnly) {
85+
FakeSeam seam; seam.rpc_present = true; seam.submit_ack = true;
86+
auto r = dgb::coin::broadcast_won_block(/*p2p_relay=*/{}, &seam, kBytes, kHex);
87+
88+
EXPECT_FALSE(r.p2p_sent);
89+
EXPECT_TRUE(r.rpc_ok);
90+
EXPECT_TRUE(r.any());
91+
EXPECT_STREQ(r.landed_first, "rpc");
92+
EXPECT_EQ(seam.submit_calls, 1);
93+
EXPECT_TRUE(seam.last_ignore_failure); // duplicate must not mask a P2P win
94+
}
95+
96+
// 4) DUAL-PATH: both sinks live -> p2p wins landed_first, but the RPC fallback
97+
// STILL fires (the always-fire rule), and a duplicate ack there is success.
98+
TEST(DgbBlockBroadcast, DualPathAlwaysFiresFallback) {
99+
bool relayed = false;
100+
auto relay = [&](const std::vector<unsigned char>&) { relayed = true; };
101+
102+
FakeSeam seam; seam.rpc_present = true; seam.submit_ack = true;
103+
auto r = dgb::coin::broadcast_won_block(relay, &seam, kBytes, kHex);
104+
105+
EXPECT_TRUE(relayed);
106+
EXPECT_TRUE(r.p2p_sent);
107+
EXPECT_TRUE(r.rpc_ok); // fallback fired even though P2P won
108+
EXPECT_EQ(seam.submit_calls, 1); // ALWAYS-fired, not P2P-only catch
109+
EXPECT_STREQ(r.landed_first, "p2p"); // primary won the race
110+
}
111+
112+
// 5) Both sinks present but RPC no-acks (rejected): p2p still carried the block,
113+
// rpc_ok=false, any()=true (P2P leg succeeded).
114+
TEST(DgbBlockBroadcast, FallbackNoAckDoesNotMaskP2p) {
115+
auto relay = [&](const std::vector<unsigned char>&) {};
116+
FakeSeam seam; seam.rpc_present = true; seam.submit_ack = false;
117+
auto r = dgb::coin::broadcast_won_block(relay, &seam, kBytes, kHex);
118+
119+
EXPECT_TRUE(r.p2p_sent);
120+
EXPECT_FALSE(r.rpc_ok);
121+
EXPECT_TRUE(r.any());
122+
EXPECT_STREQ(r.landed_first, "p2p");
123+
EXPECT_EQ(seam.submit_calls, 1);
124+
}

‎src/impl/dgb/test/coin_node_seam_test.cpp‎

Lines changed: 94 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,94 @@
1+
// ---------------------------------------------------------------------------
2+
// dgb::coin::CoinNode seam-contract test (#82 broadcaster-gate, RPC-fallback
3+
// half).
4+
//
5+
// Locks the embedded-primary / external-RPC-fallback contract of the DGB
6+
// CoinNode seam (core::coin::ICoinNode) that the won-block dispatch depends on.
7+
// web_server.cpp submits a solved block through exactly this seam:
8+
// m_coin_node->submit_block_hex(hex, false) (core/web_server.cpp)
9+
// which forwards to NodeRPC::submitblock (the external-digibyted fallback that
10+
// MUST persist alongside the embedded path). This test pins the three
11+
// invariants that path relies on, so a regression here is caught before it can
12+
// silently break block submission:
13+
// 1. no work source at all -> empty WorkView, no throw
14+
// 2. embedded present, no RPC -> WorkView sourced from embedded;
15+
// is_embedded()=true, has_rpc()=false
16+
// 3. submit_block_hex w/ no RPC sink -> false (the !m_rpc guard, NOT a throw
17+
// and NOT a crash dereferencing null)
18+
//
19+
// SCOPE: the no-RPC guard + embedded WorkView slice only. The LIVE submitblock
20+
// RPC call and the m_on_block_found tracker callback are wired by the DGB
21+
// run-loop standup (NodeBridge + web_server; main_dgb.cpp is selftest-only
22+
// today) -- that is the remaining #82 slice and is NOT exercised here (rpc=
23+
// nullptr in every case). p2pool-merged-v36 surface: NONE (pure local seam).
24+
//
25+
// Mirrors src/impl/bch/test/coin_node_seam_test.cpp; written gtest-style to
26+
// match the sibling dgb tests (gtest_add_tests AUTO). MUST appear in BOTH the
27+
// test/CMakeLists.txt registration AND the build.yml --target allowlist or it
28+
// becomes a #143-style NOT_BUILT sentinel that reds master.
29+
// ---------------------------------------------------------------------------
30+
31+
#include <gtest/gtest.h>
32+
33+
#include <string>
34+
35+
#include "../coin/coin_node.hpp"
36+
37+
namespace {
38+
39+
// Minimal embedded work source: returns a recognisable WorkData so the test can
40+
// prove the seam moved THIS object's agnostic slice into the WorkView.
41+
class FakeEmbedded : public dgb::coin::CoinNodeInterface {
42+
public:
43+
int calls = 0;
44+
45+
dgb::coin::rpc::WorkData getwork() override {
46+
++calls;
47+
dgb::coin::rpc::WorkData wd;
48+
wd.m_data = nlohmann::json{{"marker", "embedded-dgb"}};
49+
wd.m_hashes.push_back(uint256(static_cast<uint64_t>(0xab)));
50+
wd.m_latency = 42;
51+
return wd;
52+
}
53+
54+
nlohmann::json getblockchaininfo() override { return nlohmann::json::object(); }
55+
bool is_synced() const override { return true; }
56+
};
57+
58+
} // namespace
59+
60+
// 1) No work source configured -> empty view, no throw (1:1 btc/bch/ltc ref).
61+
TEST(DgbCoinNodeSeam, NoSourceEmptyView) {
62+
dgb::coin::CoinNode n(nullptr, nullptr);
63+
EXPECT_FALSE(n.is_embedded());
64+
EXPECT_FALSE(n.has_rpc());
65+
core::coin::WorkView v = n.get_work_view();
66+
EXPECT_TRUE(v.m_data.is_null() || v.m_data.empty());
67+
EXPECT_TRUE(v.m_hashes.empty());
68+
EXPECT_EQ(v.m_latency, 0);
69+
}
70+
71+
// 2) Embedded preferred, no RPC fallback wired -> view comes from embedded.
72+
TEST(DgbCoinNodeSeam, EmbeddedSourcedView) {
73+
FakeEmbedded emb;
74+
dgb::coin::CoinNode n(&emb, /*rpc=*/nullptr);
75+
EXPECT_TRUE(n.is_embedded());
76+
EXPECT_FALSE(n.has_rpc());
77+
core::coin::WorkView v = n.get_work_view();
78+
EXPECT_EQ(emb.calls, 1); // embedded WAS the source
79+
ASSERT_TRUE(v.m_data.contains("marker"));
80+
EXPECT_EQ(v.m_data["marker"], "embedded-dgb");
81+
EXPECT_EQ(v.m_hashes.size(), 1u);
82+
EXPECT_EQ(v.m_latency, 42);
83+
}
84+
85+
// 3) No RPC sink -> submit_block_hex returns false (the !m_rpc guard), not a
86+
// throw and not a null-deref crash. This is the won-block fallback contract.
87+
TEST(DgbCoinNodeSeam, SubmitNoRpcReturnsFalse) {
88+
FakeEmbedded emb;
89+
dgb::coin::CoinNode n(&emb, /*rpc=*/nullptr);
90+
EXPECT_FALSE(n.submit_block_hex("00", /*ignore_failure=*/true));
91+
92+
dgb::coin::CoinNode bare(nullptr, nullptr);
93+
EXPECT_FALSE(bare.submit_block_hex("00", /*ignore_failure=*/false));
94+
}

0 commit comments

Comments
 (0)