[avalanche] Add a getflakyproofs RPC to retrieve the list of flaky proofs

Summary:
This returns the list of proofs added via the setflakyproof RPC.

Depends on D16368.

Test Plan:
  ./test/functional/test_runner.py abc_mining_stakingrewards

Reviewers: #bitcoin_abc, PiRK

Reviewed By: #bitcoin_abc, PiRK

Differential Revision: https://reviews.bitcoinabc.org/D16369

Author: Fabcien

doc/release-notes.md

@@ -10,4 +10,5 @@ This release includes the following features and fixes:
  - The `getstakingreward` RPC now returns the `proofid` of the staking reward
    winner in addition to the payout script.
  - A new `setflakyproof` RPC instructs the node to also accept an alternative
-   staking reward winner when the flaky proof would have been selected.
+   staking reward winner when the flaky proof would have been selected. The list
+   of these flaky proofs can be retrieved via the `getflakyproofs` RPC.

src/avalanche/peermanager.h

@@ -443,6 +443,11 @@ class PeerManager {
 
     bool setFlaky(const ProofId &proofid);
     bool unsetFlaky(const ProofId &proofid);
+    template <typename Callable> void forEachFlakyProof(Callable &&func) const {
+        for (const auto &p : manualFlakyProofids) {
+            func(p);
+        }
+    }
 
     template <typename Callable>
     void updateAvailabilityScores(const double decayFactor,

src/rpc/avalanche.cpp

@@ -1669,6 +1669,79 @@ static RPCHelpMan setflakyproof() {
         }};
 }
 
+static RPCHelpMan getflakyproofs() {
+    return RPCHelpMan{
+        "getflakyproofs",
+        "List the flaky proofs (set via setflakyproof).\n",
+        {},
+        RPCResult{
+            RPCResult::Type::ARR,
+            "flaky_proofs",
+            "",
+            {{
+                RPCResult::Type::OBJ,
+                "proof",
+                "",
+                {{
+                    {RPCResult::Type::STR_HEX, "proofid",
+                     "The hex encoded proof identifier."},
+                    {RPCResult::Type::STR_AMOUNT, "staked_amount",
+                     "The proof stake amount, only present if the proof is "
+                     "known."},
+                    {RPCResult::Type::OBJ,
+                     "payout",
+                     "The proof payout script, only present if the proof is "
+                     "known.",
+                     {
+                         {RPCResult::Type::STR, "asm", "Decoded payout script"},
+                         {RPCResult::Type::STR_HEX, "hex",
+                          "Raw payout script in hex format"},
+                         {RPCResult::Type::STR, "type",
+                          "The output type (e.g. " + GetAllOutputTypes() + ")"},
+                         {RPCResult::Type::NUM, "reqSigs",
+                          "The required signatures"},
+                         {RPCResult::Type::ARR,
+                          "addresses",
+                          "",
+                          {
+                              {RPCResult::Type::STR, "address",
+                               "eCash address"},
+                          }},
+                     }},
+                }},
+            }},
+        },
+        RPCExamples{HelpExampleRpc("getflakyproofs", "")},
+        [&](const RPCHelpMan &self, const Config &config,
+            const JSONRPCRequest &request) -> UniValue {
+            NodeContext &node = EnsureAnyNodeContext(request.context);
+            avalanche::Processor &avalanche = EnsureAvalanche(node);
+
+            UniValue flakyProofs(UniValue::VARR);
+            avalanche.withPeerManager([&flakyProofs](
+                                          avalanche::PeerManager &pm) {
+                pm.forEachFlakyProof([&](const avalanche::ProofId &proofid) {
+                    UniValue flakyProof(UniValue::VOBJ);
+                    flakyProof.pushKV("proofid", proofid.GetHex());
+
+                    const auto proof = pm.getProof(proofid);
+                    if (proof) {
+                        flakyProof.pushKV("staked_amount",
+                                          proof->getStakedAmount());
+                        UniValue payout(UniValue::VOBJ);
+                        ScriptPubKeyToUniv(proof->getPayoutScript(), payout,
+                                           /*fIncludeHex=*/true);
+                        flakyProof.pushKV("payout", payout);
+                    }
+
+                    flakyProofs.push_back(flakyProof);
+                });
+            });
+
+            return flakyProofs;
+        }};
+}
+
 void RegisterAvalancheRPCCommands(CRPCTable &t) {
     // clang-format off
     static const CRPCCommand commands[] = {
@@ -1695,6 +1768,7 @@ void RegisterAvalancheRPCCommands(CRPCTable &t) {
         { "avalanche",         verifyavalancheproof,      },
         { "avalanche",         verifyavalanchedelegation, },
         { "avalanche",         setflakyproof,             },
+        { "avalanche",         getflakyproofs,            },
     };
     // clang-format on
 

test/functional/abc_mining_stakingrewards.py

@@ -328,15 +328,66 @@ def finalize_proof(proofid):
 
             proofids.append(last_proofid)
 
+            flaky_proofs = node.getflakyproofs()
+            assert_equal(len(flaky_proofs), len(proofids))
+            assert last_proofid in [p["proofid"] for p in flaky_proofs]
+
         for i in range(QUORUM_NODE_COUNT, 1, -1):
             reward = node.getstakingreward(tiphash)
             assert_equal(len(reward), i)
 
             last_proofid = proofids.pop()
             assert node.setflakyproof(last_proofid, False)
 
+            flaky_proofs = node.getflakyproofs()
+            assert_equal(len(flaky_proofs), len(proofids))
+            assert last_proofid not in [p["proofid"] for p in flaky_proofs]
+
         assert_equal(len(node.getstakingreward(tiphash)), 1)
 
+        # Add an unknown proof, check the stake amount and payout are not
+        # returned but the proofid always is
+        unknown_proofid = uint256_hex(0)
+        assert node.setflakyproof(unknown_proofid, True)
+        flaky_proofs = node.getflakyproofs()
+        assert_equal(len(flaky_proofs), 1)
+        flaky_proof = flaky_proofs[0]
+        assert_equal(
+            flaky_proof,
+            {
+                "proofid": unknown_proofid,
+            },
+        )
+        assert node.setflakyproof(unknown_proofid, False)
+        assert_equal(node.getflakyproofs(), [])
+
+        known_proofid = node.getstakingreward(blockhash=tiphash, recompute=True)[0][
+            "proofid"
+        ]
+        assert node.setflakyproof(known_proofid, True)
+        flaky_proofs = node.getflakyproofs()
+        assert_equal(len(flaky_proofs), 1)
+        flaky_proof = flaky_proofs[0]
+        staked_amount = node.decodeavalancheproof(
+            node.getrawavalancheproof(known_proofid)["proof"]
+        )["staked_amount"]
+        assert_equal(
+            flaky_proof,
+            {
+                "proofid": known_proofid,
+                "staked_amount": Decimal(staked_amount),
+                "payout": {
+                    "asm": "OP_DUP OP_HASH160 0000000000000000000000000000000000000000 OP_EQUALVERIFY OP_CHECKSIG",
+                    "hex": "76a914000000000000000000000000000000000000000088ac",
+                    "reqSigs": 1,
+                    "type": "pubkeyhash",
+                    "addresses": [ADDRESS_ECREG_UNSPENDABLE],
+                },
+            },
+        )
+        assert node.setflakyproof(known_proofid, False)
+        assert_equal(node.getflakyproofs(), [])
+
 
 if __name__ == "__main__":
     AbcMiningStakingRewardsTest().main()