mining: expose OP_RETURN signals in required_outputs

Author: Sjors

src/node/miner.cpp

@@ -22,10 +22,12 @@
 #include <policy/policy.h>
 #include <pow.h>
 #include <primitives/transaction.h>
+#include <script/script.h>
 #include <util/moneystr.h>
 #include <util/signalinterrupt.h>
 #include <util/time.h>
 #include <validation.h>
+#include <versionbits.h>
 
 #include <algorithm>
 #include <utility>
@@ -196,6 +198,13 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock()
     coinbaseTx.nLockTime = static_cast<uint32_t>(nHeight - 1);
     coinbase_tx.lock_time = coinbaseTx.nLockTime;
 
+    if ((pblock->nVersion & VERSIONBITS_TOP_MASK) == VERSIONBITS_TOP_BITS &&
+        (pblock->nVersion & VERSIONBITS_DEPLOYMENT_OPRETURN_FLAG) != 0) {
+        for (const auto& signal_tag : m_chainstate.m_chainman.m_versionbitscache.GetRequiredSignalTags(pindexPrev, chainparams.GetConsensus())) {
+            coinbase_tx.required_outputs.emplace_back(0, CScript{} << OP_RETURN << std::vector<unsigned char>{signal_tag.begin(), signal_tag.end()});
+        }
+    }
+
     pblock->vtx[0] = MakeTransactionRef(std::move(coinbaseTx));
     m_chainstate.m_chainman.GenerateCoinbaseCommitment(*pblock, pindexPrev);
 

src/node/types.h

@@ -149,8 +149,8 @@ struct CoinbaseTx {
     CAmount block_reward_remaining;
     /*
      * To be included as the last outputs in the coinbase transaction.
-     * Currently this is only the witness commitment OP_RETURN, but future
-     * softforks or a custom mining patch could add more.
+     * Currently this includes the witness commitment OP_RETURN, and may also
+     * include other zero-value signalling outputs for supported softforks.
      *
      * The dummy output that spends the full reward is excluded.
      */

src/versionbits.cpp

@@ -347,6 +347,20 @@ int32_t VersionBitsCache::ComputeBlockVersion(const CBlockIndex* pindexPrev, con
     return ::ComputeBlockVersion(pindexPrev, params, m_caches);
 }
 
+std::vector<std::string> VersionBitsCache::GetRequiredSignalTags(const CBlockIndex* pindexPrev, const Consensus::Params& params)
+{
+    LOCK(m_mutex);
+
+    std::vector<std::string> signal_tags;
+    ForEachSignallingDeployment(pindexPrev, params, m_caches, [&](Consensus::DeploymentPos pos, const VersionBitsConditionChecker&) {
+        const auto& signal_tag{params.vDeployments[pos].signal_tag};
+        if (!signal_tag.empty()) {
+            signal_tags.push_back(signal_tag);
+        }
+    });
+    return signal_tags;
+}
+
 void VersionBitsCache::Clear()
 {
     LOCK(m_mutex);

src/versionbits.h

@@ -11,6 +11,7 @@
 #include <array>
 #include <map>
 #include <optional>
+#include <string>
 #include <vector>
 
 class CChainParams;
@@ -97,6 +98,9 @@ class VersionBitsCache
     /** Determine what nVersion a new block should use */
     int32_t ComputeBlockVersion(const CBlockIndex* pindexPrev, const Consensus::Params& params) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex);
 
+    /** Return the OP_RETURN deployment tags required in the next block's coinbase. */
+    std::vector<std::string> GetRequiredSignalTags(const CBlockIndex* pindexPrev, const Consensus::Params& params) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex);
+
     /** Check for unknown activations
      *  Returns a vector containing the bit number used for signalling and a bool
      *  indicating the deployment is likely to be ACTIVE, rather than merely LOCKED_IN. */

test/functional/interface_ipc_mining.py

@@ -24,6 +24,7 @@
 from test_framework.script import (
     CScript,
     CScriptNum,
+    OP_RETURN,
 )
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
@@ -96,8 +97,8 @@ async def build_coinbase_test(self, template, ctx, miniwallet):
         coinbase_tx.vout = [CTxOut()]
         coinbase_tx.vout[0].scriptPubKey = miniwallet.get_output_script()
         coinbase_tx.vout[0].nValue = coinbase_res.blockRewardRemaining
-        # Add SegWit OP_RETURN. This is currently always present even for
-        # empty blocks, but this may change.
+        # Append any required coinbase outputs, such as the witness
+        # commitment and deployment signalling OP_RETURNs.
         for output_data in coinbase_res.requiredOutputs:
             output = CTxOut()
             output.deserialize(BytesIO(output_data))
@@ -396,6 +397,39 @@ async def async_routine():
 
         asyncio.run(capnp.run(async_routine()))
 
+    def run_opreturn_required_outputs_test(self):
+        self.log.info("Running OP_RETURN required_outputs test")
+        self.restart_node(0, extra_args=[
+            '-vbparams=testdummy:999999999999:999999999999',
+            '-vbparams=testdummy2:0:999999999999',
+        ])
+
+        async def async_routine():
+            ctx, mining = await self.make_mining_ctx()
+
+            async with AsyncExitStack() as stack:
+                template = await mining_create_block_template(mining, stack, ctx, self.default_block_create_options)
+                assert template is not None
+
+                coinbase_res = await mining_get_coinbase_tx(template, ctx)
+                assert_equal(len(coinbase_res.requiredOutputs), 2)
+
+                signal_output = CTxOut()
+                signal_output.deserialize(BytesIO(coinbase_res.requiredOutputs[0]))
+                assert_equal(signal_output.nValue, 0)
+                assert_equal(signal_output.scriptPubKey.hex(), CScript([OP_RETURN, b"BIP-9999"]).hex())
+
+                witness_output = CTxOut()
+                witness_output.deserialize(BytesIO(coinbase_res.requiredOutputs[1]))
+                assert_equal(witness_output.nValue, 0)
+                # getblocktemplate only exposes the witness commitment today.
+                assert_equal(
+                    witness_output.scriptPubKey.hex(),
+                    self.nodes[0].getblocktemplate({"rules": ["segwit"]})["default_witness_commitment"],
+                )
+
+        asyncio.run(capnp.run(async_routine()))
+
     def run_test(self):
         self.miniwallet = MiniWallet(self.nodes[0])
         self.default_block_create_options = self.capnp_modules['mining'].BlockCreateOptions()
@@ -404,6 +438,7 @@ def run_test(self):
         self.run_block_template_test()
         self.run_coinbase_and_submission_test()
         self.run_ipc_option_override_test()
+        self.run_opreturn_required_outputs_test()
 
 
 if __name__ == '__main__':