signet: miner skips PSBT step for OP_TRUE

contrib/signet/README.md

@@ -44,6 +44,8 @@ Adding the --ongoing parameter will then cause the signet miner to create blocks
 
     $MINER --cli="$CLI" generate --grind-cmd="$GRIND" --address="$ADDR" --nbits=$NBITS --ongoing
 
+For custom signets with a trivial challenge a PSBT is not necessary. The miner detects this for `OP_TRUE`.
+
 Other options
 -------------
 
@@ -80,4 +82,3 @@ These steps can instead be done explicitly:
       $CLI -signet -stdin submitblock
 
 This is intended to allow you to replace part of the pipeline for further experimentation (eg, to sign the block with a hardware wallet).
-

contrib/signet/miner

@@ -96,9 +96,10 @@ def do_decode_psbt(b64psbt):
     return from_binary(CBlock, psbt.g.map[PSBT_SIGNET_BLOCK]), ser_string(scriptSig) + scriptWitness
 
 def finish_block(block, signet_solution, grind_cmd):
-    block.vtx[0].vout[-1].scriptPubKey += CScriptOp.encode_op_pushdata(SIGNET_HEADER + signet_solution)
-    block.vtx[0].rehash()
-    block.hashMerkleRoot = block.calc_merkle_root()
+    if signet_solution is not None:
+        block.vtx[0].vout[-1].scriptPubKey += CScriptOp.encode_op_pushdata(SIGNET_HEADER + signet_solution)
+        block.vtx[0].rehash()
+        block.hashMerkleRoot = block.calc_merkle_root()
     if grind_cmd is None:
         block.solve()
     else:
@@ -110,10 +111,12 @@ def finish_block(block, signet_solution, grind_cmd):
         block.rehash()
     return block
 
-def generate_psbt(tmpl, reward_spk, *, blocktime=None):
-    signet_spk = tmpl["signet_challenge"]
+def generate_psbt(block, signet_spk):
     signet_spk_bin = bytes.fromhex(signet_spk)
+    signme, spendme = signet_txs(block, signet_spk_bin)
+    return do_createpsbt(block, signme, spendme)
 
+def new_block(tmpl, reward_spk, blocktime=None):
     cbtx = create_coinbase(height=tmpl["height"], value=tmpl["coinbasevalue"], spk=reward_spk)
     cbtx.vin[0].nSequence = 2**32-2
     cbtx.rehash()
@@ -135,9 +138,10 @@ def generate_psbt(tmpl, reward_spk, *, blocktime=None):
     block.vtx[0].wit.vtxinwit = [cbwit]
     block.vtx[0].vout.append(CTxOut(0, bytes(get_witness_script(witroot, witnonce))))
 
-    signme, spendme = signet_txs(block, signet_spk_bin)
+    block.vtx[0].rehash()
+    block.hashMerkleRoot = block.calc_merkle_root()
 
-    return do_createpsbt(block, signme, spendme)
+    return block
 
 def get_reward_address(args, height):
     if args.address is not None:
@@ -177,8 +181,10 @@ def get_reward_addr_spk(args, height):
 
 def do_genpsbt(args):
     tmpl = json.load(sys.stdin)
+    signet_spk = tmpl["signet_challenge"]
     _, reward_spk = get_reward_addr_spk(args, tmpl["height"])
-    psbt = generate_psbt(tmpl, reward_spk)
+    block = new_block(tmpl, reward_spk)
+    psbt = generate_psbt(block, signet_spk)
     print(psbt)
 
 def do_solvepsbt(args):
@@ -407,14 +413,23 @@ def do_generate(args):
         # mine block
         logging.debug("Mining block delta=%s start=%s mine=%s", seconds_to_hms(mine_time-bestheader["time"]), mine_time, is_mine)
         mined_blocks += 1
-        psbt = generate_psbt(tmpl, reward_spk, blocktime=mine_time)
-        input_stream = os.linesep.join([psbt, "true", "ALL"]).encode('utf8')
-        psbt_signed = json.loads(args.bcli("-stdin", "walletprocesspsbt", input=input_stream))
-        if not psbt_signed.get("complete",False):
-            logging.debug("Generated PSBT: %s" % (psbt,))
-            sys.stderr.write("PSBT signing failed\n")
-            return 1
-        block, signet_solution = do_decode_psbt(psbt_signed["psbt"])
+        block = new_block(tmpl, reward_spk, blocktime=mine_time)
+
+        # BIP325 allows omitting the signet commitment when scriptSig and
+        # scriptWitness are both empty. This is the case for trivial
+        # challenges such as OP_TRUE
+        signet_solution = None
+        signet_spk = tmpl["signet_challenge"]
+        if signet_spk != "51":
+            psbt = generate_psbt(block, signet_spk)
+            input_stream = os.linesep.join([psbt, "true", "ALL"]).encode('utf8')
+            psbt_signed = json.loads(args.bcli("-stdin", "walletprocesspsbt", input=input_stream))
+            if not psbt_signed.get("complete",False):
+               logging.debug("Generated PSBT: %s" % (psbt,))
+               sys.stderr.write("PSBT signing failed\n")
+               return 1
+            block, signet_solution = do_decode_psbt(psbt_signed["psbt"])
+
         block = finish_block(block, signet_solution, args.grind_cmd)
 
         # submit block

test/functional/tool_signet_miner.py

@@ -26,26 +26,31 @@ def add_options(self, parser):
     def set_test_params(self):
         self.chain = "signet"
         self.setup_clean_chain = True
-        self.num_nodes = 1
+        self.num_nodes = 2
 
         # generate and specify signet challenge (simple p2wpkh script)
         privkey = ECKey()
         privkey.set(CHALLENGE_PRIVATE_KEY, True)
         pubkey = privkey.get_pubkey().get_bytes()
         challenge = key_to_p2wpkh_script(pubkey)
-        self.extra_args = [[f'-signetchallenge={challenge.hex()}']]
+
+        self.extra_args = [
+            ["-signetchallenge=51"], # OP_TRUE
+            [f'-signetchallenge={challenge.hex()}'],
+        ]
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_cli()
         self.skip_if_no_wallet()
         self.skip_if_no_bitcoin_util()
 
-    def run_test(self):
-        node = self.nodes[0]
-        # import private key needed for signing block
-        node.importprivkey(bytes_to_wif(CHALLENGE_PRIVATE_KEY))
+    def setup_network(self):
+        self.setup_nodes()
+        # Nodes with different signet networks are not connected
 
-        # generate block with signet miner tool
+    # generate block with signet miner tool
+    def mine_block(self, node):
+        assert_equal(node.getblockcount(), 0)
         base_dir = self.config["environment"]["SRCDIR"]
         signet_miner_path = os.path.join(base_dir, "contrib", "signet", "miner")
         subprocess.run([
@@ -60,6 +65,14 @@ def run_test(self):
             ], check=True, stderr=subprocess.STDOUT)
         assert_equal(node.getblockcount(), 1)
 
+    def run_test(self):
+        self.log.info("Signet node with trivial challenge (OP_RETURN)")
+        self.mine_block(self.nodes[0])
+
+        self.log.info("Signet node with single signature challenge")
+        # import private key needed for signing block
+        self.nodes[1].importprivkey(bytes_to_wif(CHALLENGE_PRIVATE_KEY))
+        self.mine_block(self.nodes[1])
 
 if __name__ == "__main__":
     SignetMinerTest().main()