diff --git a/contrib/federation/blocksign.sh b/contrib/federation/blocksign.sh
new file mode 100755
index 0000000000..87a179c730
--- /dev/null
+++ b/contrib/federation/blocksign.sh
@@ -0,0 +1,96 @@
+#!/bin/bash
+
+BIN=$(dirname $0)/../../src/elements
+
+ADDR0=2dg8TR1BtYs1BJPLdjSpWnhDgadEDXxKRM7
+PK0=02febf482b566f37b7b8a624e3bcb708ff745daa37389bcc381ea207efaa84d85c
+SK0=cPpQ1dgHCiaPKmpCeuRBECfwaa5cJCj39n6j8vLmZ8ZgLJ6NQ4ce
+
+ADDR1=2dmHcVLR9xCbCnkVGAAaJyps5Ak7hPkNEWu
+PK1=039a70503f82b475f0388a0a187b4bef35f54d4e63e6ea235790f03ac070750b93
+SK1=cStpof1xJ6yvGhxMmxKrJPfV8D8V8VGgftJPffyZk8eaJmFWZMFR
+
+ADDR2=2dZwNCpB4xHqhexTavHdFXHjRRCLALpkYmm
+PK2=022ceed2aa5b56abf6765135daf8970bd0be44e890d0b493eb6efb824be6c29197
+SK2=cVNMk5uTaAFVRKQvEwSxd6hnuQdDoXJ5qpGsvVchmESuy6s9MPcd
+
+# 2-of-3 multisig
+SCRIPT=5221${PK0}21${PK1}21${PK2}53ae
+
+TMP=/tmp/blocksign.$$
+PORT0=38401
+PORT1=38402
+PORT2=38403
+RPCPORT0=38501
+RPCPORT1=38502
+RPCPORT2=38503
+
+echo Setting up nodes...
+mkdir -p ${TMP}/node0
+echo "validatepegin=0"                   > ${TMP}/node0/elements.conf
+echo "con_signed_blocks=1"              >> ${TMP}/node0/elements.conf
+echo "signblockscript=${SCRIPT}"        >> ${TMP}/node0/elements.conf
+echo "con_max_block_sig_size=150"       >> ${TMP}/node0/elements.conf
+echo "con_dyna_deploy_start=9999999999" >> ${TMP}/node0/elements.conf
+echo "blocksigner=1"                    >> ${TMP}/node0/elements.conf
+echo "debug=federation"                 >> ${TMP}/node0/elements.conf
+echo "debug=net"                        >> ${TMP}/node0/elements.conf
+mkdir -p ${TMP}/node1
+cp ${TMP}/node0/elements.conf \
+   ${TMP}/node1/elements.conf
+mkdir -p ${TMP}/node2
+cp ${TMP}/node0/elements.conf \
+   ${TMP}/node2/elements.conf
+echo "elementsregtest.port=${PORT0}"       >> ${TMP}/node0/elements.conf
+echo "elementsregtest.port=${PORT1}"       >> ${TMP}/node1/elements.conf
+echo "elementsregtest.port=${PORT2}"       >> ${TMP}/node2/elements.conf
+echo "elementsregtest.rpcport=${RPCPORT0}" >> ${TMP}/node0/elements.conf
+echo "elementsregtest.rpcport=${RPCPORT1}" >> ${TMP}/node1/elements.conf
+echo "elementsregtest.rpcport=${RPCPORT2}" >> ${TMP}/node2/elements.conf
+
+${BIN}d -datadir=${TMP}/node0 -chain=elementsregtest -daemon
+${BIN}d -datadir=${TMP}/node1 -chain=elementsregtest -daemon
+${BIN}d -datadir=${TMP}/node2 -chain=elementsregtest -daemon
+sleep 1
+
+echo Importing block-signing keys...
+${BIN}-cli -datadir=${TMP}/node0 -chain=elementsregtest createwallet "" >/dev/null
+${BIN}-cli -datadir=${TMP}/node0 -chain=elementsregtest importprivkey ${SK0}
+${BIN}-cli -datadir=${TMP}/node0 -chain=elementsregtest stop
+
+${BIN}-cli -datadir=${TMP}/node1 -chain=elementsregtest createwallet "" >/dev/null
+${BIN}-cli -datadir=${TMP}/node1 -chain=elementsregtest importprivkey ${SK1}
+${BIN}-cli -datadir=${TMP}/node1 -chain=elementsregtest stop
+
+${BIN}-cli -datadir=${TMP}/node2 -chain=elementsregtest createwallet "" >/dev/null
+${BIN}-cli -datadir=${TMP}/node2 -chain=elementsregtest importprivkey ${SK2}
+${BIN}-cli -datadir=${TMP}/node2 -chain=elementsregtest stop
+sleep 1
+
+echo Connecting nodes...
+echo "elementsregtest.blocksignnode=${PK1}@localhost:${PORT1}" >> ${TMP}/node0/elements.conf
+echo "elementsregtest.blocksignnode=${PK2}@localhost:${PORT2}" >> ${TMP}/node0/elements.conf
+echo "elementsregtest.blocksignnode=${PK0}@localhost:${PORT0}" >> ${TMP}/node1/elements.conf
+echo "elementsregtest.blocksignnode=${PK2}@localhost:${PORT2}" >> ${TMP}/node1/elements.conf
+echo "elementsregtest.blocksignnode=${PK0}@localhost:${PORT0}" >> ${TMP}/node2/elements.conf
+echo "elementsregtest.blocksignnode=${PK1}@localhost:${PORT1}" >> ${TMP}/node2/elements.conf
+
+echo "Watching logs..."
+${BIN}d -datadir=${TMP}/node0 -chain=elementsregtest -daemon
+${BIN}d -datadir=${TMP}/node1 -chain=elementsregtest -daemon
+${BIN}d -datadir=${TMP}/node2 -chain=elementsregtest -daemon
+
+xtail ${TMP}/node{0,1,2}/elementsregtest/debug.log
+
+echo ""
+echo "Cleaning up..."
+
+${BIN}-cli -datadir=${TMP}/node0 -chain=elementsregtest stop
+${BIN}-cli -datadir=${TMP}/node1 -chain=elementsregtest stop
+${BIN}-cli -datadir=${TMP}/node2 -chain=elementsregtest stop
+sleep 1
+rm -rf ${TMP}
+
+echo "Done!"
+
+# End of File
diff --git a/contrib/federation/elements.conf b/contrib/federation/elements.conf
new file mode 100644
index 0000000000..df158843c4
--- /dev/null
+++ b/contrib/federation/elements.conf
@@ -0,0 +1,11 @@
+validatepegin=0
+con_blocksubsidy=5000000000
+con_signed_blocks=1
+signblockscript=52210358e9f8af27053e08243270dc20e2542904561af30b60ad2be4dbc070d5af01ae210217420a47c91a2c9a7f18d6e8d881881cb9118915525041320cb9b379cbe25dc621027cd276ac6111da90f87823f278e601be900e58c1a38690af9b9e22136a9b8d2853ae
+con_max_block_sig_size=150
+con_dyna_deploy_start=9999999999
+elementsregtest.port=38233
+elementsregtest.rpcport=38232
+elementsregtest.addnode=vt4ahyjxprgvqrtv42kiqii2yhm6xebmlqkdphjnrxx2hw3r7wjklfad.onion:38233
+elementsregtest.addnode=biojtxr7rfene2ynqwwp7avqoctcn2y6hld5k5ctim3cevamxy4uvoqd.onion:38233
+elementsregtest.addnode=vhi7qknkigewaxgmv7s7exmvklrj2haiqbp7nnq3wxwxeldjc6vvclid.onion:38233
diff --git a/src/Makefile.am b/src/Makefile.am
index a29a52eb0d..cd26b0f5f0 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -143,6 +143,7 @@ BITCOIN_CORE_H = \
   cuckoocache.h \
   dbwrapper.h \
   dynafed.h \
+  federation.h \
   flatfile.h \
   fs.h \
   httprpc.h \
@@ -310,6 +311,7 @@ libbitcoin_server_a_SOURCES = \
   consensus/tx_verify.cpp \
   dynafed.cpp \
   dbwrapper.cpp \
+  federation.cpp \
   flatfile.cpp \
   httprpc.cpp \
   httpserver.cpp \
diff --git a/src/federation.cpp b/src/federation.cpp
new file mode 100644
index 0000000000..ef046e67a6
--- /dev/null
+++ b/src/federation.cpp
@@ -0,0 +1,862 @@
+// Copyright (c) 2021 Digital Garage
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#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 <netmessagemaker.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
+
+#include <algorithm>
+#include <chrono>
+#include <functional>
+#include <memory>
+#include <map>
+#include <set>
+#include <string>
+#include <utility>
+#include <vector>
+
+//! Pointer to the NodeContext for the process
+static NodeContext* g_context = nullptr;
+
+//! Critical section guarding access to any of the block-signing federation global state
+static RecursiveMutex cs_block_signer;
+
+//! Thread interrupter which is used to command the block-signing thread to terminate.
+static CThreadInterrupt g_thread_interrupt;
+void InterruptBlockSignerThread() {
+    g_thread_interrupt();
+}
+
+#ifdef ENABLE_WALLET
+// Elements supports multiple user wallets.  The wallet which should be used for
+// block signing can be specified via a configuration option, otherwise the
+// "default" wallet will be used.
+static std::shared_ptr<CWallet> GetWalletForBlockSigning()
+{
+    std::vector<std::shared_ptr<CWallet>> wallets = GetWallets();
+    if (wallets.empty()) {
+        return nullptr;
+    }
+    // The user can configure which wallet to use for block signing with the
+    // '-signblockwallet' option.  By default, the default wallet is used.
+    const std::string requestedwallet = g_context->args->GetArg("-signblockwallet", "");
+    std::shared_ptr<CWallet> ret = GetWallet(requestedwallet);
+    if (ret) {
+        return ret;
+    }
+    // If a wallet name was specified but not found, let's log that so the user
+    // knows they need to fix their configuration.
+    if (requestedwallet != "" && requestedwallet != "0") {
+        LogPrintf("Requested wallet \"%s\" be used to sign block proposals, but no such wallet found.\n", requestedwallet);
+    }
+    // The user can disable use of a wallet for block signing by setting
+    // '-signblockwallet' to 0 or false or '-nosignblockwallet=1'.  Note that
+    // there must not be a wallet named "0" (or "false", etc.), or else that
+    // wallet will be selected above.
+    if (!g_context->args->GetBoolArg("-signblockwallet", true)) {
+        return nullptr;
+    }
+    // If we get this far, it is because the default wallet is requested.
+    return !wallets.empty() ? wallets[0] : nullptr;
+}
+#endif // ENABLE_WALLET
+
+//! All public keys contained within the block signing script.
+static std::vector<CPubKey> g_block_signing_keys;
+//! The block signing public key associated with this node.
+static CPubKey g_our_block_signing_key;
+//! The index of the block signing key associated with this node.
+static size_t g_our_block_signing_key_index = 0;
+
+//! The subnets match only the IPs which are known federation block-signing
+//! nodes.  Block-signing messages from other nodes not matching any of these
+//! subnets are ignored, so as to not reveal that we are a block-signing
+//! federation node.
+static std::set<CSubNet> g_whitelist;
+
+struct BlockSigner {
+    CPubKey m_pubkey;
+    std::set<std::string> m_netaddrs;
+    int64_t m_endpoint_last_update_time;
+    std::set<NodeId> m_nodes;
+
+    BlockSigner() : m_endpoint_last_update_time(0) { }
+    BlockSigner(const CPubKey& pubkey) : m_pubkey(pubkey), m_endpoint_last_update_time(0) { }
+};
+
+//! A record to store configuration information and state for each block signer.
+static std::map<CPubKey, BlockSigner> g_block_signers;
+
+// Parses the configuration options to determine connection and pubkey
+// information for all the other federation peers.
+static bool ReadFederationOpts() {
+    using std::swap;
+
+    LOCK(cs_block_signer);
+
+    CScript script = Params().GetConsensus().signblockscript;
+#if ENABLE_WALLET
+    std::shared_ptr<CWallet> pwallet = GetWalletForBlockSigning();
+    LegacyScriptPubKeyMan* spk_man = pwallet ? pwallet->GetOrCreateLegacyScriptPubKeyMan() : nullptr;
+#endif // ENABLE_WALLET
+    CScript::const_iterator pc = script.begin();
+    opcodetype opcode;
+    std::vector<unsigned char> data;
+    while (pc < script.end() && script.GetOp(pc, opcode, data)) {
+        // We are only interested in data pushes
+        if (data.empty()) {
+            continue;
+        }
+        // Check that the push data is a valid pubkey
+        CPubKey pk(data);
+        if (!pk.IsFullyValid()) {
+            continue;
+        }
+        // Treat any valid pubkey as a block-signing key
+        g_block_signing_keys.push_back(pk);
+    }
+
+    std::sort(g_block_signing_keys.begin(),
+              g_block_signing_keys.end());
+
+    g_our_block_signing_key_index = 0;
+    for (const auto& pk : g_block_signing_keys) {
+#if ENABLE_WALLET
+        // Check to see if it is *our* block-signing key
+        if (spk_man && spk_man->HaveKey(pk.GetID())) {
+            g_our_block_signing_key = pk;
+            break;
+        }
+#endif // ENABLE_WALLET
+        ++g_our_block_signing_key_index;
+    }
+    if (g_our_block_signing_key_index >= g_block_signing_keys.size()) {
+        LogPrintf("Error: unable to determine block-signing key.\n");
+        return false;
+    }
+
+    std::string pkstr(HexStr(CDataStream(SER_NETWORK, CLIENT_VERSION) << g_our_block_signing_key), 2);
+    LogPrint(BCLog::FEDERATION, "Identified block-signing key to be %s\n", pkstr);
+
+    int errors = 0;
+    const auto& opt_blocksignnodes = g_context->args->GetArgs("-blocksignnode");
+    for (const auto& opt_blocksignnode : opt_blocksignnodes) {
+        auto pos = opt_blocksignnode.find('@');
+        if (pos == std::string::npos) {
+            LogPrintf("Error: -blocksignnode configuration must be in the form '=<pubkey@ip[:port]>, not '=%s''\n", opt_blocksignnode);
+            ++errors;
+            continue;
+        }
+
+        CPubKey pk;
+        std::string substr(opt_blocksignnode, 0, pos);
+        if (IsHex(substr) && substr.size() == 2*33) {
+            auto data = ParseHex(substr);
+            pk.Set(data.begin(), data.end());
+            if (!pk.IsFullyValid()) {
+                LogPrintf("Error: invalid key provided to -blocksignnode: %s\n", substr);
+                ++errors;
+                continue;
+            }
+        } else {
+            LogPrintf("Error: \"%s\" is not a 33-byte hex-encoded public key\n", substr);
+            ++errors;
+            continue;
+        }
+
+        std::string netaddr(opt_blocksignnode, pos + 1);
+        if (netaddr.empty()) {
+            LogPrintf("Error: no network address is provided for -blocksignnode=%s\n", opt_blocksignnode);
+            ++errors;
+            continue;
+        }
+
+        std::vector<CService> endpoints;
+        int64_t time = GetTime();
+        if (!Lookup(netaddr.c_str(), endpoints, Params().GetDefaultPort(), fNameLookup && !HaveNameProxy(), 256)) {
+            LogPrintf("Error: unable to resolve network address for -blocksignnode=%s\n", opt_blocksignnode);
+            ++errors;
+            continue;
+        }
+
+        // We were able to resolve the network address into at least one ip:port
+        // service endpoint, so we now assume the address is well-formed.
+        LogPrint(BCLog::FEDERATION, "Mapping block signer %s to network address %s\n", pkstr, netaddr);
+        if (!g_block_signers.count(pk)) {
+            g_block_signers[pk] = BlockSigner(pk);
+        }
+        g_block_signers[pk].m_netaddrs.insert(netaddr);
+        g_block_signers[pk].m_endpoint_last_update_time = time;
+
+        // For each service endpoint, we let the connection manager know about
+        // the node, and add it to our own list of potential peers.
+        for (const auto& endpoint : endpoints) {
+            LogPrint(BCLog::FEDERATION, "Whitelisting resolved endpoint %s for block signer %s\n", endpoint.ToString(), pkstr);
+            g_whitelist.emplace(endpoint);
+        }
+
+        // Add the network address to the connection manager, so that a p2p
+        // connection is attempted.
+        g_context->connman->AddNode(netaddr);
+    }
+
+    return !errors;
+}
+
+//! A record of which nodes have identified themselves as block-signing peers,
+//! and their associated public keys.
+static std::map<NodeId, CPubKey> g_fednode_conn;
+
+//! The current round, calculated from the beginning of (UNIX) time.  The actual
+//! number doesn't matter, so long as all peers agree on what it is.
+static int64_t g_roundno = 0;
+
+//! The current block proposal, which is announced by the leader at the
+//! beginning of their round.
+static CBlock g_block_proposal;
+//! A collection of ACK signatures for the block proposal of the current round.
+static std::map<CPubKey, std::vector<unsigned char>> g_block_acks;
+//! A collection of valid signatures for the proposed block of the current round.
+static std::map<CPubKey, std::vector<unsigned char>> g_block_sigs;
+
+//! The time at which the last block was accepted.
+static int64_t g_last_block_time = 0;
+
+// Our peer-to-peer messages all transmitted as NetMsgType::BLOCKSIGN messages
+// on the wire.  We differentiate the type of message for our own purposes with
+// a sub-message command, a single byte value at the beginning of the message
+// payload.
+namespace BlockSignMsgType {
+const unsigned char VER      = 0;
+const unsigned char VERACK   = 1;
+const unsigned char PROPOSAL = 2;
+const unsigned char ACK      = 3;
+const unsigned char SIG      = 4;
+} // namespace BlockSignMsgType
+
+// Checks if the specified peer is in the whitelist, and if so sends it a VER
+// or VERACK message.
+static bool DoHandshake(CNode& node, unsigned char msg)
+    EXCLUSIVE_LOCKS_REQUIRED(cs_block_signer)
+{
+    if (g_fednode_conn.count(node.GetId())) {
+        // Already handshaked
+        return true;
+    }
+
+    for (const auto& subnet : g_whitelist) {
+        if (subnet.Match(node.addr)) {
+            g_context->connman->PushMessage(&node, CNetMsgMaker(node.GetCommonVersion()).Make(
+                NetMsgType::BLOCKSIGN,
+                msg,
+                g_our_block_signing_key));
+            return true;
+        }
+    }
+
+    // Not found in our whitelists.
+    return false;
+}
+
+static void HandshakePeer(CNode* pnode)
+{
+    LOCK(cs_block_signer);
+
+    DoHandshake(*pnode, BlockSignMsgType::VER);
+}
+
+// Checks if the connection manager has connected to any new nodes since we were
+// last called, and attempts a handshake if these nodes are in the whitelist.
+static void HandshakeNewConnections()
+{
+    g_context->connman->ForEachNode(HandshakePeer);
+}
+
+static bool GenerateBlockProposal()
+{
+    const CChainParams& params = Params();
+    const Consensus::Params& consensusParams = params.GetConsensus();
+
+    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 (since this is
+    // the chain setting on regtest), we make it anyone-can-spend.
+    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 takes the chain tip as a parameter, but nHeight
+        // is the only field used, for the purpose of BIP-34 committing to the
+        // height in the coinbase.  We could pass the active tip here, and that
+        // appears to be the intention of the API, but that introduces a race
+        // condition which would result in an invalid block if the chain
+        // advances between when the block template was generated above and now.
+        // So we pass in a dummy block index that just has the correct nHeight
+        // field filled out.
+        CBlockIndex dummy_tip;
+        dummy_tip.nHeight = pblocktemplate->height - 1;
+        IncrementExtraNonce(&block, &dummy_tip, extra_nonce);
+    }
+
+    LOCK(cs_block_signer);
+
+    using std::swap;
+    swap(g_block_proposal, block);
+    return true;
+}
+
+bool CheckMsgSignature(const CPubKey& other, const uint256& hash, const std::vector<unsigned char>& sig)
+{
+    CPubKey pk;
+    if (!pk.RecoverCompact(hash, sig)) {
+        LogPrint(BCLog::FEDERATION, "Error: unable to recover pubkey; is this really a ECDSA signature?\n");
+        return false;
+    }
+    if (pk != other) {
+        LogPrint(BCLog::FEDERATION, "Error: recovered pubkey does not match expected signing key.\n");
+        return false;
+    }
+    return true;
+}
+
+struct AckBlockMsg
+{
+    uint256 m_block_hash;
+
+    AckBlockMsg(const uint256& hash) : m_block_hash(hash) { }
+    AckBlockMsg(const CBlock& block) : m_block_hash(block.GetHash()) { }
+
+    SERIALIZE_METHODS(AckBlockMsg, obj)
+    {
+        READWRITE(obj.m_block_hash);
+        READWRITE(BlockSignMsgType::ACK);
+    }
+};
+
+// 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;
+    }
+
+    // Ignore empty block proposals if we've accepted a block within the
+    // last 15 min.
+    int64_t current_time = GetTime();
+    if (block.vtx.size() <= 1 && (current_time - g_last_block_time) < 15*60) {
+        LogPrint(BCLog::FEDERATION, "Ignoring empty block proposal because insufficient time has passed between blocks. (%d < %d)\n", current_time - g_last_block_time, 15*60);
+        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;
+    }
+
+    // Produce the ack signature
+    std::vector<unsigned char> sig;
+#ifdef ENABLE_WALLET
+    CKey key;
+    std::shared_ptr<CWallet> pwallet = GetWalletForBlockSigning();
+    LegacyScriptPubKeyMan* spk_man = pwallet->GetLegacyScriptPubKeyMan();
+    if (spk_man && spk_man->GetKey(g_our_block_signing_key.GetID(), key)) {
+        CHashWriter ss(SER_GETHASH, 0);
+        ss << AckBlockMsg(block);
+        key.SignCompact(ss.GetHash(), sig);
+    }
+#endif // ENABLE_WALLET
+    if (sig.empty()) {
+        LogPrint(BCLog::FEDERATION, "Error: unable to produce block ACK signature.\n");
+        return false;
+    }
+
+    // Record our ack signature
+    g_block_acks[g_our_block_signing_key] = sig;
+    return true;
+}
+
+static void SendToEachPeer(std::function<bool(CNode* pnode)> func)
+{
+    LOCK(cs_block_signer);
+
+    for (auto& item : g_block_signers) {
+        BlockSigner& other = item.second;
+        // Attempt to send the message through each connection.  Log the
+        // connections for which sending fails.
+        std::vector<NodeId> nodes_to_remove;
+        for (const auto& nodeid : other.m_nodes) {
+            if (!g_context->connman->ForNode(nodeid, func)) {
+                nodes_to_remove.push_back(nodeid);
+            }
+        }
+        // Remove any connection in which the message couldn't be sent.
+        for (const auto& nodeid : nodes_to_remove) {
+            other.m_nodes.erase(nodeid);
+            g_fednode_conn.erase(nodeid);
+        }
+    }
+}
+
+static bool SendBlockProposalToPeer(CNode* pnode)
+{
+    // All paths return true because returning false is used to indicate that
+    // the connection has been dropped.
+
+    LOCK(cs_block_signer);
+
+    if (!g_block_acks.count(g_our_block_signing_key)) {
+        LogPrintf("Error: %s called for a block that we haven't ACK'd.  Did the round end while we were generating the block?  Otherwise this should never happen.\n", __func__);
+        return true;
+    }
+
+    g_context->connman->PushMessage(pnode, CNetMsgMaker(pnode->GetCommonVersion()).Make(
+        NetMsgType::BLOCKSIGN,
+        BlockSignMsgType::PROPOSAL,
+        g_our_block_signing_key,
+        g_block_proposal,
+        g_block_acks[g_our_block_signing_key]));
+    return true;
+}
+
+static void SendBlockProposal()
+{
+    SendToEachPeer(SendBlockProposalToPeer);
+}
+
+static bool SendAckToPeer(CNode* pnode)
+{
+    // All paths return true because returning false is used to indicate that
+    // the connection has been dropped.
+
+    LOCK(cs_block_signer);
+
+    if (g_block_acks.count(g_our_block_signing_key)) {
+        g_context->connman->PushMessage(pnode, CNetMsgMaker(pnode->GetCommonVersion()).Make(
+            NetMsgType::BLOCKSIGN,
+            BlockSignMsgType::ACK,
+            g_our_block_signing_key,
+            g_block_proposal.GetHash(),
+            g_block_acks[g_our_block_signing_key]));
+    }
+
+    return true;
+}
+
+static void SendAck()
+{
+    SendToEachPeer(SendAckToPeer);
+}
+
+static bool SignBlock()
+{
+    LOCK(cs_block_signer);
+    if (g_block_sigs.count(g_our_block_signing_key)) {
+        // Already signed.
+        return true;
+    }
+
+    // Check that we have ACK'd this block.  This serves as a cached check that
+    // the block proposal validates.
+    if (!g_block_acks.count(g_our_block_signing_key)) {
+        LogPrint(BCLog::FEDERATION, "%s called for a block proposal that we haven't ACK'd (yet).  This should never happen!\n", __func__);
+        return false;
+    }
+
+    // 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 SendBlockSigToPeer(CNode* pnode)
+{
+    // All paths return true because returning false is used to indicate that
+    // the connection has been dropped.
+
+    LOCK(cs_block_signer);
+
+    if (!g_block_sigs.count(g_our_block_signing_key)) {
+        LogPrint(BCLog::FEDERATION, "%s called before we signed the current block proposal.  Did the current round end while we were sending our signature?  Otherwise this should never happen.\n", __func__);
+        return true;
+    }
+
+    g_context->connman->PushMessage(pnode, CNetMsgMaker(pnode->GetCommonVersion()).Make(
+        NetMsgType::BLOCKSIGN,
+        BlockSignMsgType::SIG,
+        g_our_block_signing_key,
+        g_block_proposal.GetHash(),
+        g_block_sigs[g_our_block_signing_key]));
+    return true;
+}
+
+static void SendBlockSig()
+{
+    SendToEachPeer(SendBlockSigToPeer);
+}
+
+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 signed block.\n");
+        return false;
+    }
+    g_last_block_time = GetTime();
+
+    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)
+{
+    // Make node context accessible everywhere from within this file.
+    g_context = &node;
+
+    if (!g_context->connman) {
+        LogPrint(BCLog::FEDERATION, "Error: peer-to-peer functionality missing or disabled.  Unable to start block signer.\n");
+        return;
+    }
+
+    // Parse the various federation and block signing configuration
+    // options and initialize the global variable state accordingly.
+    if (!ReadFederationOpts()) {
+        LogPrintf("Error processing federation command-line options.  Block-signing services will be disabled.\n");
+        return;
+    }
+
+    // Blocks are generated on the minute, every minute.  We round the current
+    // time up to the next minute to get the initial block generation time.
+    // (Note that the following code truncates back to the last minute interval
+    // start time, but will then be advanced past the present at the beginning
+    // of the mining loop below.)
+    std::chrono::steady_clock::time_point nextblocktime(
+        std::chrono::duration_cast<std::chrono::minutes>(
+            std::chrono::steady_clock::now().time_since_epoch()));
+
+    while (true) {
+        HandshakeNewConnections();
+
+        // Sleep this thread until the start of the next block interval.
+        nextblocktime += std::chrono::minutes{1};
+        if (!g_thread_interrupt.sleep_until(nextblocktime)) {
+            // Thread interrupted.  Shutdown in progress?
+            break;
+        }
+
+        {
+            LOCK(cs_block_signer);
+            using std::swap;
+            CBlock empty;
+            swap(g_block_proposal, empty);
+            g_block_acks.clear();
+            g_block_sigs.clear();
+        }
+
+        int64_t sec_since_epoch = nextblocktime.time_since_epoch().count();
+        g_roundno = sec_since_epoch / 60;
+        int turn = g_roundno % g_block_signing_keys.size();
+        if (turn != g_our_block_signing_key_index) {
+            // Not our round
+            LogPrint(BCLog::FEDERATION, "Not our round; skipping\n");
+            continue;
+        }
+
+        // Delay 1 second to make sure our peers have transitioned to the
+        // new round before sending our block proposal.
+        std::chrono::steady_clock::time_point delay =
+            nextblocktime + std::chrono::seconds{1};
+        if (!g_thread_interrupt.sleep_until(delay)) {
+            // Thread interrupted.  Shutdown in progress?
+            break;
+        }
+
+        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;
+        }
+
+        SendBlockProposal();
+    }
+}
+
+void HandleBlockSignMessage(CNode& from, CDataStream& msg, std::chrono::microseconds time_received, const std::atomic<bool>& interrupt_msg_proc)
+{
+    unsigned char code;
+    msg >> code;
+
+    switch (code) {
+        case BlockSignMsgType::VER:
+        case BlockSignMsgType::VERACK:
+        {
+            const std::string msgstr = (code == BlockSignMsgType::VERACK) ? "VERACK" : "VER";
+
+            LOCK(cs_block_signer);
+
+            CPubKey other;
+            msg >> other;
+            if (!other.IsFullyValid()) {
+                LogPrint(BCLog::FEDERATION, "Received blocksign::%s message with invalid/malformed public key.  Ignoring.\n", msgstr);
+                break;
+            }
+            if (std::find(g_block_signing_keys.begin(), g_block_signing_keys.end(), other) == g_block_signing_keys.end()) {
+                std::string pkstr(HexStr(CDataStream(SER_NETWORK, CLIENT_VERSION) << other), 2);
+                LogPrint(BCLog::FEDERATION, "Received blocksign::%s message with unrecognized public key %s.  Ignoring.\n", msgstr, pkstr);
+                break;
+            }
+            if (!g_block_signers.count(other)) {
+                std::string pkstr(HexStr(CDataStream(SER_NETWORK, CLIENT_VERSION) << other), 2);
+                LogPrint(BCLog::FEDERATION, "Received blocksign::%s message with known public key, but cannot find record for peer: %s.  Ignoring.  Are you missing a '-blocksignnode=%s:<ip:port>' configuration parameter?\n", msgstr, pkstr, pkstr);
+                break;
+            }
+
+            g_fednode_conn[from.GetId()] = other;
+            g_block_signers[other].m_nodes.insert(from.GetId());
+
+            if (code == BlockSignMsgType::VERACK) {
+                break;
+            }
+
+            DoHandshake(from, BlockSignMsgType::VERACK);
+        }
+        break;
+
+        case BlockSignMsgType::PROPOSAL:
+        {
+            LOCK(cs_block_signer);
+
+            CPubKey other;
+            msg >> other;
+            if (other != g_block_signing_keys[g_roundno % g_block_signing_keys.size()]) {
+                std::string pkstr(HexStr(CDataStream(SER_NETWORK, CLIENT_VERSION) << other), 2);
+                LogPrint(BCLog::FEDERATION, "Received out-of-turn block proposal from peer %s.  Ignoring.\n", pkstr);
+                break;
+            }
+
+            msg >> g_block_proposal;
+
+            CHashWriter ss(SER_GETHASH, 0);
+            ss << AckBlockMsg(g_block_proposal.GetHash());
+
+            std::vector<unsigned char> sig;
+            msg >> sig;
+
+            if (!CheckMsgSignature(other, ss.GetHash(), sig)) {
+                LogPrint(BCLog::FEDERATION, "Error: signature validation failed; ignoring PROPOSAL message\n");
+                break;
+            }
+
+            g_block_acks[other] = sig;
+        }
+        if (AcceptBlockProposal()) {
+            SendAck();
+        }
+        break;
+
+        case BlockSignMsgType::ACK:
+        {
+            LOCK(cs_block_signer);
+
+            CPubKey other;
+            msg >> other;
+            if (std::find(g_block_signing_keys.begin(), g_block_signing_keys.end(), other) == g_block_signing_keys.end()) {
+                LogPrint(BCLog::FEDERATION, "Error: received BlockSignMsgType::ACK message with unknown pubkey.\n");
+                break;
+            }
+
+            uint256 block_hash;
+            msg >> block_hash;
+            if (block_hash != g_block_proposal.GetHash()) {
+                LogPrint(BCLog::FEDERATION, "Error: received BlockSignMsgType::ACK message for block which does not match current proposal. (%s != %s)\n", block_hash.GetHex(), g_block_proposal.GetHash().GetHex());
+                break;
+            }
+            CHashWriter ss(SER_GETHASH, 0);
+            ss << AckBlockMsg(block_hash);
+
+            std::vector<unsigned char> sig;
+            msg >> sig;
+
+            if (!CheckMsgSignature(other, ss.GetHash(), sig)) {
+                LogPrint(BCLog::FEDERATION, "Error: signature validation failed; ignoring ACK message\n");
+                break;
+            }
+
+            g_block_acks[other] = sig;
+
+            auto missing_acks = g_block_signing_keys.size() - g_block_acks.size();
+            if (missing_acks > (g_block_signing_keys.size() / 3)) {
+                LogPrint(BCLog::FEDERATION, "Not enough keys to advance to signing round. (%d > %d)\n", missing_acks, g_block_signing_keys.size() / 3);
+                break;
+            }
+#if 0
+            if (g_block_sigs.count(g_our_block_signing_key)) {
+                LogPrint(BCLog::FEDERATION, "Already sent our block sig; won't send again.\n");
+                break;
+            }
+#endif
+        }
+        if (!SignBlock()) {
+            LogPrintf("Error: failed to create block signature.\n");
+            break;
+        }
+        SendBlockSig();
+        break;
+
+        case BlockSignMsgType::SIG:
+        {
+            LOCK(cs_block_signer);
+
+            CPubKey other;
+            msg >> other;
+            if (std::find(g_block_signing_keys.begin(), g_block_signing_keys.end(), other) == g_block_signing_keys.end()) {
+                LogPrint(BCLog::FEDERATION, "Error: received BlockSignMsgType::SIG message with unknown pubkey.\n");
+                break;
+            }
+
+            uint256 block_hash;
+            msg >> block_hash;
+            if (block_hash != g_block_proposal.GetHash()) {
+                LogPrint(BCLog::FEDERATION, "Error: received BlockSignMsgType::SIG message for block which does not match current proposal. (%s != %s)\n", block_hash.GetHex(), g_block_proposal.GetHash().GetHex());
+                break;
+            }
+
+            std::vector<unsigned char> sig;
+            msg >> sig;
+
+            // FIXME: check if signature is valid!
+
+            g_block_sigs[other] = sig;
+        }
+        SubmitBlock();
+        break;
+
+        default:
+            LogPrint(BCLog::FEDERATION, "Received an unrecognized blocksign message (code=%d) from peer=%d.  Ignoring.\n", code, from.GetId());
+        break;
+    }
+}
+
+// End of File
diff --git a/src/federation.h b/src/federation.h
new file mode 100644
index 0000000000..bbe4d69917
--- /dev/null
+++ b/src/federation.h
@@ -0,0 +1,30 @@
+// Copyright (c) 2021 Digital Garage
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_FEDERATION_H
+#define BITCOIN_FEDERATION_H
+
+#include <net.h>
+#include <node/context.h>
+#include <streams.h>
+
+#include <atomic>
+#include <chrono>
+#include <cstdint>
+
+/** Run an instance of the block-signing protocol manager. */
+void ThreadBlockSigner(NodeContext &node);
+
+// For some reason the Boost thread interrupt is not interrupting the sleep
+// within ThreadBlockSigner, so we provide a special-purpose interruption
+// routine.  This should be investigated and removed if possible.
+void InterruptBlockSignerThread();
+
+/** Called by the code in net_processing.cpp, handles a BLOCKSIGN message from a
+ ** federation peer. */
+void HandleBlockSignMessage(CNode& from, CDataStream& msg, std::chrono::microseconds time_received, const std::atomic<bool>& interrupt_msg_proc);
+
+#endif // BITCOIN_FEDERATION_H
+
+// End of File
diff --git a/src/init.cpp b/src/init.cpp
index 22d09d28e9..2ad421f5b9 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -17,6 +17,7 @@
 #include <chainparams.h>
 #include <compat/sanity.h>
 #include <consensus/validation.h>
+#include <federation.h>
 #include <fs.h>
 #include <hash.h>
 #include <httprpc.h>
@@ -92,6 +93,7 @@ static bool fFeeEstimatesInitialized = false;
 static const bool DEFAULT_PROXYRANDOMIZE = true;
 static const bool DEFAULT_REST_ENABLE = false;
 static const bool DEFAULT_STOPAFTERBLOCKIMPORT = false;
+static const bool DEFAULT_BLOCK_SIGNER_ENABLE = false;
 
 #ifdef WIN32
 // Win32 LevelDB doesn't use filedescriptors, and the ones used for
@@ -174,6 +176,7 @@ void Interrupt(NodeContext& node)
     InterruptREST();
     InterruptTorControl();
     InterruptMapPort();
+    InterruptBlockSignerThread();
     if (node.connman)
         node.connman->Interrupt();
     if (g_txindex) {
@@ -639,6 +642,9 @@ void SetupServerArgs(NodeContext& node)
     argsman.AddArg("-ct_bits", strprintf("The default number of hiding bits in a rangeproof. Will be exceeded to cover amounts exceeding the maximum hiding value. (default: %d)", 52), ArgsManager::ALLOW_ANY, OptionsCategory::CHAINPARAMS);
     argsman.AddArg("-ct_exponent", strprintf("The hiding exponent. (default: %s)", 0), ArgsManager::ALLOW_ANY, OptionsCategory::CHAINPARAMS);
 
+    argsman.AddArg("-blocksigner", strprintf("Enable built-in block-signing federated peer protocol. (default: %s)", DEFAULT_BLOCK_SIGNER_ENABLE ? "on" : "off"), ArgsManager::ALLOW_ANY, OptionsCategory::ELEMENTS);
+    argsman.AddArg("-blocksignnode=<pubkey>@<ip[:port]>", "Connection information for the block-signing federation peer associated with the specified pubkey.  May be specified as many times as necessary for different peers and/or alternative connection strings for a given peer.", ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY, OptionsCategory::ELEMENTS);
+
     // Add the hidden options
     argsman.AddHiddenArgs(hidden_args);
     argsman.AddHiddenArgs(elements_hidden_args);
@@ -2064,6 +2070,11 @@ bool AppInitMain(const util::Ref& context, NodeContext& node, interfaces::BlockA
         return false;
     }
 
+    // Start the block-signing protocol management thread
+    if (args.GetBoolArg("-blocksigner", DEFAULT_BLOCK_SIGNER_ENABLE)) {
+        threadGroup.create_thread(std::bind(&TraceThread<CScheduler::Function>, "block-signer", [&node](){ThreadBlockSigner(node);}));
+    }
+
     // ********************************************************* Step 13: Check PAK
     if (chainparams.GetEnforcePak()) {
         if (!chainparams.GetConsensus().first_extension_space.empty() &&
diff --git a/src/logging.cpp b/src/logging.cpp
index 35e0754f20..fe621454e1 100644
--- a/src/logging.cpp
+++ b/src/logging.cpp
@@ -155,6 +155,7 @@ const CLogCategoryDesc LogCategories[] =
     {BCLog::QT, "qt"},
     {BCLog::LEVELDB, "leveldb"},
     {BCLog::VALIDATION, "validation"},
+    {BCLog::FEDERATION, "federation"},
     {BCLog::ALL, "1"},
     {BCLog::ALL, "all"},
 };
diff --git a/src/logging.h b/src/logging.h
index 7e646ef67a..d5d47550ff 100644
--- a/src/logging.h
+++ b/src/logging.h
@@ -56,6 +56,7 @@ namespace BCLog {
         QT          = (1 << 19),
         LEVELDB     = (1 << 20),
         VALIDATION  = (1 << 21),
+        FEDERATION  = (1 << 29),
         ALL         = ~(uint32_t)0,
     };
 
diff --git a/src/miner.cpp b/src/miner.cpp
index 73437df58e..7c90e7f35d 100644
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -135,6 +135,7 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
     CBlockIndex* pindexPrev = ::ChainActive().Tip();
     assert(pindexPrev != nullptr);
     nHeight = pindexPrev->nHeight + 1;
+    pblocktemplate->height = nHeight;
 
     pblock->nVersion = ComputeBlockVersion(pindexPrev, chainparams.GetConsensus());
     // -regtest only: allow overriding block.nVersion with
diff --git a/src/miner.h b/src/miner.h
index 8510983419..4a39534675 100644
--- a/src/miner.h
+++ b/src/miner.h
@@ -31,6 +31,7 @@ struct CBlockTemplate
     std::vector<CAmount> vTxFees;
     std::vector<int64_t> vTxSigOpsCost;
     std::vector<unsigned char> vchCoinbaseCommitment;
+    uint32_t height;
 };
 
 // Container for tracking updates to ancestor feerate as we include (parent)
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index c649cf7757..8a1872df90 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -11,6 +11,7 @@
 #include <blockfilter.h>
 #include <chainparams.h>
 #include <consensus/validation.h>
+#include <federation.h>
 #include <hash.h>
 #include <index/blockfilterindex.h>
 #include <merkleblock.h>
@@ -3750,6 +3751,11 @@ void PeerManager::ProcessMessage(CNode& pfrom, const std::string& msg_type, CDat
         return;
     }
 
+    if (msg_type == NetMsgType::BLOCKSIGN) {
+        HandleBlockSignMessage(pfrom, vRecv, time_received, interruptMsgProc);
+        return;
+    }
+
     // Ignore unknown commands for extensibility
     LogPrint(BCLog::NET, "Unknown command \"%s\" from peer=%d\n", SanitizeString(msg_type), pfrom.GetId());
     return;
diff --git a/src/protocol.cpp b/src/protocol.cpp
index 7ffad1b4dc..42bebfa157 100644
--- a/src/protocol.cpp
+++ b/src/protocol.cpp
@@ -38,6 +38,7 @@ const char *SENDCMPCT="sendcmpct";
 const char *CMPCTBLOCK="cmpctblock";
 const char *GETBLOCKTXN="getblocktxn";
 const char *BLOCKTXN="blocktxn";
+const char *BLOCKSIGN="blocksign";
 const char *GETCFILTERS="getcfilters";
 const char *CFILTER="cfilter";
 const char *GETCFHEADERS="getcfheaders";
diff --git a/src/protocol.h b/src/protocol.h
index 7d4304eaf7..7e8740805d 100644
--- a/src/protocol.h
+++ b/src/protocol.h
@@ -218,6 +218,9 @@ extern const char* GETBLOCKTXN;
  * @since protocol version 70014 as described by BIP 152
  */
 extern const char* BLOCKTXN;
+/**
+ */
+extern const char *BLOCKSIGN;
 /**
  * getcfilters requests compact filters for a range of blocks.
  * Only available with service bit NODE_COMPACT_FILTERS as described by
diff --git a/src/threadinterrupt.h b/src/threadinterrupt.h
index 2665f8a5be..f7a0a29dfc 100644
--- a/src/threadinterrupt.h
+++ b/src/threadinterrupt.h
@@ -27,6 +27,13 @@ class CThreadInterrupt
     bool sleep_for(std::chrono::seconds rel_time);
     bool sleep_for(std::chrono::minutes rel_time);
 
+    template<class Clock>
+    bool sleep_until(std::chrono::time_point<Clock> timeout)
+    {
+        WAIT_LOCK(mut, lock);
+        return !cond.wait_until(lock, timeout, [this]() { return flag.load(std::memory_order_acquire); });
+    }
+
 private:
     std::condition_variable cond;
     Mutex mut;
diff --git a/src/wallet/init.cpp b/src/wallet/init.cpp
index 8b2ef191fb..317c49f49e 100644
--- a/src/wallet/init.cpp
+++ b/src/wallet/init.cpp
@@ -68,6 +68,8 @@ void WalletInit::AddWalletOptions(ArgsManager& argsman) const
 #endif
     argsman.AddArg("-walletrbf", strprintf("Send transactions with full-RBF opt-in enabled (RPC only, default: %u)", DEFAULT_WALLET_RBF), ArgsManager::ALLOW_ANY, OptionsCategory::WALLET);
 
+    argsman.AddArg("-signblockwallet=<wallet>", "Use the named wallet for signing block proposals in the federation block-signing code", ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY, OptionsCategory::ELEMENTS);
+
     argsman.AddArg("-dblogsize=<n>", strprintf("Flush wallet database activity from memory to disk log every <n> megabytes (default: %u)", DEFAULT_WALLET_DBLOGSIZE), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::WALLET_DEBUG_TEST);
     argsman.AddArg("-flushwallet", strprintf("Run a thread to flush wallet periodically (default: %u)", DEFAULT_FLUSHWALLET), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::WALLET_DEBUG_TEST);
     argsman.AddArg("-privdb", strprintf("Sets the DB_PRIVATE flag in the wallet db environment (default: %u)", DEFAULT_WALLET_PRIVDB), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::WALLET_DEBUG_TEST);