Add federated block-signing server implementation

src/federation.cpp

@@ -4,19 +4,29 @@
 
 #include <federation.h>
 
+#include <block_proof.h>
 #include <chainparams.h>
+#include <consensus/validation.h>
 #include <logging.h>
+#include <miner.h>
 #include <netaddress.h>
 #include <netbase.h>
 #include <net.h>
 #include <node/context.h>
+#include <pow.h>
+#include <primitives/block.h>
 #include <pubkey.h>
+#include <script/script.h>
+#include <script/standard.h>
 #include <streams.h>
 #include <sync.h>
 #include <threadinterrupt.h>
 #include <util/strencodings.h>
 #include <util/system.h>
+#include <validation.h>
 #ifdef ENABLE_WALLET
+#include <script/generic.hpp>
+#include <script/sign.h>
 #include <wallet/wallet.h>
 #endif // ENABLE_WALLET
 
@@ -227,6 +237,173 @@ static bool ReadFederationOpts() {
     return !errors;
 }
 
+//! The current block proposal, which is announced by the leader at the
+//! beginning of their round.
+static CBlock g_block_proposal;
+//! A collection of valid signatures for the proposed block of the current round.
+static std::map<CPubKey, std::vector<unsigned char>> g_block_sigs;
+
+static bool GenerateBlockProposal()
+{
+    const CChainParams& params = Params();
+    const Consensus::Params& consensusParams = params.GetConsensus();
+
+    // FIXME: Is this mandatory coinbase destination really necessary?  I recall
+    //        that this is from the Liquid codebase to ensure that Blockstream
+    //        collected fees on Liquid rather than the functionaries.  Is this
+    //        something we want to carry over to our chain?  If so, there are
+    //        probably better ways to accomplish fee capture.
+    CScript fee_destination_script = consensusParams.mandatory_coinbase_destination;
+    // If no forced fee destination script is specified in the chain parameters,
+    // then it is not consensus-controlled.  For testing purposes, we make it
+    // anyone-can-spend.  Let's change this later when we decide what to do
+    // about collecting fees.
+    if (fee_destination_script == CScript()) {
+        fee_destination_script = CScript() << OP_TRUE;
+    }
+
+    // The required_wait parameter is useful for preventing DoS of the
+    // federation itself.  By only using transactions which have been in the
+    // mempool for X seconds, we ensure that there is probably sufficient time
+    // for those transactions to have reached the other federation nodes before
+    // the start of the round.
+    std::chrono::seconds required_wait{5}; // FIXME: fetch this from config?
+
+    std::unique_ptr<CBlockTemplate> pblocktemplate(BlockAssembler(*g_context->mempool, params).CreateNewBlock(fee_destination_script, required_wait));
+    if (!pblocktemplate.get()) {
+        LogPrint(BCLog::FEDERATION, "Error generating block template proposal.\n");
+        return false;
+    }
+
+    CBlock &block = pblocktemplate->block;
+    {
+        // IncrementExtraNonce sets coinbase flags and builds the merkle tree
+        LOCK(cs_main);
+        unsigned int extra_nonce = 0;
+        IncrementExtraNonce(&block, g_context->chainman->ActiveTip(), extra_nonce);
+    }
+
+    LOCK(cs_block_signer);
+
+    using std::swap;
+    swap(g_block_proposal, block);
+    return true;
+}
+
+// Verifies that the proposed block is building off the tip and is a valid
+// block, then signs a relayable confirmation that we will sign this block and
+// accept it if the signing threshold is reached.
+static bool AcceptBlockProposal()
+{
+    const CChainParams& params = Params();
+
+    LOCK(cs_block_signer);
+    const CBlock& block = g_block_proposal;
+
+    LOCK(cs_main);
+
+    // Verify that this isn't a replay of a prior block.
+    BlockMap::iterator mi = g_context->chainman->BlockIndex().find(block.GetHash());
+    if (mi != g_context->chainman->BlockIndex().end()) {
+        LogPrint(BCLog::FEDERATION, "Already have proposed block: %s\n", block.GetHash().GetHex());
+        return false;
+    }
+
+    // TestBlockValidity only supports blocks built on the current Tip
+    CBlockIndex* const pindexPrev = g_context->chainman->ActiveTip();
+    if (block.hashPrevBlock != pindexPrev->GetBlockHash()) {
+        LogPrint(BCLog::FEDERATION, "Block proposal was not based on our best chain. (%s != %s)\n", block.hashPrevBlock.GetHex(), g_context->chainman->ActiveTip()->GetBlockHash().GetHex());
+        return false;
+    }
+
+    // Attempt validation of the block proposal, to make sure it would be
+    // accepted once it is signed.
+    BlockValidationState state;
+    bool res = TestBlockValidity(state, params, block, pindexPrev, false, true);
+    if (!res || !state.IsValid()) {
+        LogPrint(BCLog::FEDERATION, "Block proposal %s failed validation: %s (%d)\n", block.GetHash().GetHex(), state.GetRejectReason(), (int)state.GetResult());
+        return false;
+    }
+
+    return true;
+}
+
+static bool SignBlock()
+{
+    LOCK(cs_block_signer);
+    if (g_block_sigs.count(g_our_block_signing_key)) {
+        // Already signed.
+        return true;
+    }
+
+    // Generate the block signature
+    std::vector<unsigned char> sig;
+#ifdef ENABLE_WALLET
+    const CBlock& block = g_block_proposal;
+    SignatureData block_sigs;
+    std::shared_ptr<CWallet> pwallet = GetWalletForBlockSigning();
+    LegacyScriptPubKeyMan* spk_man = pwallet ? pwallet->GetOrCreateLegacyScriptPubKeyMan() : nullptr;
+    if (g_signed_blocks && spk_man) {
+        // Sign the block.
+        if (block.m_dynafed_params.IsNull()) {
+            GenericSignScript(*spk_man, block.GetBlockHeader(), block.proof.challenge, block_sigs, SCRIPT_NO_SIGHASH_BYTE /* additional_flags */);
+        } else {
+            GenericSignScript(*spk_man, block.GetBlockHeader(), block.m_dynafed_params.m_current.m_signblockscript, block_sigs, SCRIPT_VERIFY_NONE /* additional_flags */);
+        }
+        // Extract the signature
+        if (block_sigs.signatures.count(g_our_block_signing_key.GetID())) {
+            sig = block_sigs.signatures[g_our_block_signing_key.GetID()].second;
+        }
+    }
+#endif // ENABLE_WALLET
+    if (sig.empty()) {
+        LogPrint(BCLog::FEDERATION, "Block signature not generated.  Not sure what to do.\n");
+        return false;
+    }
+
+    g_block_sigs[g_our_block_signing_key] = sig;
+    return true;
+}
+
+static bool SubmitBlock()
+{
+    LOCK(cs_block_signer);
+    CBlock& block = g_block_proposal;
+
+    SignatureData block_sigs;
+    for (const auto& item : g_block_sigs) {
+        const CPubKey& pk = item.first;
+        const std::vector<unsigned char> sig = item.second;
+        block_sigs.signatures[pk.GetID()] = std::make_pair(pk, sig);
+    }
+
+    // Finalizes the signatures, has no access to keys
+    FillableSigningProvider keystore;
+    if (block.m_dynafed_params.IsNull()) {
+        SimpleSignatureCreator signature_creator(block.GetHash(), 0);
+        ProduceSignature(keystore, signature_creator, block.proof.challenge, block_sigs, SCRIPT_NO_SIGHASH_BYTE);
+        block.proof.solution = block_sigs.scriptSig;
+    } else {
+        SimpleSignatureCreator signature_creator(block.GetHash(), SIGHASH_ALL);
+        ProduceSignature(keystore, signature_creator, block.m_dynafed_params.m_current.m_signblockscript, block_sigs, SCRIPT_VERIFY_NONE);
+        block.m_signblock_witness = block_sigs.scriptWitness;
+    }
+
+    if (!CheckProof(block, Params().GetConsensus())) {
+        LogPrint(BCLog::FEDERATION, "Signatures incomplete; not submitting block.\n");
+        return false;
+    }
+
+    std::shared_ptr<const CBlock> shared_pblock = std::make_shared<const CBlock>(block);
+    if (!g_context->chainman->ProcessNewBlock(Params(), shared_pblock, true, nullptr)) {
+        LogPrint(BCLog::FEDERATION, "ProccessNewBlock failed for signe block.\n");
+        return false;
+    }
+
+    LogPrint(BCLog::FEDERATION, "Generated new block: %s\n", block.GetHash().GetHex());
+    return true;
+}
+
 /** Manages connections to other nodes in the block-signing federation, and
  ** performs this node's role in the block-signing protocol. */
 void ThreadBlockSigner(NodeContext& node)
@@ -258,7 +435,35 @@ void ThreadBlockSigner(NodeContext& node)
             break;
         }
 
-        LogPrint(BCLog::FEDERATION, "A real block signer would generate a block here.\n");
+        {
+            LOCK(cs_block_signer);
+            using std::swap;
+            CBlock empty;
+            swap(g_block_proposal, empty);
+            g_block_sigs.clear();
+        }
+
+        if (!GenerateBlockProposal()) {
+            LogPrint(BCLog::FEDERATION, "%s: Unable to generate block proposal.  Terminating round early.\n", __func__);
+            continue;
+        }
+
+        if (!AcceptBlockProposal()) {
+            LogPrint(BCLog::FEDERATION, "%s: Unable to validate our block proposal.  Terminating round early.\n", __func__);
+            continue;
+        }
+
+        if (!SignBlock()) {
+            LogPrint(BCLog::FEDERATION, "%s: Unable to sign block.  Terminating round early.\n", __func__);
+            continue;
+        }
+
+        if (!SubmitBlock()) {
+            LogPrint(BCLog::FEDERATION, "%s: Unable to submit block.  Terminating round early.\n", __func__);
+            continue;
+        }
+
+        LogPrint(BCLog::FEDERATION, "Generated new block: %s\n", g_block_proposal.GetHash().GetHex());
     }
 }