From 0f62abe4dda014777452ea0b45822351b9aea942 Mon Sep 17 00:00:00 2001
From: Karl-Johan Alm <karljohan-alm@garage.co.jp>
Date: Wed, 17 Jul 2019 17:33:25 +0900
Subject: [PATCH 01/17] add witness commitment section support to
 primitive/block

This also moves GetWitnessCommitmentIndex out of validation.cpp into CBlock, with 3 lines affected (GetWitnessCommitmentIndex(block) -> block.GetWitnessCommitmentIndex()).
---
 src/primitives/block.cpp | 62 ++++++++++++++++++++++++++++++++++++++++
 src/primitives/block.h   | 44 ++++++++++++++++++++++++++++
 src/validation.cpp       | 19 ++----------
 src/validation.h         |  3 --
 4 files changed, 109 insertions(+), 19 deletions(-)

diff --git a/src/primitives/block.cpp b/src/primitives/block.cpp
index 0c84ed6da22e..98c93e986219 100644
--- a/src/primitives/block.cpp
+++ b/src/primitives/block.cpp
@@ -28,3 +28,65 @@ std::string CBlock::ToString() const
     }
     return s.str();
 }
+
+bool CBlock::GetWitnessCommitmentSection(const uint8_t header[4], std::vector<uint8_t>& result) const
+{
+    int cidx = GetWitnessCommitmentIndex();
+    if (cidx == -1) return false;
+    auto script = vtx.at(0)->vout.at(cidx).scriptPubKey;
+    opcodetype opcode;
+    CScript::const_iterator pc = script.begin();
+    ++pc; // move beyond initial OP_RETURN
+    while (script.GetOp(pc, opcode, result)) {
+        if (result.size() > 3 && !memcmp(result.data(), header, 4)) {
+            result.erase(result.begin(), result.begin() + 4);
+            return true;
+        }
+    }
+    result.clear();
+    return false;
+}
+
+bool CBlock::SetWitnessCommitmentSection(CMutableTransaction& mtx, const uint8_t header[4], const std::vector<uint8_t>& data)
+{
+    int cidx = GetWitnessCommitmentIndex(mtx);
+    if (cidx == -1) return false;
+
+    CScript result;
+    std::vector<uint8_t> pushdata;
+    auto script = mtx.vout[cidx].scriptPubKey;
+    opcodetype opcode;
+    CScript::const_iterator pc = script.begin();
+    result.push_back(*pc++);
+    bool found = false;
+    while (script.GetOp(pc, opcode, pushdata)) {
+        if (pushdata.size() > 0) {
+            if (pushdata.size() > 3 && !memcmp(pushdata.data(), header, 4)) {
+                // replace pushdata
+                found = true;
+                pushdata.erase(pushdata.begin() + 4, pushdata.end());
+                pushdata.insert(pushdata.end(), data.begin(), data.end());
+            }
+            result << pushdata;
+        } else {
+            result << opcode;
+        }
+    }
+    if (!found) {
+        // append section as it did not exist
+        pushdata.clear();
+        pushdata.insert(pushdata.end(), header, header + 4);
+        pushdata.insert(pushdata.end(), data.begin(), data.end());
+        result << pushdata;
+    }
+    mtx.vout[cidx].scriptPubKey = result;
+    return true;
+}
+
+bool CBlock::SetWitnessCommitmentSection(const uint8_t header[4], const std::vector<uint8_t>& data)
+{
+    auto mtx = CMutableTransaction(*vtx[0]);
+    if (!SetWitnessCommitmentSection(mtx, header, data)) return false;
+    vtx[0] = std::make_shared<CTransaction>(mtx);
+    return true;
+}
diff --git a/src/primitives/block.h b/src/primitives/block.h
index 750d42efbc23..23a375556502 100644
--- a/src/primitives/block.h
+++ b/src/primitives/block.h
@@ -116,6 +116,50 @@ class CBlock : public CBlockHeader
         return block;
     }
 
+    /**
+     * Get the vout index of the segwit commitment in the coinbase transaction of this block.
+     *
+     * Returns -1 if no witness commitment was found.
+     */
+    inline int GetWitnessCommitmentIndex() const
+    {
+        return vtx.empty() ? -1 : GetWitnessCommitmentIndex(*vtx.at(0));
+    }
+
+    /**
+     * Get the vout index of the segwit commitment in the given coinbase transaction.
+     *
+     * Returns -1 if no witness commitment was found.
+     */
+    template<typename T> static inline int GetWitnessCommitmentIndex(const T& coinbase) {
+        for (int64_t o = coinbase.vout.size() - 1; o > -1; --o) {
+            auto vospk = coinbase.vout[o].scriptPubKey;
+            if (vospk.size() >= 38 && vospk[0] == OP_RETURN && vospk[1] == 0x24 && vospk[2] == 0xaa && vospk[3] == 0x21 && vospk[4] == 0xa9 && vospk[5] == 0xed) {
+                return o;
+            }
+        }
+        return -1;
+    }
+
+    /**
+     * Attempt to get the data for the section with the given header in the witness commitment of this block.
+     *
+     * Returns false if header was not found. The data (excluding the 4 byte header) is written into result if found.
+     */
+    bool GetWitnessCommitmentSection(const uint8_t header[4], std::vector<uint8_t>& result) const;
+
+    /**
+     * Attempt to add or update the data for the section with the given header in the witness commitment of this block.
+     *
+     * This operation may fail and return false, if no witness commitment exists upon call time. Returns true on success.
+     */
+    bool SetWitnessCommitmentSection(const uint8_t header[4], const std::vector<uint8_t>& data);
+
+    /**
+     * The tx based equivalent of the above.
+     */
+    static bool SetWitnessCommitmentSection(CMutableTransaction& tx, const uint8_t header[4], const std::vector<uint8_t>& data);
+
     std::string ToString() const;
 };
 
diff --git a/src/validation.cpp b/src/validation.cpp
index 8f5d3331704d..9db40bd514df 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -3335,22 +3335,9 @@ bool IsWitnessEnabled(const CBlockIndex* pindexPrev, const Consensus::Params& pa
     return (height >= params.SegwitHeight);
 }
 
-int GetWitnessCommitmentIndex(const CBlock& block)
-{
-    int commitpos = -1;
-    if (!block.vtx.empty()) {
-        for (size_t o = 0; o < block.vtx[0]->vout.size(); o++) {
-            if (block.vtx[0]->vout[o].scriptPubKey.size() >= 38 && block.vtx[0]->vout[o].scriptPubKey[0] == OP_RETURN && block.vtx[0]->vout[o].scriptPubKey[1] == 0x24 && block.vtx[0]->vout[o].scriptPubKey[2] == 0xaa && block.vtx[0]->vout[o].scriptPubKey[3] == 0x21 && block.vtx[0]->vout[o].scriptPubKey[4] == 0xa9 && block.vtx[0]->vout[o].scriptPubKey[5] == 0xed) {
-                commitpos = o;
-            }
-        }
-    }
-    return commitpos;
-}
-
 void UpdateUncommittedBlockStructures(CBlock& block, const CBlockIndex* pindexPrev, const Consensus::Params& consensusParams)
 {
-    int commitpos = GetWitnessCommitmentIndex(block);
+    int commitpos = block.GetWitnessCommitmentIndex();
     static const std::vector<unsigned char> nonce(32, 0x00);
     if (commitpos != -1 && IsWitnessEnabled(pindexPrev, consensusParams) && !block.vtx[0]->HasWitness()) {
         CMutableTransaction tx(*block.vtx[0]);
@@ -3363,7 +3350,7 @@ void UpdateUncommittedBlockStructures(CBlock& block, const CBlockIndex* pindexPr
 std::vector<unsigned char> GenerateCoinbaseCommitment(CBlock& block, const CBlockIndex* pindexPrev, const Consensus::Params& consensusParams)
 {
     std::vector<unsigned char> commitment;
-    int commitpos = GetWitnessCommitmentIndex(block);
+    int commitpos = block.GetWitnessCommitmentIndex();
     std::vector<unsigned char> ret(32, 0x00);
     if (consensusParams.SegwitHeight != std::numeric_limits<int>::max()) {
         if (commitpos == -1) {
@@ -3503,7 +3490,7 @@ static bool ContextualCheckBlock(const CBlock& block, BlockValidationState& stat
     //   multiple, the last one is used.
     bool fHaveWitness = false;
     if (nHeight >= consensusParams.SegwitHeight) {
-        int commitpos = GetWitnessCommitmentIndex(block);
+        int commitpos = block.GetWitnessCommitmentIndex();
         if (commitpos != -1) {
             bool malleated = false;
             uint256 hashWitness = BlockWitnessMerkleRoot(block, &malleated);
diff --git a/src/validation.h b/src/validation.h
index 54f97e721325..5e555e5856d4 100644
--- a/src/validation.h
+++ b/src/validation.h
@@ -382,9 +382,6 @@ bool IsWitnessEnabled(const CBlockIndex* pindexPrev, const Consensus::Params& pa
 /** When there are blocks in the active chain with missing data, rewind the chainstate and remove them from the block index */
 bool RewindBlockIndex(const CChainParams& params) LOCKS_EXCLUDED(cs_main);
 
-/** Compute at which vout of the block's coinbase transaction the witness commitment occurs, or -1 if not found */
-int GetWitnessCommitmentIndex(const CBlock& block);
-
 /** Update uncommitted block structures (currently: only the witness reserved value). This is safe for submitted blocks. */
 void UpdateUncommittedBlockStructures(CBlock& block, const CBlockIndex* pindexPrev, const Consensus::Params& consensusParams);
 

From 1fd487727541540a308bcccd28a90a287428c7da Mon Sep 17 00:00:00 2001
From: Karl-Johan Alm <karljohan-alm@garage.co.jp>
Date: Wed, 17 Jul 2019 17:38:43 +0900
Subject: [PATCH 02/17] add simple signature support (checker/creator)

The simple signature takes a sighash as argument and verifies a signature and pubkey against it. It is used in signet for verifying blocks, but can be used for practically anything.
---
 src/script/interpreter.cpp | 14 ++++++++++++++
 src/script/interpreter.h   | 12 ++++++++++++
 src/script/sign.cpp        |  9 +++++++++
 src/script/sign.h          | 11 +++++++++++
 4 files changed, 46 insertions(+)

diff --git a/src/script/interpreter.cpp b/src/script/interpreter.cpp
index ad833bc025eb..6ce7d16725d8 100644
--- a/src/script/interpreter.cpp
+++ b/src/script/interpreter.cpp
@@ -1416,6 +1416,20 @@ bool GenericTransactionSignatureChecker<T>::CheckSequence(const CScriptNum& nSeq
 template class GenericTransactionSignatureChecker<CTransaction>;
 template class GenericTransactionSignatureChecker<CMutableTransaction>;
 
+bool SimpleSignatureChecker::CheckSig(const std::vector<unsigned char>& vchSigIn, const std::vector<unsigned char>& vchPubKey, const CScript& scriptCode, SigVersion sigversion) const
+{
+    CPubKey pubkey(vchPubKey);
+    if (!pubkey.IsValid()) return false;
+
+    // Hash type is one byte tacked on to the end of the signature
+    std::vector<unsigned char> vchSig(vchSigIn);
+    if (vchSig.empty()) return false;
+    // int nHashType = vchSig.back();
+    vchSig.pop_back();
+
+    return pubkey.Verify(hash, vchSig);
+}
+
 static bool VerifyWitnessProgram(const CScriptWitness& witness, int witversion, const std::vector<unsigned char>& program, unsigned int flags, const BaseSignatureChecker& checker, ScriptError* serror)
 {
     std::vector<std::vector<unsigned char> > stack;
diff --git a/src/script/interpreter.h b/src/script/interpreter.h
index d63d8b85b7b4..06fc3d1f85e2 100644
--- a/src/script/interpreter.h
+++ b/src/script/interpreter.h
@@ -161,6 +161,18 @@ class BaseSignatureChecker
     virtual ~BaseSignatureChecker() {}
 };
 
+/** A general purpose signature checker. */
+class SimpleSignatureChecker : public BaseSignatureChecker
+{
+private:
+    uint256 hash;
+
+public:
+    const uint256& GetHash() const { return hash; }
+    explicit SimpleSignatureChecker(const uint256& hash_in) : hash(hash_in) {}
+    bool CheckSig(const std::vector<unsigned char>& scriptSig, const std::vector<unsigned char>& vchPubKey, const CScript& scriptCode, SigVersion sigversion) const override;
+};
+
 template <class T>
 class GenericTransactionSignatureChecker : public BaseSignatureChecker
 {
diff --git a/src/script/sign.cpp b/src/script/sign.cpp
index 0ed92e8d5b08..11b035812cce 100644
--- a/src/script/sign.cpp
+++ b/src/script/sign.cpp
@@ -33,6 +33,15 @@ bool MutableTransactionSignatureCreator::CreateSig(const SigningProvider& provid
     return true;
 }
 
+bool SimpleSignatureCreator::CreateSig(const SigningProvider& provider, std::vector<unsigned char>& vchSig, const CKeyID& keyid, const CScript& scriptCode, SigVersion sigversion) const
+{
+    CKey key;
+    if (!provider.GetKey(keyid, key)) return false;
+    if (!key.Sign(checker.GetHash(), vchSig)) return false;
+    vchSig.push_back((unsigned char)SIGHASH_ALL);
+    return true;
+}
+
 static bool GetCScript(const SigningProvider& provider, const SignatureData& sigdata, const CScriptID& scriptid, CScript& script)
 {
     if (provider.GetCScript(scriptid, script)) {
diff --git a/src/script/sign.h b/src/script/sign.h
index 4c2403f83f3f..930c26a76375 100644
--- a/src/script/sign.h
+++ b/src/script/sign.h
@@ -31,6 +31,17 @@ class BaseSignatureCreator {
     virtual bool CreateSig(const SigningProvider& provider, std::vector<unsigned char>& vchSig, const CKeyID& keyid, const CScript& scriptCode, SigVersion sigversion) const =0;
 };
 
+/** A general purpose signature creator. */
+class SimpleSignatureCreator : public BaseSignatureCreator
+{
+    SimpleSignatureChecker checker;
+
+public:
+    explicit SimpleSignatureCreator(const uint256& hashIn) : BaseSignatureCreator(), checker(hashIn) {};
+    const BaseSignatureChecker& Checker() const override { return checker; }
+    bool CreateSig(const SigningProvider& provider, std::vector<unsigned char>& vchSig, const CKeyID& keyid, const CScript& scriptCode, SigVersion sigversion) const override;
+};
+
 /** A signature creator for transactions. */
 class MutableTransactionSignatureCreator : public BaseSignatureCreator {
     const CMutableTransaction* txTo;

From 58ab450de1bd8710e8b389fc06cdd6058af4254d Mon Sep 17 00:00:00 2001
From: Karl-Johan Alm <karljohan-alm@garage.co.jp>
Date: Wed, 17 Jul 2019 17:41:32 +0900
Subject: [PATCH 03/17] add signet basic support (signet.cpp)

---
 src/Makefile.am        |  2 ++
 src/consensus/params.h |  6 +++++
 src/signet.cpp         | 57 ++++++++++++++++++++++++++++++++++++++++++
 src/signet.h           | 43 +++++++++++++++++++++++++++++++
 4 files changed, 108 insertions(+)
 create mode 100644 src/signet.cpp
 create mode 100644 src/signet.h

diff --git a/src/Makefile.am b/src/Makefile.am
index 27c87688b42e..d4516d06efea 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -195,6 +195,7 @@ BITCOIN_CORE_H = \
   script/signingprovider.h \
   script/standard.h \
   shutdown.h \
+  signet.h \
   streams.h \
   support/allocators/secure.h \
   support/allocators/zeroafterfree.h \
@@ -484,6 +485,7 @@ libbitcoin_common_a_SOURCES = \
   script/sign.cpp \
   script/signingprovider.cpp \
   script/standard.cpp \
+  signet.cpp \
   versionbitsinfo.cpp \
   warnings.cpp \
   $(BITCOIN_CORE_H)
diff --git a/src/consensus/params.h b/src/consensus/params.h
index e191fd6d26bd..ef149d9daca6 100644
--- a/src/consensus/params.h
+++ b/src/consensus/params.h
@@ -80,6 +80,12 @@ struct Params {
     int64_t DifficultyAdjustmentInterval() const { return nPowTargetTimespan / nPowTargetSpacing; }
     uint256 nMinimumChainWork;
     uint256 defaultAssumeValid;
+
+    /**
+     * If true, witness commitments contain a payload equal to a Bitcoin Script solution
+     * to a signet challenge as defined in the chain params.
+     */
+    bool signet_blocks{false};
 };
 } // namespace Consensus
 
diff --git a/src/signet.cpp b/src/signet.cpp
new file mode 100644
index 000000000000..e6b8d32186cd
--- /dev/null
+++ b/src/signet.cpp
@@ -0,0 +1,57 @@
+// Copyright (c) 2019 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <signet.h>
+
+#include <consensus/merkle.h>
+#include <consensus/params.h>
+#include <hash.h>
+#include <primitives/block.h>
+#include <script/interpreter.h>
+#include <script/standard.h>        // MANDATORY_SCRIPT_VERIFY_FLAGS
+#include <util/system.h>
+
+CScript g_signet_blockscript;
+
+// Signet block solution checker
+bool CheckBlockSolution(const CBlock& block, const Consensus::Params& consensusParams)
+{
+    std::vector<uint8_t> signet_data;
+    if (!block.GetWitnessCommitmentSection(SIGNET_HEADER, signet_data)) {
+        return error("CheckBlockSolution: Errors in block (block solution missing)");
+    }
+    if (!CheckBlockSolution(GetSignetHash(block), signet_data, consensusParams)) {
+        return error("CheckBlockSolution: Errors in block (block solution invalid)");
+    }
+    return true;
+}
+
+bool CheckBlockSolution(const uint256& signet_hash, const std::vector<uint8_t>& signature, const Consensus::Params& params)
+{
+    SimpleSignatureChecker bsc(signet_hash);
+    CScript solution = CScript(signature.begin(), signature.end());
+    return VerifyScript(solution, g_signet_blockscript, nullptr, MANDATORY_SCRIPT_VERIFY_FLAGS, bsc);
+}
+
+uint256 BlockSignetMerkleRoot(const CBlock& block, bool* mutated = nullptr)
+{
+    std::vector<uint256> leaves;
+    leaves.resize(block.vtx.size());
+    {
+        // find and delete signet signature
+        CMutableTransaction mtx(*block.vtx.at(0));
+        CBlock::SetWitnessCommitmentSection(mtx, SIGNET_HEADER, std::vector<uint8_t>{});
+        leaves[0] = mtx.GetHash();
+    }
+    for (size_t s = 1; s < block.vtx.size(); s++) {
+        leaves[s] = block.vtx[s]->GetHash();
+    }
+    return ComputeMerkleRoot(std::move(leaves), mutated);
+}
+
+uint256 GetSignetHash(const CBlock& block)
+{
+    if (block.vtx.size() == 0) return block.GetHash();
+    return (CHashWriter(SER_DISK, PROTOCOL_VERSION) << block.nVersion << block.hashPrevBlock << BlockSignetMerkleRoot(block) << block.nTime << block.nBits).GetHash();
+}
diff --git a/src/signet.h b/src/signet.h
new file mode 100644
index 000000000000..b1945dab46dd
--- /dev/null
+++ b/src/signet.h
@@ -0,0 +1,43 @@
+// Copyright (c) 2019 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_SIGNET_H
+#define BITCOIN_SIGNET_H
+
+#if defined(HAVE_CONFIG_H)
+#include <config/bitcoin-config.h>
+#endif
+
+#include <consensus/params.h>
+
+#include <stdint.h>
+
+class CBlock;
+class uint256;
+class CScript;
+
+extern CScript g_signet_blockscript;
+
+constexpr uint8_t SIGNET_HEADER[4] = {0xec, 0xc7, 0xda, 0xa2};
+
+/**
+ * Check whether a block has a valid solution
+ */
+bool CheckBlockSolution(const uint256& signet_hash, const std::vector<uint8_t>& signature, const Consensus::Params&);
+
+/**
+ * Extract signature and check whether a block has a valid solution
+ */
+bool CheckBlockSolution(const CBlock& block, const Consensus::Params& consensusParams);
+
+/**
+ * Generate the signet hash for the given block
+ *
+ * The signet hash differs from the regular block hash in two places:
+ * 1. It hashes the witness root instead of the merkle root.
+ * 2. It skips the nonce.
+ */
+uint256 GetSignetHash(const CBlock& block);
+
+#endif // BITCOIN_SIGNET_H

From 96794970cdf5d233c0fdb33c508c82eb2729beb9 Mon Sep 17 00:00:00 2001
From: Karl-Johan Alm <karljohan-alm@garage.co.jp>
Date: Mon, 19 Aug 2019 11:56:55 +0900
Subject: [PATCH 04/17] add signet chain and accompanying parameters

---
 src/chainparams.cpp     | 114 ++++++++++++++++++++++++++++++++++++++--
 src/chainparams.h       |   5 ++
 src/chainparamsbase.cpp |  12 ++++-
 src/chainparamsbase.h   |   1 +
 src/util/system.cpp     |  10 +++-
 5 files changed, 135 insertions(+), 7 deletions(-)

diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index 0a1cb858ef56..d34456883067 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -7,6 +7,8 @@
 
 #include <chainparamsseeds.h>
 #include <consensus/merkle.h>
+#include <hash.h> // for signet block challenge hash
+#include <signet.h>
 #include <tinyformat.h>
 #include <util/system.h>
 #include <util/strencodings.h>
@@ -17,13 +19,13 @@
 #include <boost/algorithm/string/classification.hpp>
 #include <boost/algorithm/string/split.hpp>
 
-static CBlock CreateGenesisBlock(const char* pszTimestamp, const CScript& genesisOutputScript, uint32_t nTime, uint32_t nNonce, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward)
+static inline CBlock CreateGenesisBlock(const CScript& coinbase_sig, const CScript& genesisOutputScript, uint32_t nTime, uint32_t nNonce, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward)
 {
     CMutableTransaction txNew;
     txNew.nVersion = 1;
     txNew.vin.resize(1);
     txNew.vout.resize(1);
-    txNew.vin[0].scriptSig = CScript() << 486604799 << CScriptNum(4) << std::vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp));
+    txNew.vin[0].scriptSig = coinbase_sig;
     txNew.vout[0].nValue = genesisReward;
     txNew.vout[0].scriptPubKey = genesisOutputScript;
 
@@ -38,6 +40,12 @@ static CBlock CreateGenesisBlock(const char* pszTimestamp, const CScript& genesi
     return genesis;
 }
 
+static inline CBlock CreateGenesisBlock(const char* pszTimestamp, const CScript& genesisOutputScript, uint32_t nTime, uint32_t nNonce, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward)
+{
+    CScript coinbase_sig = CScript() << 486604799 << CScriptNum(4) << std::vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp));
+    return CreateGenesisBlock(coinbase_sig, genesisOutputScript, nTime, nNonce, nBits, nVersion, genesisReward);
+}
+
 /**
  * Build the genesis block. Note that the output of its generation
  * transaction cannot be spent since it did not originally exist in the
@@ -49,13 +57,23 @@ static CBlock CreateGenesisBlock(const char* pszTimestamp, const CScript& genesi
  *     CTxOut(nValue=50.00000000, scriptPubKey=0x5F1DF16B2B704C8A578D0B)
  *   vMerkleTree: 4a5e1e
  */
-static CBlock CreateGenesisBlock(uint32_t nTime, uint32_t nNonce, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward)
+static inline CBlock CreateGenesisBlock(uint32_t nTime, uint32_t nNonce, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward)
 {
     const char* pszTimestamp = "The Times 03/Jan/2009 Chancellor on brink of second bailout for banks";
     const CScript genesisOutputScript = CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f") << OP_CHECKSIG;
     return CreateGenesisBlock(pszTimestamp, genesisOutputScript, nTime, nNonce, nBits, nVersion, genesisReward);
 }
 
+CBlock CreateSignetGenesisBlock(const CScript& block_script, uint32_t block_nonce)
+{
+    CHashWriter h(SER_DISK, 0);
+    h << block_script;
+    uint256 hash = h.GetHash();
+    CScript coinbase_sig = CScript() << std::vector<uint8_t>(hash.begin(), hash.end());
+    CScript genesis_out = CScript() << OP_RETURN;
+    return CreateGenesisBlock(coinbase_sig, genesis_out, 1534313275, block_nonce, 0x1e2adc28, 1, 50 * COIN);
+}
+
 /**
  * Main network
  */
@@ -63,6 +81,7 @@ class CMainParams : public CChainParams {
 public:
     CMainParams() {
         strNetworkID = CBaseChainParams::MAIN;
+        consensus.signet_blocks = false;
         consensus.nSubsidyHalvingInterval = 210000;
         consensus.BIP16Exception = uint256S("0x00000000000002dc756eebf4f49723ed8d30cc28a5f108eb94b1ba88ac4f9c22");
         consensus.BIP34Height = 227931;
@@ -170,6 +189,7 @@ class CTestNetParams : public CChainParams {
 public:
     CTestNetParams() {
         strNetworkID = CBaseChainParams::TESTNET;
+        consensus.signet_blocks = false;
         consensus.nSubsidyHalvingInterval = 210000;
         consensus.BIP16Exception = uint256S("0x00000000dd30457c001f4095d208cc1296b0eed002427aa599874af7a432b105");
         consensus.BIP34Height = 21111;
@@ -248,6 +268,89 @@ class CTestNetParams : public CChainParams {
     }
 };
 
+/**
+ * SigNet
+ */
+class SigNetParams : public CChainParams {
+public:
+    explicit SigNetParams(const ArgsManager& args) {
+        std::vector<uint8_t> bin;
+        vSeeds.clear();
+        uint32_t genesis_nonce = 0;
+
+        if (!args.IsArgSet("-signet_blockscript")) {
+            throw std::runtime_error(strprintf("%s: -signet_blockscript is mandatory for signet networks", __func__));
+        }
+        if (args.GetArgs("-signet_blockscript").size() != 1) {
+            throw std::runtime_error(strprintf("%s: -signet_blockscript cannot be multiple values.", __func__));
+        }
+        bin = ParseHex(args.GetArgs("-signet_blockscript")[0]);
+        if (args.IsArgSet("-signet_genesisnonce")) {
+            genesis_nonce = args.GetArg("-signet_genesisnonce", 0);
+        }
+        if (args.IsArgSet("-signet_seednode")) {
+            vSeeds = gArgs.GetArgs("-signet_seednode");
+        }
+
+        LogPrintf("SigNet with block script %s\n", gArgs.GetArgs("-signet_blockscript")[0]);
+
+        strNetworkID = CBaseChainParams::SIGNET;
+        g_signet_blockscript = CScript(bin.begin(), bin.end());
+        consensus.signet_blocks = true;
+        consensus.nSubsidyHalvingInterval = 210000;
+        consensus.BIP34Height = 1;
+        consensus.BIP65Height = 1;
+        consensus.BIP66Height = 1;
+        consensus.CSVHeight = 0;
+        consensus.SegwitHeight = 0;
+        consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
+        consensus.nPowTargetSpacing = 10 * 60;
+        consensus.fPowAllowMinDifficultyBlocks = false;
+        consensus.fPowNoRetargeting = false;
+        consensus.nRuleChangeActivationThreshold = 1916;
+        consensus.nMinerConfirmationWindow = 2016;
+        consensus.powLimit = uint256S("00002adc28cf53b63c82faa55d83e40ac63b5f100aa5d8df62a429192f9e8ce5");
+        consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;
+        consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = 1539478800;
+        consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
+
+        pchMessageStart[0] = 0xf0;
+        pchMessageStart[1] = 0xc7;
+        pchMessageStart[2] = 0x70;
+        pchMessageStart[3] = 0x6a;
+        nDefaultPort = 38333;
+        nPruneAfterHeight = 1000;
+
+        genesis = CreateSignetGenesisBlock(g_signet_blockscript, genesis_nonce);
+        consensus.hashGenesisBlock = genesis.GetHash();
+
+        // Now that genesis block has been generated, we check if there is an enforcescript, and switch
+        // to that one, as we will not be using the real block script anymore
+        if (args.IsArgSet("-signet_enforcescript")) {
+            if (args.GetArgs("-signet_enforcescript").size() != 1) {
+                throw std::runtime_error(strprintf("%s: -signet_enforcescript cannot be multiple values.", __func__));
+            }
+            bin = ParseHex(args.GetArgs("-signet_enforcescript")[0]);
+            g_signet_blockscript = CScript(bin.begin(), bin.end());
+            LogPrintf("SigNet enforce script %s\n", gArgs.GetArgs("-signet_enforcescript")[0]);
+        }
+
+        vFixedSeeds.clear();
+
+        base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>{125};
+        base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>{87};
+        base58Prefixes[SECRET_KEY] =     std::vector<unsigned char>{217};
+        base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};
+        base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
+
+        bech32_hrp = "sb" + args.GetArg("-signet_hrp", "");
+
+        fDefaultConsistencyChecks = false;
+        fRequireStandard = true;
+        m_is_test_chain = true;
+    }
+};
+
 /**
  * Regression test
  */
@@ -255,6 +358,7 @@ class CRegTestParams : public CChainParams {
 public:
     explicit CRegTestParams(const ArgsManager& args) {
         strNetworkID =  CBaseChainParams::REGTEST;
+        consensus.signet_blocks = false;
         consensus.nSubsidyHalvingInterval = 150;
         consensus.BIP16Exception = uint256();
         consensus.BIP34Height = 500; // BIP34 activated on regtest (Used in functional tests)
@@ -394,6 +498,9 @@ std::unique_ptr<const CChainParams> CreateChainParams(const std::string& chain)
         return std::unique_ptr<CChainParams>(new CTestNetParams());
     else if (chain == CBaseChainParams::REGTEST)
         return std::unique_ptr<CChainParams>(new CRegTestParams(gArgs));
+    else if (chain == CBaseChainParams::SIGNET) {
+        return std::unique_ptr<CChainParams>(new SigNetParams(gArgs));
+    }
     throw std::runtime_error(strprintf("%s: Unknown chain %s.", __func__, chain));
 }
 
@@ -402,3 +509,4 @@ void SelectParams(const std::string& network)
     SelectBaseParams(network);
     globalChainParams = CreateChainParams(network);
 }
+
diff --git a/src/chainparams.h b/src/chainparams.h
index 6be066806bcf..90c8a4e8f455 100644
--- a/src/chainparams.h
+++ b/src/chainparams.h
@@ -125,4 +125,9 @@ const CChainParams &Params();
  */
 void SelectParams(const std::string& chain);
 
+/**
+ * Create a Signet genesis block for the given block script/nonce.
+ */
+CBlock CreateSignetGenesisBlock(const CScript& block_script, uint32_t block_nonce=0);
+
 #endif // BITCOIN_CHAINPARAMS_H
diff --git a/src/chainparamsbase.cpp b/src/chainparamsbase.cpp
index 4bb66c8d8b51..5231ae5f97fe 100644
--- a/src/chainparamsbase.cpp
+++ b/src/chainparamsbase.cpp
@@ -13,6 +13,7 @@
 
 const std::string CBaseChainParams::MAIN = "main";
 const std::string CBaseChainParams::TESTNET = "test";
+const std::string CBaseChainParams::SIGNET = "signet";
 const std::string CBaseChainParams::REGTEST = "regtest";
 
 void SetupChainParamsBaseOptions()
@@ -23,6 +24,12 @@ void SetupChainParamsBaseOptions()
     gArgs.AddArg("-segwitheight=<n>", "Set the activation height of segwit. -1 to disable. (regtest-only)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
     gArgs.AddArg("-testnet", "Use the test chain. Equivalent to -chain=test.", ArgsManager::ALLOW_ANY, OptionsCategory::CHAINPARAMS);
     gArgs.AddArg("-vbparams=deployment:start:end", "Use given start/end times for specified version bits deployment (regtest-only)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::CHAINPARAMS);
+    gArgs.AddArg("-signet", "Use the signet chain. Note that the network is defined by the signet_blockscript parameter", ArgsManager::ALLOW_ANY, OptionsCategory::CHAINPARAMS);
+    gArgs.AddArg("-signet_blockscript", "Blocks must satisfy the given script to be considered valid (only for signet networks)", ArgsManager::ALLOW_STRING, OptionsCategory::CHAINPARAMS);
+    gArgs.AddArg("-signet_genesisnonce", "Nonce value for use in genesis block to satisfy proof of work requirement", ArgsManager::ALLOW_INT, OptionsCategory::CHAINPARAMS);
+    gArgs.AddArg("-signet_hrp", "Human readable part of bech32 address (suffixed by \"sb\"; default = \"\")", ArgsManager::ALLOW_ANY, OptionsCategory::CHAINPARAMS);
+    gArgs.AddArg("-signet_enforcescript", "Blocks must satisfy the given script to be considered valid (this replaces -signet_blockscript, and is used for opt-in-reorg mode)", ArgsManager::ALLOW_STRING, OptionsCategory::CHAINPARAMS);
+    gArgs.AddArg("-signet_seednode", "Specify a seed node for the signet network (may be used multiple times to specify multiple seed nodes)", ArgsManager::ALLOW_STRING, OptionsCategory::CHAINPARAMS);
 }
 
 static std::unique_ptr<CBaseChainParams> globalChainBaseParams;
@@ -41,8 +48,9 @@ std::unique_ptr<CBaseChainParams> CreateBaseChainParams(const std::string& chain
         return MakeUnique<CBaseChainParams>("testnet3", 18332);
     else if (chain == CBaseChainParams::REGTEST)
         return MakeUnique<CBaseChainParams>("regtest", 18443);
-    else
-        throw std::runtime_error(strprintf("%s: Unknown chain %s.", __func__, chain));
+    else if (chain == CBaseChainParams::SIGNET)
+        return MakeUnique<CBaseChainParams>("signet", 38332);
+    throw std::runtime_error(strprintf("%s: Unknown chain %s.", __func__, chain));
 }
 
 void SelectBaseParams(const std::string& chain)
diff --git a/src/chainparamsbase.h b/src/chainparamsbase.h
index 69fe2438f3af..bd9579539f7c 100644
--- a/src/chainparamsbase.h
+++ b/src/chainparamsbase.h
@@ -19,6 +19,7 @@ class CBaseChainParams
     /** Chain name strings */
     static const std::string MAIN;
     static const std::string TESTNET;
+    static const std::string SIGNET;
     static const std::string REGTEST;
     ///@}
 
diff --git a/src/util/system.cpp b/src/util/system.cpp
index 563ff6a54b35..ba19756ea6cc 100644
--- a/src/util/system.cpp
+++ b/src/util/system.cpp
@@ -269,6 +269,7 @@ const std::list<SectionInfo> ArgsManager::GetUnrecognizedSections() const
 {
     // Section names to be recognized in the config file.
     static const std::set<std::string> available_sections{
+        CBaseChainParams::SIGNET,
         CBaseChainParams::REGTEST,
         CBaseChainParams::TESTNET,
         CBaseChainParams::MAIN
@@ -862,15 +863,20 @@ std::string ArgsManager::GetChainName() const
 
     const bool fRegTest = get_net("-regtest");
     const bool fTestNet = get_net("-testnet");
+    const bool fSigNet  = get_net("-signet");
     const bool is_chain_arg_set = IsArgSet("-chain");
 
-    if ((int)is_chain_arg_set + (int)fRegTest + (int)fTestNet > 1) {
-        throw std::runtime_error("Invalid combination of -regtest, -testnet and -chain. Can use at most one.");
+    if ((int)is_chain_arg_set + (int)fRegTest + (int)fTestNet + (int)fSigNet > 1) {
+        throw std::runtime_error("Invalid combination of -regtest, -testnet, -signet and -chain. Can use at most one.");
     }
     if (fRegTest)
         return CBaseChainParams::REGTEST;
     if (fTestNet)
         return CBaseChainParams::TESTNET;
+    if (fSigNet) {
+        return CBaseChainParams::SIGNET;
+    }
+
     return GetArg("-chain", CBaseChainParams::MAIN);
 }
 

From c8bdfc8abec6ae0815a2cd8c16569c849c28f5a0 Mon Sep 17 00:00:00 2001
From: Karl-Johan Alm <karljohan-alm@garage.co.jp>
Date: Wed, 17 Jul 2019 17:55:13 +0900
Subject: [PATCH 05/17] qt: update QT to support signet network

---
 src/qt/guiconstants.h   | 1 +
 src/qt/networkstyle.cpp | 3 ++-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/qt/guiconstants.h b/src/qt/guiconstants.h
index dcdb2479770f..7a8c677b2853 100644
--- a/src/qt/guiconstants.h
+++ b/src/qt/guiconstants.h
@@ -47,6 +47,7 @@ static const int TOOLTIP_WRAP_THRESHOLD = 80;
 #define QAPP_APP_NAME_DEFAULT "Bitcoin-Qt"
 #define QAPP_APP_NAME_TESTNET "Bitcoin-Qt-testnet"
 #define QAPP_APP_NAME_REGTEST "Bitcoin-Qt-regtest"
+#define QAPP_APP_NAME_SIGNET "Bitcoin-Qt-signet"
 
 /* One gigabyte (GB) in bytes */
 static constexpr uint64_t GB_BYTES{1000000000};
diff --git a/src/qt/networkstyle.cpp b/src/qt/networkstyle.cpp
index 5c039a939eee..5a30bd165531 100644
--- a/src/qt/networkstyle.cpp
+++ b/src/qt/networkstyle.cpp
@@ -19,7 +19,8 @@ static const struct {
 } network_styles[] = {
     {"main", QAPP_APP_NAME_DEFAULT, 0, 0},
     {"test", QAPP_APP_NAME_TESTNET, 70, 30},
-    {"regtest", QAPP_APP_NAME_REGTEST, 160, 30}
+    {"regtest", QAPP_APP_NAME_REGTEST, 160, 30},
+    {"signet", QAPP_APP_NAME_SIGNET, 35, 15},
 };
 static const unsigned network_styles_count = sizeof(network_styles)/sizeof(*network_styles);
 

From 9c884e1d7e79bc841e327d7b62c80e46afb1d9cd Mon Sep 17 00:00:00 2001
From: Karl-Johan Alm <karljohan-alm@garage.co.jp>
Date: Wed, 17 Jul 2019 18:40:34 +0900
Subject: [PATCH 06/17] consensus: add signet validation

---
 src/validation.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/src/validation.cpp b/src/validation.cpp
index 9db40bd514df..6d6b93cc745f 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -31,6 +31,7 @@
 #include <script/script.h>
 #include <script/sigcache.h>
 #include <shutdown.h>
+#include <signet.h>
 #include <timedata.h>
 #include <tinyformat.h>
 #include <txdb.h>
@@ -1152,6 +1153,11 @@ bool ReadBlockFromDisk(CBlock& block, const FlatFilePos& pos, const Consensus::P
     if (!CheckProofOfWork(block.GetHash(), block.nBits, consensusParams))
         return error("ReadBlockFromDisk: Errors in block header at %s", pos.ToString());
 
+    if (consensusParams.signet_blocks && block.GetHash() != consensusParams.hashGenesisBlock && !CheckBlockSolution(block, consensusParams)) {
+        /* CheckBlockSolution() calls error(..) */
+        return false;
+    }
+
     return true;
 }
 
@@ -3272,6 +3278,10 @@ bool CheckBlock(const CBlock& block, BlockValidationState& state, const Consensu
     if (!CheckBlockHeader(block, state, consensusParams, fCheckPOW))
         return false;
 
+    if (consensusParams.signet_blocks && fCheckPOW && block.GetHash() != consensusParams.hashGenesisBlock && !CheckBlockSolution(block, consensusParams)) {
+        return false;
+    }
+
     // Check the merkle root.
     if (fCheckMerkleRoot) {
         bool mutated;

From e69ef6ebd2d2d585426ff4c4ee59ea66dee11daf Mon Sep 17 00:00:00 2001
From: Karl-Johan Alm <karljohan-alm@garage.co.jp>
Date: Thu, 18 Jul 2019 13:42:31 +0900
Subject: [PATCH 07/17] i/o: make DecodeHexBlk able to read block hex from file

---
 src/core_read.cpp | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/src/core_read.cpp b/src/core_read.cpp
index a3c9cf0159b3..de6c751789f7 100644
--- a/src/core_read.cpp
+++ b/src/core_read.cpp
@@ -158,10 +158,27 @@ bool DecodeHexBlockHeader(CBlockHeader& header, const std::string& hex_header)
     return true;
 }
 
+inline bool ReadFromDisk(const std::string& path, std::string& output)
+{
+    FILE* fp = fopen(path.c_str(), "rb");
+    if (!fp) return false;
+    char buf[1025];
+    size_t r;
+    buf[1024] = 0;
+    output = "";
+    while (0 < (r = fread(buf, 1, 1024, fp))) { buf[r] = 0; output += buf; }
+    while (output.size() > 0 && output[output.size() - 1] == '\n') output = output.substr(0, output.size() - 1);
+    fclose(fp);
+    return true;
+}
+
 bool DecodeHexBlk(CBlock& block, const std::string& strHexBlk)
 {
-    if (!IsHex(strHexBlk))
+    if (!IsHex(strHexBlk)) {
+        std::string actual;
+        if (ReadFromDisk(strHexBlk, actual)) return DecodeHexBlk(block, actual);
         return false;
+    }
 
     std::vector<unsigned char> blockData(ParseHex(strHexBlk));
     CDataStream ssBlock(blockData, SER_NETWORK, PROTOCOL_VERSION);

From a368d4d3ca2862bb61660233ad1d6455c2c79b6d Mon Sep 17 00:00:00 2001
From: Karl-Johan Alm <karljohan-alm@garage.co.jp>
Date: Thu, 18 Jul 2019 12:25:47 +0900
Subject: [PATCH 08/17] rpc: add getnewblockhex command for obtaining an
 unsigned block

---
 src/rpc/mining.cpp | 54 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)

diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index 85f9f1e8b76c..3bcfd35a689e 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -23,6 +23,7 @@
 #include <script/script.h>
 #include <script/signingprovider.h>
 #include <shutdown.h>
+#include <signet.h>
 #include <txmempool.h>
 #include <univalue.h>
 #include <util/fees.h>
@@ -215,6 +216,10 @@ static UniValue generatetoaddress(const JSONRPCRequest& request)
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Error: Invalid address");
     }
 
+    if (Params().GetConsensus().signet_blocks) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "Generating signet blocks require that you use getnewblockhex");
+    }
+
     CScript coinbase_script = GetScriptForDestination(destination);
 
     return generateBlocks(coinbase_script, nGenerate, nMaxTries);
@@ -989,6 +994,52 @@ static UniValue estimaterawfee(const JSONRPCRequest& request)
     return result;
 }
 
+//
+// signet
+//
+
+UniValue getnewblockhex(const JSONRPCRequest& request)
+{
+    RPCHelpMan{"getnewblockhex",
+        "\nGets hex representation of a proposed, unmined new signet block.\n",
+        {
+            {"coinbase_destination", RPCArg::Type::STR, RPCArg::Optional::NO, "Pay-out destination, as an address or a custom coinbase script"},
+        },
+        RPCResult{
+            "blockhex      (hex) The block hex\n"
+        },
+        RPCExamples{
+            HelpExampleCli("getnewblockhex", "bc1qkallealmkdwwyuc2tmf5c6hzmlaujq6jl38hpe")
+        }
+    }.Check(request);
+
+    if (!Params().GetConsensus().signet_blocks) {
+        throw std::runtime_error("getnewblockhex can only be used with signet networks");
+    }
+
+    CScript coinbase_script;
+    auto str = request.params[0].get_str();
+    if (IsValidDestinationString(str)) {
+        auto dest = DecodeDestination(str);
+        coinbase_script = GetScriptForDestination(dest);
+    } else {
+        util::insert(coinbase_script, ParseHexV(str, "coinbase_script"));
+    }
+
+    auto block = BlockAssembler(Params()).CreateNewBlock(coinbase_script)->block;
+    unsigned int extra_nonce = 0;
+    // we bump stuff to bop stuff, or merkle root will be 0, etc etc etc etc
+    {
+        LOCK(cs_main);
+        IncrementExtraNonce(&block, ::ChainActive().Tip(), extra_nonce);
+    }
+
+    CDataStream ssBlock(SER_NETWORK, PROTOCOL_VERSION);
+    ssBlock << block;
+
+    return HexStr(ssBlock.begin(), ssBlock.end());
+}
+
 // clang-format off
 static const CRPCCommand commands[] =
 { //  category              name                      actor (function)         argNames
@@ -1007,6 +1058,9 @@ static const CRPCCommand commands[] =
     { "util",               "estimatesmartfee",       &estimatesmartfee,       {"conf_target", "estimate_mode"} },
 
     { "hidden",             "estimaterawfee",         &estimaterawfee,         {"conf_target", "threshold"} },
+
+    /** Signet mining */
+    { "signet",             "getnewblockhex",         &getnewblockhex,         {"coinbase_destination"} },
 };
 // clang-format on
 

From 63dbb0a03f60f90ff60e03e15afde43f37f6cf50 Mon Sep 17 00:00:00 2001
From: Karl-Johan Alm <karljohan-alm@garage.co.jp>
Date: Thu, 18 Jul 2019 12:19:35 +0900
Subject: [PATCH 09/17] rpc: add signblock command

---
 src/wallet/rpcwallet.cpp | 78 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 78 insertions(+)

diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
index d906f6ddf072..593354ccb559 100644
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -4,6 +4,7 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <amount.h>
+#include <consensus/merkle.h> // for BlockMerkleRoot in signblock (signet)
 #include <core_io.h>
 #include <interfaces/chain.h>
 #include <key_io.h>
@@ -17,6 +18,7 @@
 #include <rpc/util.h>
 #include <script/descriptor.h>
 #include <script/sign.h>
+#include <signet.h>
 #include <util/bip32.h>
 #include <util/fees.h>
 #include <util/moneystr.h>
@@ -4219,6 +4221,79 @@ UniValue walletcreatefundedpsbt(const JSONRPCRequest& request)
     return result;
 }
 
+void SignBlockWithWallet(CBlock& block, CWallet* const pwallet)
+{
+    SignatureData solution_in;
+
+    std::vector<uint8_t> signet_commitment;
+    if (block.GetWitnessCommitmentSection(SIGNET_HEADER, signet_commitment) && signet_commitment.size() > 8) {
+        solution_in = SignatureData(CScript(signet_commitment.begin() + 8, signet_commitment.end()));
+    }
+
+    auto signet_hash = GetSignetHash(block);
+
+    CScript blockscript(g_signet_blockscript.begin(), g_signet_blockscript.end());
+
+    SignatureData solution(solution_in);
+    bool res = ProduceSignature(*pwallet->GetSigningProvider(blockscript), SimpleSignatureCreator(signet_hash), blockscript, solution);
+    if (!res) {
+        throw JSONRPCError(RPC_VERIFY_ERROR, "could not produce a signature -- do you have the private key(s)?");
+    }
+    signet_commitment.clear();
+    signet_commitment.insert(signet_commitment.begin(), solution.scriptSig.begin(), solution.scriptSig.end());
+    block.SetWitnessCommitmentSection(SIGNET_HEADER, signet_commitment);
+}
+
+UniValue signblock(const JSONRPCRequest& request)
+{
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    CWallet* const pwallet = wallet.get();
+
+    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
+        return NullUniValue;
+    }
+
+    RPCHelpMan{"signblock",
+        "\nSigns a block proposal, checking that it would be accepted first.\n"
+        "(Note: only useable with signet networks.)\n",
+        {
+            {"blockhex", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The hex-encoded block from getnewblockhex, or a filename"},
+        },
+        RPCResult{
+            " sig      (hex) The signature\n"
+        },
+        RPCExamples{
+            HelpExampleCli("signblock", "0000002018c6f2f913f9902aeab...5ca501f77be96de63f609010000000000000000015100000000")
+        },
+    }.Check(request);
+
+    if (!Params().GetConsensus().signet_blocks) {
+        throw std::runtime_error("signblock can only be used with signet networks");
+    }
+
+    CBlock block;
+
+    if (!DecodeHexBlk(block, request.params[0].get_str())) {
+        throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block decode failed");
+    }
+
+    auto locked_chain = pwallet->chain().lock();
+    LOCK(pwallet->cs_wallet);
+
+    uint256 hash = block.GetHash();
+    if (nullopt != locked_chain->getBlockHeight(hash)) {
+        throw JSONRPCError(RPC_VERIFY_ERROR, "already have block");
+    }
+
+    SignBlockWithWallet(block, pwallet);
+    block.hashMerkleRoot = BlockMerkleRoot(block);
+
+    CDataStream ssBlock(SER_NETWORK, PROTOCOL_VERSION);
+    ssBlock << block;
+
+    return HexStr(ssBlock.begin(), ssBlock.end());
+}
+
 UniValue abortrescan(const JSONRPCRequest& request); // in rpcdump.cpp
 UniValue dumpprivkey(const JSONRPCRequest& request); // in rpcdump.cpp
 UniValue importprivkey(const JSONRPCRequest& request);
@@ -4290,6 +4365,9 @@ static const CRPCCommand commands[] =
     { "wallet",             "walletpassphrase",                 &walletpassphrase,              {"passphrase","timeout"} },
     { "wallet",             "walletpassphrasechange",           &walletpassphrasechange,        {"oldpassphrase","newpassphrase"} },
     { "wallet",             "walletprocesspsbt",                &walletprocesspsbt,             {"psbt","sign","sighashtype","bip32derivs"} },
+
+    /** Signet mining */
+    { "signet",             "signblock",                        &signblock,                     {"blockhex"} },
 };
 // clang-format on
 

From ebcbe739f329d3bc10fdb996be82f39ad17cf311 Mon Sep 17 00:00:00 2001
From: Karl-Johan Alm <karljohan-alm@garage.co.jp>
Date: Thu, 18 Jul 2019 12:21:00 +0900
Subject: [PATCH 10/17] rpc: include signet commitment in blockToJSON
 dictionary results

---
 src/rpc/blockchain.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index 946152d9aa38..0b7f791c163a 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -24,6 +24,7 @@
 #include <rpc/server.h>
 #include <rpc/util.h>
 #include <script/descriptor.h>
+#include <signet.h> // for blockToJSON signet_commitment printing
 #include <streams.h>
 #include <sync.h>
 #include <txdb.h>
@@ -168,6 +169,12 @@ UniValue blockToJSON(const CBlock& block, const CBlockIndex* tip, const CBlockIn
         result.pushKV("previousblockhash", blockindex->pprev->GetBlockHash().GetHex());
     if (pnext)
         result.pushKV("nextblockhash", pnext->GetBlockHash().GetHex());
+    if (Params().GetConsensus().signet_blocks) {
+        std::vector<uint8_t> signet_commitment;
+        if (block.GetWitnessCommitmentSection(SIGNET_HEADER, signet_commitment)) {
+            result.pushKV("signet-solution", HexStr(signet_commitment));
+        }
+    }
     return result;
 }
 

From 5a3f1dcef5f05c52e0b84ffbd7c7428573c4c1c0 Mon Sep 17 00:00:00 2001
From: Karl-Johan Alm <karljohan-alm@garage.co.jp>
Date: Mon, 19 Aug 2019 12:01:49 +0900
Subject: [PATCH 11/17] rpc: refactor out grindBlock part from generateBlocks

---
 src/rpc/mining.cpp | 35 +++++++++++++++++++++++------------
 1 file changed, 23 insertions(+), 12 deletions(-)

diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index 3bcfd35a689e..797e301db119 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -103,6 +103,25 @@ static UniValue getnetworkhashps(const JSONRPCRequest& request)
     return GetNetworkHashPS(!request.params[0].isNull() ? request.params[0].get_int() : 120, !request.params[1].isNull() ? request.params[1].get_int() : -1);
 }
 
+static bool grindBlock(CBlock* pblock, uint64_t& nMaxTries, uint256& result, bool grind_only=false)
+{
+    while (nMaxTries > 0 && pblock->nNonce < std::numeric_limits<uint32_t>::max() && !CheckProofOfWork(pblock->GetHash(), pblock->nBits, Params().GetConsensus()) && !ShutdownRequested()) {
+        ++pblock->nNonce;
+        --nMaxTries;
+    }
+    if (ShutdownRequested()) {
+        return false;
+    }
+    if (!CheckProofOfWork(pblock->GetHash(), pblock->nBits, Params().GetConsensus())) return false;
+    result = pblock->GetHash();
+    if (grind_only) return true;
+    std::shared_ptr<const CBlock> shared_pblock = std::make_shared<const CBlock>(*pblock);
+    if (!ProcessNewBlock(Params(), shared_pblock, true, nullptr)) {
+        throw JSONRPCError(RPC_INTERNAL_ERROR, "ProcessNewBlock, block not accepted");
+    }
+    return true;
+}
+
 static UniValue generateBlocks(const CScript& coinbase_script, int nGenerate, uint64_t nMaxTries)
 {
     int nHeightEnd = 0;
@@ -114,6 +133,7 @@ static UniValue generateBlocks(const CScript& coinbase_script, int nGenerate, ui
         nHeightEnd = nHeight+nGenerate;
     }
     unsigned int nExtraNonce = 0;
+    uint256 result;
     UniValue blockHashes(UniValue::VARR);
     while (nHeight < nHeightEnd && !ShutdownRequested())
     {
@@ -125,21 +145,12 @@ static UniValue generateBlocks(const CScript& coinbase_script, int nGenerate, ui
             LOCK(cs_main);
             IncrementExtraNonce(pblock, ::ChainActive().Tip(), nExtraNonce);
         }
-        while (nMaxTries > 0 && pblock->nNonce < std::numeric_limits<uint32_t>::max() && !CheckProofOfWork(pblock->GetHash(), pblock->nBits, Params().GetConsensus()) && !ShutdownRequested()) {
-            ++pblock->nNonce;
-            --nMaxTries;
-        }
-        if (nMaxTries == 0 || ShutdownRequested()) {
-            break;
-        }
-        if (pblock->nNonce == std::numeric_limits<uint32_t>::max()) {
+        if (!grindBlock(&pblocktemplate->block, nMaxTries, result)) {
+            if (nMaxTries == 0) break;
             continue;
         }
-        std::shared_ptr<const CBlock> shared_pblock = std::make_shared<const CBlock>(*pblock);
-        if (!ProcessNewBlock(Params(), shared_pblock, true, nullptr))
-            throw JSONRPCError(RPC_INTERNAL_ERROR, "ProcessNewBlock, block not accepted");
         ++nHeight;
-        blockHashes.push_back(pblock->GetHash().GetHex());
+        blockHashes.push_back(result.GetHex());
     }
     return blockHashes;
 }

From 7c7a78335682f4abc513e268a702431a0813cfb9 Mon Sep 17 00:00:00 2001
From: Karl-Johan Alm <karljohan-alm@garage.co.jp>
Date: Mon, 19 Aug 2019 12:05:43 +0900
Subject: [PATCH 12/17] rpc: add grindblock command for generating POW on a
 signed signet block

---
 src/rpc/client.cpp |  1 +
 src/rpc/mining.cpp | 56 ++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 57 insertions(+)

diff --git a/src/rpc/client.cpp b/src/rpc/client.cpp
index dfca1697c12a..236d697b7582 100644
--- a/src/rpc/client.cpp
+++ b/src/rpc/client.cpp
@@ -53,6 +53,7 @@ static const CRPCConvertParam vRPCConvertParams[] =
     { "getbalance", 2, "include_watchonly" },
     { "getbalance", 3, "avoid_reuse" },
     { "getblockhash", 0, "height" },
+    { "grindblock", 1, "maxtries" },
     { "waitforblockheight", 0, "height" },
     { "waitforblockheight", 1, "timeout" },
     { "waitforblock", 1, "timeout" },
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index 797e301db119..ad05df58ae35 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -1051,6 +1051,61 @@ UniValue getnewblockhex(const JSONRPCRequest& request)
     return HexStr(ssBlock.begin(), ssBlock.end());
 }
 
+static UniValue grindblock(const JSONRPCRequest& request)
+{
+    RPCHelpMan{"grindblock",
+        "\nGrind the given signet block to find valid proof of work\n"
+        "May fail if it reaches maxtries attempts.\n",
+        {
+            {"blockhex", RPCArg::Type::STR, RPCArg::Optional::NO, "The block data, or a script challenge, for new Signet networks"},
+            {"maxtries", RPCArg::Type::NUM, /* default */ "1000000", "How many iterations to try."},
+        },
+        {
+            RPCResult{"for block data",
+                "blockhash     (hex) resulting block hash, or null if none was found\n"
+            },
+            RPCResult{"for script challenge",
+                "nonce         (number) resulting nonce value which satisfies the proof of work requirement"
+            },
+        },
+        RPCExamples{
+            "\nGrind a block with hex $blockhex\n"
+            + HelpExampleCli("grindblock", "$blockhex")
+            + "\nCreate a new signet network with challenge 512103ad5e0edad18cb1f0fc0d28a3d4f1f3e445640337489abb10404f2d1e086be43051ae\n"
+            + HelpExampleCli("grindblock", "512103ad5e0edad18cb1f0fc0d28a3d4f1f3e445640337489abb10404f2d1e086be43051ae")
+        },
+    }.Check(request);
+
+    bool grinding_nonce = false;
+    CBlock block;
+    if (DecodeHexBlk(block, request.params[0].get_str())) {
+        if (!Params().GetConsensus().signet_blocks) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "Grinding blocks is only possible in a signet network; if you want to make a new Signet network, provide the challenge instead");
+        }
+
+        std::vector<uint8_t> signet_commitment;
+        if (!block.GetWitnessCommitmentSection(SIGNET_HEADER, signet_commitment)) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "Block has no signet commitment; please sign it first");
+        }
+    } else {
+        auto bin = ParseHexV(request.params[0], "challenge");
+        block = CreateSignetGenesisBlock(CScript(bin.begin(), bin.end()));
+        grinding_nonce = true;
+    }
+
+    uint64_t max_tries = request.params[1].isNull() ? 1000000 : request.params[1].get_int();
+    uint256 result;
+    while (max_tries > 0 && !ShutdownRequested()) {
+        if (grindBlock(&block, max_tries, result, grinding_nonce)) {
+            if (grinding_nonce) return (uint64_t)block.nNonce;
+            return result.GetHex();
+        }
+        if (max_tries == 0) break;
+    }
+
+    return false;
+}
+
 // clang-format off
 static const CRPCCommand commands[] =
 { //  category              name                      actor (function)         argNames
@@ -1072,6 +1127,7 @@ static const CRPCCommand commands[] =
 
     /** Signet mining */
     { "signet",             "getnewblockhex",         &getnewblockhex,         {"coinbase_destination"} },
+    { "signet",             "grindblock",             &grindblock,             {"blockhex", "maxtries"} },
 };
 // clang-format on
 

From 6fb40a5b243553c9a28b127f3d05683c1d090533 Mon Sep 17 00:00:00 2001
From: Karl-Johan Alm <karljohan-alm@garage.co.jp>
Date: Fri, 23 Aug 2019 14:01:45 +0900
Subject: [PATCH 13/17] rpc/signet: show signet blockscript in
 'getblockchaininfo'

---
 src/rpc/blockchain.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index 0b7f791c163a..a7de495c488a 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -1284,6 +1284,9 @@ UniValue getblockchaininfo(const JSONRPCRequest& request)
     }
 
     const Consensus::Params& consensusParams = Params().GetConsensus();
+    if (consensusParams.signet_blocks) {
+        obj.pushKV("signet-blockscript", HexStr(g_signet_blockscript));
+    }
     UniValue softforks(UniValue::VOBJ);
     BuriedForkDescPushBack(softforks, "bip34", consensusParams.BIP34Height);
     BuriedForkDescPushBack(softforks, "bip66", consensusParams.BIP66Height);

From a9667dfab892ba8d1b67b69e1cc7907ceef05394 Mon Sep 17 00:00:00 2001
From: Karl-Johan Alm <karljohan-alm@garage.co.jp>
Date: Tue, 6 Aug 2019 00:01:54 +0900
Subject: [PATCH 14/17] test: added signet mining tests

Also adds a condition to test initialization code to not generate blocks for signet chains.
---
 test/functional/mining_signet.py              | 95 +++++++++++++++++++
 test/functional/rpc_help.py                   |  2 +-
 test/functional/test_framework/mininode.py    |  1 +
 .../test_framework/test_framework.py          | 30 +++---
 test/functional/test_runner.py                |  1 +
 5 files changed, 114 insertions(+), 15 deletions(-)
 create mode 100755 test/functional/mining_signet.py

diff --git a/test/functional/mining_signet.py b/test/functional/mining_signet.py
new file mode 100755
index 000000000000..67e682a95d7f
--- /dev/null
+++ b/test/functional/mining_signet.py
@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+# Copyright (c) 2019 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+"""Test signet mining RPCs
+
+- getmininginfo
+- getblocktemplate proposal mode
+- submitblock"""
+
+from decimal import Decimal
+
+from test_framework.blocktools import (
+    create_coinbase,
+)
+from test_framework.messages import (
+    CBlock,
+)
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import (
+    assert_equal,
+)
+
+private_key  = "ZFNp4W4HSatHDc4zsheMsDWgUg2uiB5PtnY2Y2hUCNCkQiF81KyV"
+pubkey       = "02c72b24ae2ee333f2da24aea66ce4338c01db8f26d0cc96f586d77edcb5238a4f"
+address      = "sb1qghzjzc0jvkjvvvymxnadmjjpu2tywmvagduwfj"
+blockscript  = "5121" + pubkey + "51ae" # 1-of-1 multisig
+genesisnonce = 405557
+
+def assert_template(node, block, expect, rehash=True):
+    if rehash:
+        block.hashMerkleRoot = block.calc_merkle_root()
+    rsp = node.getblocktemplate(template_request={'data': block.serialize().hex(), 'mode': 'proposal', 'rules': ['segwit']})
+    assert_equal(rsp, expect)
+
+def generate(node, count):
+    for _ in range(count):
+        addr = node.getnewaddress()
+        block = node.getnewblockhex(addr)
+        signed = node.signblock(block)
+        node.grindblock(signed)
+
+
+class SigMiningTest(BitcoinTestFramework):
+    def set_test_params(self):
+        self.chain = "signet"
+        self.num_nodes = 2
+        self.setup_clean_chain = True
+        shared_args = ["-signet_blockscript=" + blockscript, "-signet_genesisnonce=" + str(genesisnonce), "-signet_seednode=localhost:1234"]
+        self.extra_args = [shared_args, shared_args]
+
+    def skip_test_if_missing_module(self):
+        self.skip_if_no_wallet()
+
+    def run_test(self):
+        node = self.nodes[0]
+
+        # give the privkey to node 1 so it can sign
+        node.importprivkey(private_key)
+        self.log.info('Imported network private key')
+        self.log.info('address: %s, privkey: %s', address, node.dumpprivkey(address))
+
+        self.log.info('getmininginfo')
+        mining_info = node.getmininginfo()
+        assert_equal(mining_info['blocks'], 0)
+        assert_equal(mining_info['chain'], 'signet')
+        assert 'currentblocktx' not in mining_info
+        assert 'currentblockweight' not in mining_info
+        assert_equal(mining_info['networkhashps'], Decimal('0'))
+        assert_equal(mining_info['pooledtx'], 0)
+
+        # Mine a block to leave initial block download
+        # Actually we mine 20 cause there's a bug in the coinbase height serializers
+
+        generate(node, 20)
+        tmpl = node.getblocktemplate({'rules': ['segwit']})
+        self.log.info("getblocktemplate: Test capability advertised")
+        assert 'proposal' in tmpl['capabilities']
+        assert 'coinbasetxn' not in tmpl
+
+        coinbase_tx = create_coinbase(height=int(tmpl["height"]))
+        # sequence numbers must not be max for nLockTime to have effect
+        coinbase_tx.vin[0].nSequence = 2 ** 32 - 2
+        coinbase_tx.rehash()
+
+        block = CBlock()
+        block.nVersion = tmpl["version"]
+        block.hashPrevBlock = int(tmpl["previousblockhash"], 16)
+        block.nTime = tmpl["curtime"]
+        block.nBits = int(tmpl["bits"], 16)
+        block.nNonce = 0
+        block.vtx = [coinbase_tx]
+
+if __name__ == '__main__':
+    SigMiningTest().main()
diff --git a/test/functional/rpc_help.py b/test/functional/rpc_help.py
index 78d6e78aed21..57685d70cc23 100755
--- a/test/functional/rpc_help.py
+++ b/test/functional/rpc_help.py
@@ -33,7 +33,7 @@ def test_categories(self):
         # command titles
         titles = [line[3:-3] for line in node.help().splitlines() if line.startswith('==')]
 
-        components = ['Blockchain', 'Control', 'Generating', 'Mining', 'Network', 'Rawtransactions', 'Util']
+        components = ['Blockchain', 'Control', 'Generating', 'Mining', 'Network', 'Rawtransactions', 'Signet', 'Util']
 
         if self.is_wallet_compiled():
             components.append('Wallet')
diff --git a/test/functional/test_framework/mininode.py b/test/functional/test_framework/mininode.py
index a9e669fea984..67c496f8622d 100755
--- a/test/functional/test_framework/mininode.py
+++ b/test/functional/test_framework/mininode.py
@@ -84,6 +84,7 @@
     "mainnet": b"\xf9\xbe\xb4\xd9",   # mainnet
     "testnet3": b"\x0b\x11\x09\x07",  # testnet3
     "regtest": b"\xfa\xbf\xb5\xda",   # regtest
+    "signet": b"\xf0\xc7\x70\x6a",    # signet
 }
 
 
diff --git a/test/functional/test_framework/test_framework.py b/test/functional/test_framework/test_framework.py
index f468f9eaec5d..ecbcbdc8c4f3 100755
--- a/test/functional/test_framework/test_framework.py
+++ b/test/functional/test_framework/test_framework.py
@@ -336,7 +336,8 @@ def setup_nodes(self):
             extra_args = self.extra_args
         self.add_nodes(self.num_nodes, extra_args)
         self.start_nodes()
-        self.import_deterministic_coinbase_privkeys()
+        if self.chain != "signet":
+            self.import_deterministic_coinbase_privkeys()
         if not self.setup_clean_chain:
             for n in self.nodes:
                 assert_equal(n.getblockchaininfo()["blocks"], 199)
@@ -543,19 +544,20 @@ def _initialize_chain(self):
             # Wait for RPC connections to be ready
             self.nodes[CACHE_NODE_ID].wait_for_rpc_connection()
 
-            # Create a 199-block-long chain; each of the 4 first nodes
-            # gets 25 mature blocks and 25 immature.
-            # The 4th node gets only 24 immature blocks so that the very last
-            # block in the cache does not age too much (have an old tip age).
-            # This is needed so that we are out of IBD when the test starts,
-            # see the tip age check in IsInitialBlockDownload().
-            for i in range(8):
-                self.nodes[CACHE_NODE_ID].generatetoaddress(
-                    nblocks=25 if i != 7 else 24,
-                    address=TestNode.PRIV_KEYS[i % 4].address,
-                )
-
-            assert_equal(self.nodes[CACHE_NODE_ID].getblockchaininfo()["blocks"], 199)
+            if self.chain != "signet":
+                # Create a 199-block-long chain; each of the 4 first nodes
+                # gets 25 mature blocks and 25 immature.
+                # The 4th node gets only 24 immature blocks so that the very last
+                # block in the cache does not age too much (have an old tip age).
+                # This is needed so that we are out of IBD when the test starts,
+                # see the tip age check in IsInitialBlockDownload().
+                for i in range(8):
+                    self.nodes[CACHE_NODE_ID].generatetoaddress(
+                        nblocks=25 if i != 7 else 24,
+                        address=TestNode.PRIV_KEYS[i % 4].address,
+                    )
+
+                assert_equal(self.nodes[CACHE_NODE_ID].getblockchaininfo()["blocks"], 199)
 
             # Shut it down, and clean up cache directories:
             self.stop_nodes()
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index 4156e22720f5..a95d5cf46833 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -179,6 +179,7 @@
     'rpc_bind.py --ipv6',
     'rpc_bind.py --nonloopback',
     'mining_basic.py',
+    'mining_signet.py',
     'wallet_bumpfee.py',
     'wallet_bumpfee_totalfee_deprecation.py',
     'wallet_implicitsegwit.py',

From abe2d907435731f60e0574c5b1f60987f440b303 Mon Sep 17 00:00:00 2001
From: Karl-Johan Alm <karljohan-alm@garage.co.jp>
Date: Wed, 17 Jul 2019 17:21:57 +0900
Subject: [PATCH 15/17] contrib: add signet scripts (issuer, etc)

---
 contrib/signet/README.md       | 60 ++++++++++++++++++++++
 contrib/signet/addtxtoblock.py | 57 +++++++++++++++++++++
 contrib/signet/args.sh         | 59 ++++++++++++++++++++++
 contrib/signet/forker.sh       | 74 +++++++++++++++++++++++++++
 contrib/signet/getcoins.sh     | 43 ++++++++++++++++
 contrib/signet/issuer.sh       | 60 ++++++++++++++++++++++
 contrib/signet/mkblock.sh      | 37 ++++++++++++++
 contrib/signet/secondary.sh    | 92 ++++++++++++++++++++++++++++++++++
 test/lint/lint-python.sh       |  2 +-
 test/lint/lint-shell.sh        |  1 +
 10 files changed, 484 insertions(+), 1 deletion(-)
 create mode 100644 contrib/signet/README.md
 create mode 100755 contrib/signet/addtxtoblock.py
 create mode 100755 contrib/signet/args.sh
 create mode 100755 contrib/signet/forker.sh
 create mode 100755 contrib/signet/getcoins.sh
 create mode 100755 contrib/signet/issuer.sh
 create mode 100755 contrib/signet/mkblock.sh
 create mode 100755 contrib/signet/secondary.sh

diff --git a/contrib/signet/README.md b/contrib/signet/README.md
new file mode 100644
index 000000000000..e39327b6e5bc
--- /dev/null
+++ b/contrib/signet/README.md
@@ -0,0 +1,60 @@
+Contents
+========
+This directory contains tools related to Signet, both for running a Signet yourself and for using one.
+
+The `args.sh` script is a helper script used by the other scripts and should not be invoked directly.
+
+getcoins.sh
+===========
+
+A script to call a faucet to get Signet coins.
+
+Syntax: `getcoins.sh [--help] [--cmd=<bitcoin-cli path>] [--faucet=<faucet URL>] [--addr=<signet bech32 address>] [--password=<faucet password>] [--] [<bitcoin-cli args>]`
+
+* `--cmd` lets you customize the bitcoin-cli path. By default it will look for it in the PATH, then in `../../src/`
+* `--faucet` lets you specify which faucet to use; the faucet is assumed to be compatible with https://github.com/kallewoof/bitcoin-faucet
+* `--addr` lets you specify a Signet address; by default, the address must be a bech32 address. This and `--cmd` above complement each other (i.e. you do not need `bitcoin-cli` if you use `--addr`)
+* `--password` lets you specify a faucet password; this is handy if you are in a classroom and set up your own faucet for your students; (above faucet does not limit by IP when password is enabled)
+
+If using the default network, invoking the script with no arguments should be sufficient under normal
+circumstances, but if multiple people are behind the same IP address, the faucet will by default only
+accept one claim per day. See `--password` above.
+
+issuer.sh
+=========
+
+A script to regularly issue Signet blocks.
+
+Syntax: `issuer.sh <idle time> [--help] [--cmd=<bitcoin-cli path>] [--] [<bitcoin-cli args>]`
+
+* `<idle time>` is a time in seconds to wait between each block generation
+* `--cmd` lets you customize the bitcoin-cli path. By default it will look for it in the PATH, then in `../../src/`
+
+Signet, just like other bitcoin networks, uses proof of work alongside the block signature; this
+includes the difficulty adjustment every 2016 blocks.
+The `<idle time>` exists to allow you to maintain a relatively low difficulty over an extended period
+of time. E.g. an idle time of 540 means your node will end up spending roughly 1 minute grinding
+hashes for each block, and wait 9 minutes after every time.
+
+mkblock.sh
+==========
+
+A script to generate one Signet block.
+
+Syntax: `mkblock.sh <bitcoin-cli path> [<bitcoin-cli args>]`
+
+This script is called by the other block issuing scripts, but can be invoked independently to generate
+1 block immediately.
+
+secondary.sh
+============
+
+A script to act as backup generator in case the primary issuer goes offline.
+
+Syntax: `secondary.sh <trigger time> <idle time> [--cmd=<bitcoin-cli path>] [<bitcoin-cli args>]`
+
+* `<trigger time>` is the time in seconds that must have passed since the last block was seen for the secondary issuer to kick into motion
+* `<idle time>` is the time in seconds to wait after generating a block, and should preferably be the same as the idle time of the main issuer
+
+Running a Signet network, it is recommended to have at least one secondary running in a different
+place, so it doesn't go down together with the main issuer.
diff --git a/contrib/signet/addtxtoblock.py b/contrib/signet/addtxtoblock.py
new file mode 100755
index 000000000000..ba8ededc7163
--- /dev/null
+++ b/contrib/signet/addtxtoblock.py
@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+# Copyright (c) 2019 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+import sys
+import os
+import argparse
+
+# dirty hack but makes CBlock etc available
+sys.path.append('/'.join(os.getcwd().split('/')[:-2]) + '/test/functional')
+
+from test_framework.messages import (
+    CBlock,
+    CTransaction,
+    FromHex,
+    ToHex,
+)
+
+from test_framework.blocktools import add_witness_commitment
+
+def main():
+
+    # Parse arguments and pass through unrecognised args
+    parser = argparse.ArgumentParser(add_help=False,
+                                        usage='%(prog)s [addtxtoblock options] [bitcoin block file] [tx file] [fee]',
+                                        description=__doc__,
+                                        epilog='''Help text and arguments:''',
+                                        formatter_class=argparse.RawTextHelpFormatter)
+    _, unknown_args = parser.parse_known_args()
+
+    if len(unknown_args) != 3:
+        print("Need three arguments (block file, tx file, and fee)")
+        sys.exit(1)
+
+    [blockfile, txfile, feestr] = unknown_args
+
+    with open(blockfile, "r", encoding="utf8") as f:
+        blockhex = f.read().strip()
+    with open(txfile,    "r", encoding="utf8") as f:
+        txhex    = f.read().strip()
+
+    fee = int(feestr)
+
+    block = CBlock()
+    FromHex(block, blockhex)
+
+    tx = CTransaction()
+    FromHex(tx, txhex)
+
+    block.vtx[0].vout[0].nValue += fee
+    block.vtx.append(tx)
+    add_witness_commitment(block)
+    print(ToHex(block))
+
+if __name__ == '__main__':
+    main()
diff --git a/contrib/signet/args.sh b/contrib/signet/args.sh
new file mode 100755
index 000000000000..cce81a78a72d
--- /dev/null
+++ b/contrib/signet/args.sh
@@ -0,0 +1,59 @@
+#!/usr/bin/env bash
+# Copyright (c) 2019 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+export LC_ALL=C
+
+args="-signet"
+eoc=
+
+command -v bitcoin-cli > /dev/null \
+&& bcli="bitcoin-cli" \
+|| bcli="$(dirname $0)/../../src/bitcoin-cli"
+
+if [ "$VARCHECKS" = "" ]; then
+    VARCHECKS='if [ "$varname" = "cmd" ]; then bcli=$value;'
+fi
+
+# compatibility; previously the bitcoin-cli path was given as first argument
+if [[ "$1" != "" && "${1:$((${#1}-11))}" = "bitcoin-cli" ]]; then
+    echo "using $1 as bcli"
+    bcli=$1
+    shift
+fi
+
+for i in "$@"; do
+    if [ $eoc ]; then
+        args="$args $i"
+    elif [ "$i" = "--" ]; then
+        # end of commands; rest into args for bitcoin-cli
+        eoc=1
+        continue
+    elif [ "${i:0:2}" = "--" ]; then
+        # command
+        j=${i:2}
+        if [ "$j" = "help" ]; then
+            >&2 echo -e $HELPSTRING # "syntax: $0 [--help] [--cmd=<bitcoin-cli path>] [--faucet=<faucet URL>=https://signet.bc-2.jp/claim] [<bitcoin-cli args>]"
+            exit 1
+        fi
+        export varname=${j%=*}
+        export value=${j#*=}
+        eval $VARCHECKS '
+        else
+            >&2 echo "unknown parameter $varname (from \"$i\"); for help, type: $0 --help"
+            exit 1
+        fi'
+        # if [ "$varname" = "cmd" ]; then
+        #     bcli=$value
+        # elif [ "$varname" = "faucet" ]; then
+        #     faucet=$value
+    else
+        # arg
+        args="$args $i"
+    fi
+done
+
+if ! [ -e "$bcli" ]; then
+    command -v "$bcli" >/dev/null 2>&1 || { echo >&2 "error: unable to find bitcoin binary: $bcli"; exit 1; }
+fi
diff --git a/contrib/signet/forker.sh b/contrib/signet/forker.sh
new file mode 100755
index 000000000000..72c5c5584fc0
--- /dev/null
+++ b/contrib/signet/forker.sh
@@ -0,0 +1,74 @@
+#!/usr/bin/env bash
+# Copyright (c) 2019 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+export LC_ALL=C
+
+#
+# Take the hex formatted line separated transactions in reorg-list.txt where every even transaction is put into the even set, and every odd transaction is put into the odd set.
+# That is, transactions on line 1, 3, 5, 7, ... go into the odd set, and transactions on line 2, 4, 6, 8, ... go into the even set.
+#
+# - Generate two blocks A and B, where A contains all or some of the odd set, and B contains the corresponding even set.
+# - Sign, grind, and broadcast block A
+# - Wait a random amount of time (1-10 mins)
+# - Invalidate block A
+# - Sign, grind, and broadcast block B
+#
+
+bcli=$1
+shift
+
+function log()
+{
+    echo "- $(date +%H:%M:%S): $*"
+}
+
+if [ ! -e "reorg-list.txt" ]; then
+    echo "reorg-list.txt not found"
+    exit 1
+fi
+
+# get address for coinbase output
+addr=$($bcli "$@" getnewaddress)
+
+# create blocks A and B
+$bcli "$@" getnewblockhex $addr > $PWD/block-a
+cp block-a block-b
+
+odd=1
+while read -r line; do
+    if [ "$line" = "" ]; then continue; fi
+    echo $line > tx
+    if [ $odd -eq 1 ]; then blk="block-a"; else blk="block-b"; fi
+    ./addtxtoblock.py $blk tx 100 > t # note: we are throwing away all fees above 100 satoshis for now; should figure out a way to determine fees
+    mv t $blk
+    (( odd=1-odd ))
+done < reorg-list.txt
+
+rm reorg-list.txt
+
+log "mining block A (to-orphan block)"
+while true; do
+    $bcli "$@" signblock $PWD/block-a > signed-a
+    blockhash_a=$($bcli "$@" grindblock $PWD/signed-a 1000000000)
+    if [ "$blockhash_a" != "false" ]; then break; fi
+done
+log "mined block with hash $blockhash_a"
+(( waittime=RANDOM%570 ))
+(( waittime=30+waittime ))
+log "waiting for $waittime s"
+sleep $waittime
+log "invalidating $blockhash_a"
+$bcli "$@" invalidateblock $blockhash_a
+
+log "mining block B (replace block)"
+while true; do
+    $bcli "$@" signblock $PWD/block-b > signed-b
+    blockhash_b=$($bcli "$@" grindblock $PWD/signed-b 1000000000)
+    if [ "$blockhash_b" != "false" ]; then break; fi
+done
+
+echo "mined $blockhash_b"
+echo "cleaning up"
+rm block-b signed-b block-a signed-a
diff --git a/contrib/signet/getcoins.sh b/contrib/signet/getcoins.sh
new file mode 100755
index 000000000000..8a2fedf8ae49
--- /dev/null
+++ b/contrib/signet/getcoins.sh
@@ -0,0 +1,43 @@
+#!/usr/bin/env bash
+# Copyright (c) 2019 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+export LC_ALL=C
+
+#
+# Get coins from Signet Faucet
+#
+
+export VARCHECKS='
+        if [ "$varname" = "cmd" ]; then
+            bcli=$value;
+        elif [ "$varname" = "faucet" ]; then
+            faucet=$value;
+        elif [ "$varname" = "addr" ]; then
+            addr=$value;
+        elif [ "$varname" = "password" ]; then
+            password=$value;
+    '
+export HELPSTRING="syntax: $0 [--help] [--cmd=<bitcoin-cli path>] [--faucet=<faucet URL>] [--addr=<signet bech32 address>] [--password=<faucet password>] [--] [<bitcoin-cli args>]"
+
+bcli=
+args=
+password=
+addr=
+faucet="https://signet.bc-2.jp/claim"
+
+# shellcheck source=contrib/signet/args.sh
+source $(dirname $0)/args.sh "$@"
+
+if [ "$addr" = "" ]; then
+    # get address for receiving coins
+    addr=$($bcli $args getnewaddress faucet bech32) || { echo >&2 "for help, type: $0 --help"; exit 1; }
+fi
+
+# shellcheck disable=SC2015
+command -v "curl" > /dev/null \
+&& curl -X POST -d "address=$addr&password=$password" $faucet \
+|| wget -qO - --post-data "address=$addr&password=$password" $faucet
+
+echo
diff --git a/contrib/signet/issuer.sh b/contrib/signet/issuer.sh
new file mode 100755
index 000000000000..a83e82641e14
--- /dev/null
+++ b/contrib/signet/issuer.sh
@@ -0,0 +1,60 @@
+#!/usr/bin/env bash
+# Copyright (c) 2019 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+export LC_ALL=C
+
+#
+# Issue blocks using a local node at a given interval.
+#
+
+export HELPSTRING="syntax: $0 <idle time> [--help] [--cmd=<bitcoin-cli path>] [--] [<bitcoin-cli args>]"
+
+if [ $# -lt 1 ]; then
+    echo $HELPSTRING
+    exit 1
+fi
+
+function log()
+{
+    echo "- $(date +%H:%M:%S): $*"
+}
+
+idletime=$1
+shift
+
+bcli=
+args=
+
+# shellcheck source=contrib/signet/args.sh
+source $(dirname $0)/args.sh "$@"
+
+MKBLOCK=$(dirname $0)/mkblock.sh
+
+if [ ! -e "$MKBLOCK" ]; then
+    >&2 echo "error: cannot locate mkblock.sh (expected to find in $MKBLOCK"
+    exit 1
+fi
+
+echo "- checking node status"
+conns=$($bcli $args getconnectioncount) || { echo >&2 "node error"; exit 1; }
+
+if [ $conns -lt 1 ]; then
+    echo "warning: node is not connected to any other node"
+fi
+
+log "node OK with $conns connection(s)"
+log "mining at maximum capacity with $idletime second delay between each block"
+log "hit ^C to stop"
+
+while true; do
+    if [ -e "reorg-list.txt" ]; then
+        ./forker.sh $bcli $args
+    else
+        log "generating next block"
+        blockhash=$("$MKBLOCK" "$bcli" $args) || { echo "node error; aborting" ; exit 1; }
+        log "mined block $($bcli $args getblockcount) $blockhash to $($bcli $args getconnectioncount) peer(s); idling for $idletime seconds"
+    fi
+    sleep $idletime
+done
diff --git a/contrib/signet/mkblock.sh b/contrib/signet/mkblock.sh
new file mode 100755
index 000000000000..e63bdec575b2
--- /dev/null
+++ b/contrib/signet/mkblock.sh
@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+# Copyright (c) 2019 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+export LC_ALL=C
+
+#
+# Generate a block
+#
+
+if [ $# -lt 1 ]; then
+    >&2 echo "syntax: $0 <bitcoin-cli path> [<bitcoin-cli args>]" ; exit 1
+fi
+
+bcli=$1
+shift
+
+if ! [ -e "$bcli" ]; then
+    command -v "$bcli" >/dev/null 2>&1 || { echo >&2 "error: unable to find bitcoin binary: $bcli"; exit 1; }
+fi
+
+# get address for coinbase output
+addr=$($bcli "$@" getnewaddress)
+# start looping; we re-create the block every time we fail to grind as that resets the nonce and gives us an updated
+# version of the block
+while true; do
+    # create an unsigned, un-PoW'd block
+    $bcli "$@" getnewblockhex $addr > $PWD/unsigned
+    # sign it
+    $bcli "$@" signblock $PWD/unsigned > $PWD/signed
+    # grind proof of work; this ends up broadcasting the block, if successful (akin to "generatetoaddress")
+    blockhash=$($bcli "$@" grindblock $PWD/signed 10000000)
+    if [ "$blockhash" != "false" ]; then break; fi
+done
+
+echo $blockhash
diff --git a/contrib/signet/secondary.sh b/contrib/signet/secondary.sh
new file mode 100755
index 000000000000..b3d4e33f7bed
--- /dev/null
+++ b/contrib/signet/secondary.sh
@@ -0,0 +1,92 @@
+#!/usr/bin/env bash
+# Copyright (c) 2019 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+export LC_ALL=C
+
+#
+# Backup Issuer which will begin to issue blocks if it sees no blocks within
+# a specified period of time. It will continue to make blocks until a block
+# is generated from an external source (i.e. the primary issuer is back online)
+#
+
+export HELPSTRING="syntax: $0 <trigger time> <idle time> [--cmd=<bitcoin-cli path>] [<bitcoin-cli args>]"
+
+if [ $# -lt 3 ]; then
+    echo $HELPSTRING
+    exit 1
+fi
+
+function log()
+{
+    echo "- $(date +%H:%M:%S): $*"
+}
+
+triggertime=$1
+shift
+
+idletime=$1
+shift
+
+bcli=
+args=
+
+# shellcheck source=contrib/signet/args.sh
+source $(dirname $0)/args.sh "$@"
+
+echo "- checking node status"
+conns=$($bcli $args getconnectioncount) || { echo >&2 "node error"; exit 1; }
+
+if [ $conns -lt 1 ]; then
+    echo "warning: node is not connected to any other node"
+fi
+
+MKBLOCK=$(dirname $0)/mkblock.sh
+
+if [ ! -e "$MKBLOCK" ]; then
+    >&2 echo "error: cannot locate mkblock.sh (expected to find in $MKBLOCK"
+    exit 1
+fi
+
+log "node OK with $conns connection(s)"
+log "hit ^C to stop"
+
+# outer loop alternates between watching and mining
+while true; do
+    # inner watchdog loop
+    blocks=$($bcli $args getblockcount)
+    log "last block #$blocks; waiting up to $triggertime seconds for a new block"
+    remtime=$triggertime
+    while true; do
+        waittime=1800
+        if [ $waittime -gt $remtime ]; then waittime=$remtime; fi
+        conns=$($bcli $args getconnectioncount)
+        if [ $conns -eq 1 ]; then s=""; else s="s"; fi
+        log "waiting $waittime/$remtime seconds with $conns peer$s"
+        sleep $waittime
+        new_blocks=$($bcli $args getblockcount)
+        if [ $new_blocks -gt $blocks ]; then
+            log "detected block count increase $blocks -> $new_blocks; resetting timer"
+            remtime=$triggertime
+            blocks=$new_blocks
+        else
+            (( remtime=remtime-waittime ))
+            if [ $remtime -lt 1 ]; then break; fi
+        fi
+    done
+    log "*** no blocks in $triggertime seconds; initiating issuance ***"
+    # inner issuer loop
+    while true; do
+        log "generating next block"
+        blockhash=$("$MKBLOCK" "$bcli" "$2") || { echo "node error; aborting" ; exit 1; }
+        blocks=$($bcli $args getblockcount)
+        log "mined block $new_blocks $blockhash to $($bcli $args getconnectioncount) peer(s); idling for $idletime seconds"
+        sleep $idletime
+        new_blocks=$($bcli $args getblockcount)
+        if [ $blocks -lt $new_blocks ]; then
+            log "primary issuer appears to be back online ($blocks -> $new_blocks blocks during downtime); going back to watching"
+            break
+        fi
+    done
+done
diff --git a/test/lint/lint-python.sh b/test/lint/lint-python.sh
index 2b1a1d8fbc16..c8b6f09314e7 100755
--- a/test/lint/lint-python.sh
+++ b/test/lint/lint-python.sh
@@ -30,7 +30,7 @@ enabled=(
     E304 # blank lines found after function decorator
     E306 # expected 1 blank line before a nested definition
     E401 # multiple imports on one line
-    E402 # module level import not at top of file
+    # E402 # module level import not at top of file (interferes with contrib/signet/addtxtoblock.py)
     E502 # the backslash is redundant between brackets
     E701 # multiple statements on one line (colon)
     E702 # multiple statements on one line (semicolon)
diff --git a/test/lint/lint-shell.sh b/test/lint/lint-shell.sh
index 63624e3ae09d..72da0453f649 100755
--- a/test/lint/lint-shell.sh
+++ b/test/lint/lint-shell.sh
@@ -19,6 +19,7 @@ fi
 # Disabled warnings:
 disabled=(
     SC2046 # Quote this to prevent word splitting.
+    SC2016 # Expressions don't expand in single quotes
     SC2086 # Double quote to prevent globbing and word splitting.
     SC2162 # read without -r will mangle backslashes.
 )

From 91f9f17e4d628c43b230134deb0b5eda10be527c Mon Sep 17 00:00:00 2001
From: Karl-Johan Alm <karljohan-alm@garage.co.jp>
Date: Fri, 28 Jun 2019 12:29:10 +0900
Subject: [PATCH 16/17] signet: hard-coded parameters for Signet Global Network
 III (2019-08-19)

Running with -signet without any other parameters will use this network's parameters.
---
 src/chainparams.cpp | 28 ++++++++++++++++------------
 1 file changed, 16 insertions(+), 12 deletions(-)

diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index d34456883067..634f05684868 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -279,20 +279,24 @@ class SigNetParams : public CChainParams {
         uint32_t genesis_nonce = 0;
 
         if (!args.IsArgSet("-signet_blockscript")) {
-            throw std::runtime_error(strprintf("%s: -signet_blockscript is mandatory for signet networks", __func__));
-        }
-        if (args.GetArgs("-signet_blockscript").size() != 1) {
-            throw std::runtime_error(strprintf("%s: -signet_blockscript cannot be multiple values.", __func__));
-        }
-        bin = ParseHex(args.GetArgs("-signet_blockscript")[0]);
-        if (args.IsArgSet("-signet_genesisnonce")) {
+            LogPrintf("Using default signet network\n");
+            bin = ParseHex("512103ad5e0edad18cb1f0fc0d28a3d4f1f3e445640337489abb10404f2d1e086be43051ae");
+            genesis_nonce = 621297;
+            vSeeds.push_back("178.128.221.177");
+            vSeeds.push_back("2a01:7c8:d005:390::5");
+            vSeeds.push_back("ntv3mtqw5wt63red.onion:38333");
+        } else {
+            if (args.GetArgs("-signet_blockscript").size() != 1) {
+                throw std::runtime_error(strprintf("%s: -signet_blockscript cannot be multiple values.", __func__));
+            }
+            bin = ParseHex(args.GetArgs("-signet_blockscript")[0]);
             genesis_nonce = args.GetArg("-signet_genesisnonce", 0);
-        }
-        if (args.IsArgSet("-signet_seednode")) {
-            vSeeds = gArgs.GetArgs("-signet_seednode");
-        }
+            if (args.IsArgSet("-signet_seednode")) {
+                vSeeds = gArgs.GetArgs("-signet_seednode");
+            }
 
-        LogPrintf("SigNet with block script %s\n", gArgs.GetArgs("-signet_blockscript")[0]);
+            LogPrintf("SigNet with block script %s\n", gArgs.GetArgs("-signet_blockscript")[0]);
+        }
 
         strNetworkID = CBaseChainParams::SIGNET;
         g_signet_blockscript = CScript(bin.begin(), bin.end());

From 4b00cec361069da46931dcd23f6a8c7eeebeb92a Mon Sep 17 00:00:00 2001
From: Karl-Johan Alm <karljohan-alm@garage.co.jp>
Date: Tue, 10 Sep 2019 13:48:39 +0300
Subject: [PATCH 17/17] util_tests.cpp update hash for hard coded chain merge

---
 src/test/util_tests.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/test/util_tests.cpp b/src/test/util_tests.cpp
index b9fcd97a8f45..87399054dbef 100644
--- a/src/test/util_tests.cpp
+++ b/src/test/util_tests.cpp
@@ -990,7 +990,7 @@ BOOST_FIXTURE_TEST_CASE(util_ChainMerge, ChainMergeTestingSetup)
     // Results file is formatted like:
     //
     //   <input> || <output>
-    BOOST_CHECK_EQUAL(out_sha_hex, "f0b3a3c29869edc765d579c928f7f1690a71fbb673b49ccf39cbc4de18156a0d");
+    BOOST_CHECK_EQUAL(out_sha_hex, "4645298a210e40fd8dfacc2b470be96a186f0ff2ebab328953cfe1ce866e55cf");
 }
 
 BOOST_AUTO_TEST_CASE(util_FormatMoney)