diff --git a/contrib/signet/issuer/issuer.sh b/contrib/signet/issuer/issuer.sh
new file mode 100755
index 00000000000000..dbcacf1b4a71c5
--- /dev/null
+++ b/contrib/signet/issuer/issuer.sh
@@ -0,0 +1,76 @@
+#!/usr/bin/env bash
+# Copyright (c) 2018 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.
+#
+
+if [ $# -lt 3 ]; then
+    echo "syntax: $0 <min_time> <max_time> <bitcoin-cli path> [<bitcoin-cli args>]" ; exit 1
+fi
+
+function log()
+{
+    echo "- $(date +%H:%M:%S): $*"
+}
+
+min_time=$1
+shift
+max_time=$1
+shift
+bcli=$1
+shift
+
+# https://stackoverflow.com/questions/806906/how-do-i-test-if-a-variable-is-a-number-in-bash
+re='^[0-9]+$'
+if ! [[ $min_time =~ $re ]] ; then
+   echo "error: min_time $min_time is not a number" ; exit 1
+fi
+if ! [[ $max_time =~ $re ]] ; then
+   echo "error: max_time $max_time is not a number" ; exit 1
+fi
+
+(( randinterval=max_time-min_time ))
+if [ $randinterval -lt 1 ]; then
+    echo "error: interval min..max must be positive and greater than 0" ; exit 1
+fi
+
+if ! [ -e "$bcli" ]; then
+    which "$bcli" &> /dev/null
+    if [ $? -ne 0 ]; then
+        echo "error: unable to find bitcoin binary: $bcli" ; exit 1
+    fi
+fi
+
+echo "- checking node status"
+conns=$($bcli "$@" getconnectioncount)
+
+if [ $? -ne 0 ]; then
+    echo "node error" ; exit 1
+fi
+
+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 in random intervals between $min_time .. $max_time seconds"
+log "hit ^C to stop"
+
+while true; do
+    (( rv=$RANDOM%$randinterval ))
+    (( rv=rv+min_time ))
+    echo -n -e "- $(date +%H:%M:%S): next block in $rv seconds..."
+    sleep $rv
+    echo -n -e " [submit]"
+    blockhash=$($bcli "$@" getnewblockhex true)
+    if [ $? -ne 0 ]; then
+        echo "node error; aborting" ; exit 1
+    fi
+    echo ""
+    log "broadcasting block $($bcli "$@" getblockcount) $blockhash to $($bcli "$@" getconnectioncount) peer(s)"
+done
diff --git a/src/chain.h b/src/chain.h
index 2b6d2d082cb237..bd0e85c52fb1e6 100644
--- a/src/chain.h
+++ b/src/chain.h
@@ -383,6 +383,16 @@ class CDiskBlockIndex : public CBlockIndex
         READWRITE(nTime);
         READWRITE(nBits);
         READWRITE(nNonce);
+        if (g_solution_blocks && !(s.GetType() & SER_GETHASH)) {
+            uint256 hash = GetBlockHash();
+            READWRITE(g_blockheader_payload_map[hash]);
+            size_t len = GetSizeOfCompactSize(g_blockheader_payload_map[hash].size()) + g_blockheader_payload_map[hash].size();
+            while (len < g_solution_block_len) {
+                uint8_t padding = 0;
+                READWRITE(padding);
+                len++;
+            }
+        }
     }
 
     uint256 GetBlockHash() const
diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index b8e0ea23dd5a45..40c5a6cbf4440e 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -17,13 +17,15 @@
 #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)
+#include <hash.h>
+
+static 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 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
@@ -268,6 +276,88 @@ class CTestNetParams : public CChainParams {
     }
 };
 
+/**
+ * SigNet version 2018-07-20
+ */
+class SigNetParams : public CChainParams {
+public:
+    SigNetParams(const ArgsManager& args) {
+        if (!args.IsArgSet("-signet_blockscript") || !args.IsArgSet("-signet_siglen")) {
+            throw std::runtime_error(strprintf("%s: -signet_blockscript and -signet_siglen are both 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__));
+        }
+        if (args.GetArgs("-signet_siglen").size() != 1) {
+            throw std::runtime_error(strprintf("%s: -signet_siglen cannot be multiple values.", __func__));
+        }
+
+        LogPrintf("SigNet with block script %s\n", gArgs.GetArgs("-signet_blockscript")[0]);
+
+        strNetworkID = "signet";
+        consensus.signature_pow = true;
+        consensus.blockscript = ParseHex(args.GetArgs("-signet_blockscript")[0]);
+        consensus.siglen = g_solution_block_len = atoi64(args.GetArgs("-signet_siglen")[0]);
+        consensus.nSubsidyHalvingInterval = 210000;
+        consensus.BIP34Height = 1;
+        consensus.BIP65Height = 1;
+        consensus.BIP66Height = 1;
+        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("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+        consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;
+        consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = 1539478800;
+        consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
+
+        // Deployment of BIP68, BIP112, and BIP113.
+        consensus.vDeployments[Consensus::DEPLOYMENT_CSV].bit = 0;
+        consensus.vDeployments[Consensus::DEPLOYMENT_CSV].nStartTime = 1539478800;
+        consensus.vDeployments[Consensus::DEPLOYMENT_CSV].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
+
+        // Deployment of SegWit (BIP141, BIP143, and BIP147)
+        consensus.vDeployments[Consensus::DEPLOYMENT_SEGWIT].bit = 1;
+        consensus.vDeployments[Consensus::DEPLOYMENT_SEGWIT].nStartTime = 1539478800;
+        consensus.vDeployments[Consensus::DEPLOYMENT_SEGWIT].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
+
+        pchMessageStart[0] = 0xf0;
+        pchMessageStart[1] = 0xc7;
+        pchMessageStart[2] = 0x70;
+        pchMessageStart[3] = 0x6a;
+        nDefaultPort = 38333;
+        nPruneAfterHeight = 1000;
+
+        CHashWriter h(SER_DISK, 0);
+        h << consensus.blockscript << consensus.siglen;
+        uint256 hash = h.GetHash();
+        CScript coinbase_sig = CScript() << std::vector<uint8_t>(hash.begin(), hash.end());
+        CScript genesis_out = CScript() << OP_RETURN;
+        genesis = CreateGenesisBlock(coinbase_sig, genesis_out, 1534313275, 0, 0x1d00ffff, 1, 50 * COIN);
+        consensus.hashGenesisBlock = genesis.GetHash();
+
+        vFixedSeeds.clear();
+        vSeeds.clear();
+        if (args.IsArgSet("-signet_seednode")) {
+            vSeeds = gArgs.GetArgs("-signet_seednode");
+        }
+
+        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";
+
+        fDefaultConsistencyChecks = false;
+        fRequireStandard = false;
+        fMineBlocksOnDemand = false;
+    }
+};
+
 /**
  * Regression test
  */
@@ -409,6 +499,10 @@ 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) {
+        g_solution_blocks = true;
+        return std::unique_ptr<CChainParams>(new SigNetParams(gArgs));
+    }
     throw std::runtime_error(strprintf("%s: Unknown chain %s.", __func__, chain));
 }
 
diff --git a/src/chainparamsbase.cpp b/src/chainparamsbase.cpp
index f0559a319acb7c..5ee50ad19bcf5b 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()
@@ -21,6 +22,10 @@ void SetupChainParamsBaseOptions()
                                    "This is intended for regression testing tools and app development.", true, OptionsCategory::CHAINPARAMS);
     gArgs.AddArg("-testnet", "Use the test chain", false, OptionsCategory::CHAINPARAMS);
     gArgs.AddArg("-vbparams=deployment:start:end", "Use given start/end times for specified version bits deployment (regtest-only)", true, OptionsCategory::CHAINPARAMS);
+    gArgs.AddArg("-signet", "Use the signet chain. Note that the network is defined by the signet_blockscript and signet_siglen parameters", false, OptionsCategory::CHAINPARAMS);
+    gArgs.AddArg("-signet_blockscript", "Blocks must satisfy the given script to be considered valid (only for -signet networks)", false, OptionsCategory::CHAINPARAMS);
+    gArgs.AddArg("-signet_siglen", "The length of the signature must be exactly this long (padded to this length, if shorter). All block headers in this network are of length 80 + this value", false, OptionsCategory::CHAINPARAMS);
+    gArgs.AddArg("-signet_seednode", "Specify a seed node for the signet network (may be used multiple times to specify multiple seed nodes)", false, OptionsCategory::CHAINPARAMS);
 }
 
 static std::unique_ptr<CBaseChainParams> globalChainBaseParams;
@@ -39,8 +44,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 355df043d39e45..a960defbcf430f 100644
--- a/src/chainparamsbase.h
+++ b/src/chainparamsbase.h
@@ -16,9 +16,10 @@
 class CBaseChainParams
 {
 public:
-    /** BIP70 chain name strings (main, test or regtest) */
+    /** BIP70 chain name strings (main, test, sigtest or regtest) */
     static const std::string MAIN;
     static const std::string TESTNET;
+    static const std::string SIGNET;
     static const std::string REGTEST;
 
     const std::string& DataDir() const { return strDataDir; }
diff --git a/src/consensus/params.h b/src/consensus/params.h
index 6c3a201f4f5fb7..560317d4c34908 100644
--- a/src/consensus/params.h
+++ b/src/consensus/params.h
@@ -75,7 +75,12 @@ struct Params {
     int64_t DifficultyAdjustmentInterval() const { return nPowTargetTimespan / nPowTargetSpacing; }
     uint256 nMinimumChainWork;
     uint256 defaultAssumeValid;
+
+    bool signature_pow{false};
+    std::vector<uint8_t> blockscript;
+    uint32_t siglen;
 };
+
 } // namespace Consensus
 
 #endif // BITCOIN_CONSENSUS_PARAMS_H
diff --git a/src/miner.cpp b/src/miner.cpp
index 80a2f8f018073a..9e04af22d78b26 100644
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -47,6 +47,10 @@ int64_t UpdateTime(CBlockHeader* pblock, const Consensus::Params& consensusParam
 BlockAssembler::Options::Options() {
     blockMinFeeRate = CFeeRate(DEFAULT_BLOCK_MIN_TX_FEE);
     nBlockMaxWeight = DEFAULT_BLOCK_MAX_WEIGHT;
+
+    // Make room for the signature in the block header, if this is a signet
+    // block
+    if (g_solution_blocks) nBlockMaxWeight -= g_solution_block_len;
 }
 
 BlockAssembler::BlockAssembler(const CChainParams& params, const Options& options) : chainparams(params)
diff --git a/src/policy/policy.cpp b/src/policy/policy.cpp
index d4cc538492b322..49b4baa9f8aa2a 100644
--- a/src/policy/policy.cpp
+++ b/src/policy/policy.cpp
@@ -14,6 +14,7 @@
 #include <util/system.h>
 #include <util/strencodings.h>
 
+unsigned int GetStandardScriptVerifyFlags() { return STANDARD_SCRIPT_VERIFY_FLAGS; }
 
 CAmount GetDustThreshold(const CTxOut& txout, const CFeeRate& dustRelayFeeIn)
 {
diff --git a/src/policy/policy.h b/src/policy/policy.h
index 3d47ac12676257..28e9eb1877b2ad 100644
--- a/src/policy/policy.h
+++ b/src/policy/policy.h
@@ -68,6 +68,8 @@ static constexpr unsigned int STANDARD_SCRIPT_VERIFY_FLAGS = MANDATORY_SCRIPT_VE
                                                              SCRIPT_VERIFY_WITNESS_PUBKEYTYPE |
                                                              SCRIPT_VERIFY_CONST_SCRIPTCODE;
 
+unsigned int GetStandardScriptVerifyFlags();
+
 /** For convenience, standard but not mandatory verify flags. */
 static constexpr unsigned int STANDARD_NOT_MANDATORY_VERIFY_FLAGS = STANDARD_SCRIPT_VERIFY_FLAGS & ~MANDATORY_SCRIPT_VERIFY_FLAGS;
 
diff --git a/src/pow.cpp b/src/pow.cpp
index 1414d375649254..ef7dfba9e0ccb8 100644
--- a/src/pow.cpp
+++ b/src/pow.cpp
@@ -9,6 +9,9 @@
 #include <chain.h>
 #include <primitives/block.h>
 #include <uint256.h>
+#include <script/interpreter.h>
+
+unsigned int GetStandardScriptVerifyFlags();
 
 unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHeader *pblock, const Consensus::Params& params)
 {
@@ -71,8 +74,17 @@ unsigned int CalculateNextWorkRequired(const CBlockIndex* pindexLast, int64_t nF
     return bnNew.GetCompact();
 }
 
-bool CheckProofOfWork(uint256 hash, unsigned int nBits, const Consensus::Params& params)
+bool CheckProofOfWork(const uint256& hash, unsigned int nBits, const Consensus::Params& params)
 {
+    if (g_solution_blocks) {
+        if (hash == params.hashGenesisBlock) return true;
+        SimpleSignatureChecker bsc(hash);
+        const auto& payload = g_blockheader_payload_map.at(hash);
+        CScript solution = CScript(payload.begin(), payload.end());
+        CScript challenge = CScript(params.blockscript.begin(), params.blockscript.end());
+        return VerifyScript(solution, challenge, nullptr, GetStandardScriptVerifyFlags(), bsc);
+    }
+
     bool fNegative;
     bool fOverflow;
     arith_uint256 bnTarget;
diff --git a/src/pow.h b/src/pow.h
index 1d802cd01e403f..fcc3b4cbbbc5b1 100644
--- a/src/pow.h
+++ b/src/pow.h
@@ -18,6 +18,6 @@ unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHead
 unsigned int CalculateNextWorkRequired(const CBlockIndex* pindexLast, int64_t nFirstBlockTime, const Consensus::Params&);
 
 /** Check whether a block hash satisfies the proof-of-work requirement specified by nBits */
-bool CheckProofOfWork(uint256 hash, unsigned int nBits, const Consensus::Params&);
+bool CheckProofOfWork(const uint256& hash, unsigned int nBits, const Consensus::Params&);
 
 #endif // BITCOIN_POW_H
diff --git a/src/primitives/block.cpp b/src/primitives/block.cpp
index a0c2e3f1257497..6686bdd2c197c1 100644
--- a/src/primitives/block.cpp
+++ b/src/primitives/block.cpp
@@ -10,9 +10,13 @@
 #include <util/strencodings.h>
 #include <crypto/common.h>
 
+bool g_solution_blocks = false;
+size_t g_solution_block_len = 0;
+std::map<uint256,std::vector<uint8_t>> g_blockheader_payload_map;
+
 uint256 CBlockHeader::GetHash() const
 {
-    return SerializeHash(*this);
+    return SerializeHash(*this, SER_GETHASH, SERIALIZE_TRANSACTION_NO_WITNESS);
 }
 
 std::string CBlock::ToString() const
diff --git a/src/primitives/block.h b/src/primitives/block.h
index 750d42efbc2362..64c6e124ae2fb4 100644
--- a/src/primitives/block.h
+++ b/src/primitives/block.h
@@ -10,6 +10,23 @@
 #include <serialize.h>
 #include <uint256.h>
 
+/**
+ * If true, block headers contain a payload equal to a Bitcoin Script solution
+ * to a signet challenge as defined in the chain params.
+ */
+extern bool g_solution_blocks;
+/**
+ * If non-zero, defines an enforced size requirement for block header payloads.
+ * It requires that all blocks are of size 80 + (this value) bytes.
+ */
+extern size_t g_solution_block_len;
+
+/**
+ * Contains a mapping of hash to signature data for each block header
+ * in signet networks.
+ */
+extern std::map<uint256,std::vector<uint8_t>> g_blockheader_payload_map;
+
 /** Nodes collect new transactions into a block, hash them into a hash tree,
  * and scan through nonce values to make the block's hash satisfy proof-of-work
  * requirements.  When they solve the proof-of-work, they broadcast the block
@@ -43,6 +60,15 @@ class CBlockHeader
         READWRITE(nTime);
         READWRITE(nBits);
         READWRITE(nNonce);
+        if (g_solution_blocks && !(s.GetVersion() & SERIALIZE_TRANSACTION_NO_WITNESS)) {
+            READWRITE(g_blockheader_payload_map[GetHash()]);
+            size_t len = GetSizeOfCompactSize(g_blockheader_payload_map[GetHash()].size()) + g_blockheader_payload_map[GetHash()].size();
+            while (len < g_solution_block_len) {
+                uint8_t padding = 0;
+                READWRITE(padding);
+                len++;
+            }
+        }
     }
 
     void SetNull()
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index 7e8e5e07d08c49..99988a1ea9c512 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -154,6 +154,9 @@ 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 (g_solution_blocks && g_blockheader_payload_map.count(blockindex->GetBlockHash())) {
+        result.pushKV("signet-solution", HexStr(g_blockheader_payload_map.at(blockindex->GetBlockHash())));
+    }
     return result;
 }
 
diff --git a/src/rpc/client.cpp b/src/rpc/client.cpp
index a266580b3d1eef..3e7a53aa7c57c6 100644
--- a/src/rpc/client.cpp
+++ b/src/rpc/client.cpp
@@ -49,6 +49,7 @@ static const CRPCConvertParam vRPCConvertParams[] =
     { "getbalance", 1, "minconf" },
     { "getbalance", 2, "include_watchonly" },
     { "getblockhash", 0, "height" },
+    { "getnewblockhex", 0, "broadcast" },
     { "waitforblockheight", 0, "height" },
     { "waitforblockheight", 1, "timeout" },
     { "waitforblock", 1, "timeout" },
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index f2acb8fbf59773..95a268a9b49d4e 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -179,6 +179,10 @@ static UniValue generatetoaddress(const JSONRPCRequest& request)
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Error: Invalid address");
     }
 
+    if (g_solution_blocks) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "Generating signet blocks require that you use the getnewblockhex, as wallet access is required");
+    }
+
     std::shared_ptr<CReserveScript> coinbaseScript = std::make_shared<CReserveScript>();
     coinbaseScript->reserveScript = GetScriptForDestination(destination);
 
@@ -697,7 +701,7 @@ class submitblock_StateCatcher : public CValidationInterface
     }
 };
 
-static UniValue submitblock(const JSONRPCRequest& request)
+UniValue submitblock(const JSONRPCRequest& request)
 {
     // We allow 2 arguments for compliance with BIP22. Argument 2 is ignored.
     if (request.fHelp || request.params.size() < 1 || request.params.size() > 2) {
@@ -728,6 +732,11 @@ static UniValue submitblock(const JSONRPCRequest& request)
     }
 
     uint256 hash = block.GetHash();
+
+    if (!request.params[1].isNull()) {
+        g_blockheader_payload_map[hash] = ParseHex(request.params[1].get_str());
+    }
+
     {
         LOCK(cs_main);
         const CBlockIndex* pindex = LookupBlockIndex(hash);
diff --git a/src/script/interpreter.cpp b/src/script/interpreter.cpp
index 95b25b491199be..81a3e671a67f39 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 276ff9a58a870b..85091e6f813be2 100644
--- a/src/script/interpreter.h
+++ b/src/script/interpreter.h
@@ -162,6 +162,17 @@ class BaseSignatureChecker
     virtual ~BaseSignatureChecker() {}
 };
 
+class SimpleSignatureChecker : public BaseSignatureChecker
+{
+private:
+    uint256 hash;
+
+public:
+    const uint256& GetHash() const { return hash; }
+    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 320956d0c4c6bb..d44a5706f38f1d 100644
--- a/src/script/sign.cpp
+++ b/src/script/sign.cpp
@@ -32,6 +32,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 491fb54c453f58..d4f6adf387983e 100644
--- a/src/script/sign.h
+++ b/src/script/sign.h
@@ -98,6 +98,16 @@ class BaseSignatureCreator {
     virtual bool CreateSig(const SigningProvider& provider, std::vector<unsigned char>& vchSig, const CKeyID& keyid, const CScript& scriptCode, SigVersion sigversion) const =0;
 };
 
+class SimpleSignatureCreator : public BaseSignatureCreator
+{
+    SimpleSignatureChecker checker;
+
+public:
+    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;
diff --git a/src/txdb.cpp b/src/txdb.cpp
index 8447352c541368..b2c51120c0c9b9 100644
--- a/src/txdb.cpp
+++ b/src/txdb.cpp
@@ -274,7 +274,9 @@ bool CBlockTreeDB::LoadBlockIndexGuts(const Consensus::Params& consensusParams,
                 pindexNew->nStatus        = diskindex.nStatus;
                 pindexNew->nTx            = diskindex.nTx;
 
-                if (!CheckProofOfWork(pindexNew->GetBlockHash(), pindexNew->nBits, consensusParams))
+                // Block index guts do not include the payload, so we cannot check the POW for
+                // signets here
+                if (!consensusParams.signature_pow && !CheckProofOfWork(pindexNew->GetBlockHash(), pindexNew->nBits, consensusParams))
                     return error("%s: CheckProofOfWork failed: %s", __func__, pindexNew->ToString());
 
                 pcursor->Next();
diff --git a/src/util/system.cpp b/src/util/system.cpp
index 9594dd81bf7b87..ecd508224424f8 100644
--- a/src/util/system.cpp
+++ b/src/util/system.cpp
@@ -365,6 +365,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
@@ -958,13 +959,16 @@ std::string ArgsManager::GetChainName() const
     LOCK(cs_args);
     bool fRegTest = ArgsManagerHelper::GetNetBoolArg(*this, "-regtest");
     bool fTestNet = ArgsManagerHelper::GetNetBoolArg(*this, "-testnet");
+    bool signet   = ArgsManagerHelper::GetNetBoolArg(*this, "-signet");
 
-    if (fTestNet && fRegTest)
-        throw std::runtime_error("Invalid combination of -regtest and -testnet.");
+    if (fTestNet + fRegTest + signet > 1)
+        throw std::runtime_error("Invalid combination of -regtest, -testnet, and -signet.");
     if (fRegTest)
         return CBaseChainParams::REGTEST;
     if (fTestNet)
         return CBaseChainParams::TESTNET;
+    if (signet)
+        return CBaseChainParams::SIGNET;
     return CBaseChainParams::MAIN;
 }
 
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
index 31a3209a49e770..899bee89e8b079 100644
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -12,6 +12,7 @@
 #include <interfaces/chain.h>
 #include <validation.h>
 #include <key_io.h>
+#include <miner.h>
 #include <net.h>
 #include <node/transaction.h>
 #include <outputtype.h>
@@ -3356,6 +3357,192 @@ static UniValue bumpfee(const JSONRPCRequest& request)
     return result;
 }
 
+void SignBlockHashWithWallet(const uint256& hash, CWallet* const pwallet)
+{
+    SignatureData solution_in;
+    if (g_blockheader_payload_map.count(hash) && g_blockheader_payload_map.at(hash).size()) {
+        solution_in = SignatureData(CScript(g_blockheader_payload_map[hash].begin(), g_blockheader_payload_map[hash].end()));
+    }
+    CScript blockscript(Params().GetConsensus().blockscript.begin(), Params().GetConsensus().blockscript.end());
+
+    // sign until we have a sufficiently small signature, or until we run out of tries
+    bool res;
+    size_t smallest = 9999;
+    std::vector<uint8_t> sigdata;
+    size_t overhead = GetSizeOfCompactSize(g_solution_block_len);
+    for (size_t i = 0; i < 1000; ++i) {
+        SignatureData solution(solution_in);
+        res = ProduceSignature(*pwallet, SimpleSignatureCreator(hash), blockscript, solution);
+        if (!res) {
+            throw JSONRPCError(RPC_VERIFY_ERROR, "could not produce a signature -- do you have the private key(s)?");
+        }
+        if (solution.scriptSig.size() < smallest) {
+            smallest = solution.scriptSig.size();
+            if (!g_solution_block_len || smallest + overhead <= g_solution_block_len) {
+                sigdata = std::vector<uint8_t>(solution.scriptSig.begin(), solution.scriptSig.end());
+                break;
+            }
+        }
+    }
+    if (g_solution_block_len && sigdata.size() == 0) {
+        throw JSONRPCError(RPC_VERIFY_ERROR, strprintf("unable to produce a signature of size <= %zu (smallest found was %zu)", g_solution_block_len, smallest + overhead));
+    }
+
+    g_blockheader_payload_map[hash] = sigdata;
+}
+
+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;
+    }
+
+    if (request.fHelp || request.params.size() != 1) {
+        throw std::runtime_error(
+            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"},
+                },
+                RPCResult{
+                    " sig      (hex) The signature\n"
+                },
+                RPCExamples{
+                    HelpExampleCli("signblock", "0000002018c6f2f913f9902aeab...5ca501f77be96de63f609010000000000000000015100000000")
+                },
+            }.ToString());
+    }
+
+    if (!g_solution_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");
+    }
+
+    LOCK(cs_main);
+
+    uint256 hash = block.GetHash();
+    BlockMap::iterator mi = mapBlockIndex.find(hash);
+    if (mi != mapBlockIndex.end()) {
+        throw JSONRPCError(RPC_VERIFY_ERROR, "already have block");
+    }
+
+    CBlockIndex* const pindexPrev = chainActive.Tip();
+    // TestBlockValidity only supports blocks built on the current Tip
+    if (block.hashPrevBlock != pindexPrev->GetBlockHash()) {
+        throw JSONRPCError(RPC_VERIFY_ERROR, "proposal was not based on our best chain");
+    }
+
+    CValidationState state;
+    if (!TestBlockValidity(state, Params(), block, pindexPrev, false, true) || !state.IsValid()) {
+        std::string strRejectReason = state.GetRejectReason();
+        if (strRejectReason.empty()) {
+            throw JSONRPCError(RPC_VERIFY_ERROR, state.IsInvalid() ? "Block proposal was invalid" : "Error checking block proposal");
+        }
+        throw JSONRPCError(RPC_VERIFY_ERROR, strRejectReason);
+    }
+    SignBlockHashWithWallet(hash, pwallet);
+    return HexStr(g_blockheader_payload_map.at(hash));
+}
+
+UniValue getnewblockhex(const JSONRPCRequest& request)
+{
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    CWallet* const pwallet = wallet.get();
+
+    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
+        return NullUniValue;
+    }
+
+    if (request.fHelp || request.params.size() > 2) {
+        throw std::runtime_error(
+            RPCHelpMan{"getnewblockhex",
+                "\nGets hex representation of a proposed, unmined new block, optionally\n"
+                "signing and broadcasting it to the network.\n",
+                {
+                    {"broadcast", RPCArg::Type::BOOL, "false", "Sign and broadcast the block immediately, returning the blockhash"},
+                    {"coinbase_script", RPCArg::Type::STR, "", "A custom coinbase script"},
+                },
+                RPCResult{
+                    "\n(for broadcast=false)\n"
+                    "blockhex      (hex) The block hex\n"
+                    "\n(for broadcast=true)\n"
+                    "blockhash     (hash) The block hash\n"
+                },
+                RPCExamples{
+                    HelpExampleCli("getnewblockhex", "")
+                    + HelpExampleCli("getnewblockhex", "true")
+                }
+            }.ToString());
+    }
+
+    bool broadcast = !request.params[0].isNull() && request.params[0].get_bool();
+
+    CScript reserve_script;
+    if (request.params[1].isNull()) {
+        // static UniValue getnewaddress(const JSONRPCRequest& request)
+        JSONRPCRequest sub_request;
+        CTxDestination destination = DecodeDestination(getnewaddress(sub_request).get_str());
+        if (!IsValidDestination(destination)) {
+            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Error: Invalid address");
+        }
+
+        std::shared_ptr<CReserveScript> coinbase_script = std::make_shared<CReserveScript>();
+        coinbase_script->reserveScript = GetScriptForDestination(destination);
+
+        // If the keypool is exhausted, no script is returned at all.  Catch this.
+        if (!coinbase_script) {
+            throw JSONRPCError(RPC_WALLET_KEYPOOL_RAN_OUT, "Error: Keypool ran out, please call keypoolrefill first");
+        }
+
+        // throw an error if no script was provided
+        if (coinbase_script->reserveScript.empty()) {
+            throw JSONRPCError(RPC_INTERNAL_ERROR, "No coinbase script available");
+        }
+
+        reserve_script = coinbase_script->reserveScript;
+    } else {
+        util::insert(reserve_script, ParseHexV(request.params[1], "coinbase_script"));
+    }
+
+    std::unique_ptr<CBlockTemplate> pblocktemplate(BlockAssembler(Params()).CreateNewBlock(reserve_script));
+    {
+        // IncrementExtraNonce sets coinbase flags and builds merkle tree
+        LOCK(cs_main);
+        unsigned int nExtraNonce = 0;
+        IncrementExtraNonce(&pblocktemplate->block, chainActive.Tip(), nExtraNonce);
+    }
+
+    CDataStream ssBlock(SER_NETWORK, PROTOCOL_VERSION);
+    ssBlock << pblocktemplate->block;
+
+    if (broadcast) {
+        // attempt to sign
+        uint256 hash = pblocktemplate->block.GetHash();
+        SignBlockHashWithWallet(hash, pwallet);
+        // and submit
+        UniValue submitblock(const JSONRPCRequest& request);
+        UniValue params(UniValue::VARR);
+        params.push_back(HexStr(ssBlock.begin(), ssBlock.end()));
+        params.push_back(HexStr(g_blockheader_payload_map.at(hash).begin(), g_blockheader_payload_map.at(hash).end()));
+        JSONRPCRequest req;
+        req.params = params;
+        submitblock(req);
+        return hash.GetHex();
+    }
+
+    return HexStr(ssBlock.begin(), ssBlock.end());
+}
+
 UniValue rescanblockchain(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
@@ -4153,6 +4340,10 @@ static const CRPCCommand commands[] =
     { "wallet",             "walletpassphrase",                 &walletpassphrase,              {"passphrase","timeout"} },
     { "wallet",             "walletpassphrasechange",           &walletpassphrasechange,        {"oldpassphrase","newpassphrase"} },
     { "wallet",             "walletprocesspsbt",                &walletprocesspsbt,             {"psbt","sign","sighashtype","bip32derivs"} },
+
+    /** Signet mining */
+    { "wallet",             "signblock",                        &signblock,                     {"blockhex"} },
+    { "wallet",             "getnewblockhex",                   &getnewblockhex,                {"broadcast","coinbase_script"} },
 };
 // clang-format on
 
diff --git a/test/functional/feature_blocksdir.py b/test/functional/feature_blocksdir.py
index 3a4889bbe9cf36..88344bc97850c2 100755
--- a/test/functional/feature_blocksdir.py
+++ b/test/functional/feature_blocksdir.py
@@ -21,7 +21,7 @@ def run_test(self):
         assert os.path.isdir(os.path.join(self.nodes[0].datadir, "regtest", "blocks"))
         assert not os.path.isdir(os.path.join(self.nodes[0].datadir, "blocks"))
         shutil.rmtree(self.nodes[0].datadir)
-        initialize_datadir(self.options.tmpdir, 0)
+        initialize_datadir(self.options.tmpdir, 0, self.net)
         self.log.info("Starting with nonexistent blocksdir ...")
         blocksdir_path = os.path.join(self.options.tmpdir, 'blocksdir')
         self.nodes[0].assert_start_raises_init_error(["-blocksdir=" + blocksdir_path], 'Error: Specified blocks directory "{}" does not exist.'.format(blocksdir_path))
diff --git a/test/functional/interface_bitcoin_cli.py b/test/functional/interface_bitcoin_cli.py
index f44fc768dc9f0c..0de082565ee063 100755
--- a/test/functional/interface_bitcoin_cli.py
+++ b/test/functional/interface_bitcoin_cli.py
@@ -29,7 +29,7 @@ def run_test(self):
         rpc_response = self.nodes[0].getblockchaininfo()
         assert_equal(cli_response, rpc_response)
 
-        user, password = get_auth_cookie(self.nodes[0].datadir)
+        user, password = get_auth_cookie(self.nodes[0].datadir, self.net)
 
         self.log.info("Test -stdinrpcpass option")
         assert_equal(0, self.nodes[0].cli('-rpcuser=%s' % user, '-stdinrpcpass', input=password).getblockcount())
diff --git a/test/functional/mining_signet.py b/test/functional/mining_signet.py
new file mode 100755
index 00000000000000..7e561286236c7c
--- /dev/null
+++ b/test/functional/mining_signet.py
@@ -0,0 +1,165 @@
+#!/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"""
+
+import copy
+from decimal import Decimal
+
+from test_framework.blocktools import (
+    create_coinbase,
+)
+from test_framework.messages import (
+    CBlock,
+    BLOCK_HEADER_SIZE,
+    enable_signet,
+)
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import (
+    assert_equal,
+    assert_raises_rpc_error,
+)
+
+private_key = "ZFNp4W4HSatHDc4zsheMsDWgUg2uiB5PtnY2Y2hUCNCkQiF81KyV"
+pubkey      = "02c72b24ae2ee333f2da24aea66ce4338c01db8f26d0cc96f586d77edcb5238a4f"
+address     = "sb1qghzjzc0jvkjvvvymxnadmjjpu2tywmvagduwfj"
+blockscript = "5121" + pubkey + "51ae" # 1-of-1 multisig
+siglen      = 80
+header_sz   = BLOCK_HEADER_SIZE + siglen
+
+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)
+
+
+class SigMiningTest(BitcoinTestFramework):
+    def set_test_params(self):
+        enable_signet()
+        self.net = "signet"
+        self.num_nodes = 2
+        self.setup_clean_chain = True
+        shared_args = ["-signet_blockscript=" + blockscript, "-signet_siglen=" + str(siglen), "-signet_seednode=localhost:1234"]
+        self.extra_args = [shared_args, shared_args]
+
+    def skip_test_if_missing_module(self):
+        self.skip_if_no_wallet()
+
+    def generate(self, node, count):
+        for i in range(count):
+            node.getnewblockhex(True)
+
+    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['difficulty'], Decimal('1'))
+        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
+
+        self.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]
+
+        self.log.info("getblocktemplate: Test valid block")
+        assert_template(node, block, None)
+
+        self.log.info("submitblock: Test block decode failure")
+        assert_raises_rpc_error(-22, "Block decode failed", node.submitblock, block.serialize()[:-15].hex())
+
+        self.log.info("getblocktemplate: Test bad input hash for coinbase transaction")
+        bad_block = copy.deepcopy(block)
+        bad_block.vtx[0].vin[0].prevout.hash += 1
+        bad_block.vtx[0].rehash()
+        assert_template(node, bad_block, 'bad-cb-missing')
+
+        self.log.info("submitblock: Test invalid coinbase transaction")
+        assert_raises_rpc_error(-22, "Block does not start with a coinbase", node.submitblock, bad_block.serialize().hex())
+
+        self.log.info("getblocktemplate: Test truncated final transaction")
+        assert_raises_rpc_error(-22, "Block decode failed", node.getblocktemplate, {'data': block.serialize()[:-1].hex(), 'mode': 'proposal', 'rules': ['segwit']})
+
+        self.log.info("getblocktemplate: Test duplicate transaction")
+        bad_block = copy.deepcopy(block)
+        bad_block.vtx.append(bad_block.vtx[0])
+        assert_template(node, bad_block, 'bad-txns-duplicate')
+
+        self.log.info("getblocktemplate: Test invalid transaction")
+        bad_block = copy.deepcopy(block)
+        bad_tx = copy.deepcopy(bad_block.vtx[0])
+        bad_tx.vin[0].prevout.hash = 255
+        bad_tx.rehash()
+        bad_block.vtx.append(bad_tx)
+        assert_template(node, bad_block, 'bad-txns-inputs-missingorspent')
+
+        self.log.info("getblocktemplate: Test nonfinal transaction")
+        bad_block = copy.deepcopy(block)
+        bad_block.vtx[0].nLockTime = 2 ** 32 - 1
+        bad_block.vtx[0].rehash()
+        assert_template(node, bad_block, 'bad-txns-nonfinal')
+
+        self.log.info("getblocktemplate: Test bad tx count")
+        # The tx count is immediately after the block header
+        bad_block_sn = bytearray(block.serialize())
+        assert_equal(bad_block_sn[header_sz], 1)
+        bad_block_sn[header_sz] += 1
+        assert_raises_rpc_error(-22, "Block decode failed", node.getblocktemplate, {'data': bad_block_sn.hex(), 'mode': 'proposal'})
+
+        self.log.info("getblocktemplate: Test bad bits")
+        bad_block = copy.deepcopy(block)
+        bad_block.nBits = 469762303  # impossible in the real world
+        assert_template(node, bad_block, 'bad-diffbits')
+
+        self.log.info("getblocktemplate: Test bad merkle root")
+        bad_block = copy.deepcopy(block)
+        bad_block.hashMerkleRoot += 1
+        assert_template(node, bad_block, 'bad-txnmrklroot', False)
+
+        self.log.info("getblocktemplate: Test bad timestamps")
+        bad_block = copy.deepcopy(block)
+        bad_block.nTime = 2 ** 31 - 1
+        assert_template(node, bad_block, 'time-too-new')
+        bad_block.nTime = 0
+        assert_template(node, bad_block, 'time-too-old')
+
+        self.log.info("getblocktemplate: Test not best block")
+        bad_block = copy.deepcopy(block)
+        bad_block.hashPrevBlock = 123
+        assert_template(node, bad_block, 'inconclusive-not-best-prevblk')
+
+if __name__ == '__main__':
+    SigMiningTest().main()
diff --git a/test/functional/test_framework/messages.py b/test/functional/test_framework/messages.py
index 7cf51d9223ac9b..16f7ada5cfbd7e 100755
--- a/test/functional/test_framework/messages.py
+++ b/test/functional/test_framework/messages.py
@@ -53,6 +53,13 @@
 MSG_WITNESS_FLAG = 1 << 30
 MSG_TYPE_MASK = 0xffffffff >> 2
 
+SOLUTION_BLOCKS = False
+SOLUTION_LEN = 80 # TODO: customizify
+
+def enable_signet():
+    global SOLUTION_BLOCKS
+    SOLUTION_BLOCKS = True
+
 # Serialization/deserialization tools
 def sha256(s):
     return hashlib.new('sha256', s).digest()
@@ -105,6 +112,23 @@ def ser_uint256(u):
     return rs
 
 
+def deser_sol(f):
+    nit = deser_compact_size(f)
+    rem = SOLUTION_LEN - nit - len(ser_compact_size(nit))
+    r = f.read(nit)
+    if rem > 0:
+        f.read(rem)
+    return r
+
+def ser_sol(s):
+    t = s
+    rem = SOLUTION_LEN - len(s) - len(ser_compact_size(len(s)))
+    while rem > 0:
+        t = t + b" "
+        rem = rem - 1
+    return ser_compact_size(len(s)) + t
+
+
 def uint256_from_str(s):
     r = 0
     t = struct.unpack("<IIIIIIII", s[:32])
@@ -523,7 +547,7 @@ def __repr__(self):
 
 class CBlockHeader:
     __slots__ = ("hash", "hashMerkleRoot", "hashPrevBlock", "nBits", "nNonce",
-                 "nTime", "nVersion", "sha256")
+                 "nTime", "nVersion", "sha256", "solution")
 
     def __init__(self, header=None):
         if header is None:
@@ -536,6 +560,8 @@ def __init__(self, header=None):
             self.nBits = header.nBits
             self.nNonce = header.nNonce
             self.sha256 = header.sha256
+            if SOLUTION_BLOCKS:
+                self.solution = header.solution
             self.hash = header.hash
             self.calc_sha256()
 
@@ -547,6 +573,8 @@ def set_null(self):
         self.nBits = 0
         self.nNonce = 0
         self.sha256 = None
+        if SOLUTION_BLOCKS:
+            self.solution = b""
         self.hash = None
 
     def deserialize(self, f):
@@ -557,6 +585,8 @@ def deserialize(self, f):
         self.nBits = struct.unpack("<I", f.read(4))[0]
         self.nNonce = struct.unpack("<I", f.read(4))[0]
         self.sha256 = None
+        if SOLUTION_BLOCKS:
+            self.solution = deser_sol(f)
         self.hash = None
 
     def serialize(self):
@@ -567,6 +597,8 @@ def serialize(self):
         r += struct.pack("<I", self.nTime)
         r += struct.pack("<I", self.nBits)
         r += struct.pack("<I", self.nNonce)
+        if SOLUTION_BLOCKS:
+            r += ser_sol(self.solution)
         return r
 
     def calc_sha256(self):
diff --git a/test/functional/test_framework/mininode.py b/test/functional/test_framework/mininode.py
index 52a840941b8be8..25f5681988631d 100755
--- a/test/functional/test_framework/mininode.py
+++ b/test/functional/test_framework/mininode.py
@@ -86,6 +86,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 15d2e08c93ce55..6d78a3a1270030 100755
--- a/test/functional/test_framework/test_framework.py
+++ b/test/functional/test_framework/test_framework.py
@@ -91,6 +91,7 @@ class BitcoinTestFramework(metaclass=BitcoinTestMetaClass):
 
     def __init__(self):
         """Sets test framework defaults. Do not override this method. Instead, override the set_test_params() method"""
+        self.net = "regtest"
         self.setup_clean_chain = False
         self.nodes = []
         self.network_thread = None
@@ -289,14 +290,15 @@ def setup_nodes(self):
                 assert_equal(chain_info["initialblockdownload"], False)
 
     def import_deterministic_coinbase_privkeys(self):
-        for n in self.nodes:
-            try:
-                n.getwalletinfo()
-            except JSONRPCException as e:
-                assert str(e).startswith('Method not found')
-                continue
+        if self.net == "regtest":
+            for n in self.nodes:
+                try:
+                    n.getwalletinfo()
+                except JSONRPCException as e:
+                    assert str(e).startswith('Method not found')
+                    continue
 
-            n.importprivkey(privkey=n.get_deterministic_priv_key().key, label='coinbase')
+                n.importprivkey(privkey=n.get_deterministic_priv_key().key, label='coinbase')
 
     def run_test(self):
         """Tests must override this method to define test logic"""
@@ -334,6 +336,7 @@ def add_nodes(self, num_nodes, extra_args=None, *, rpchost=None, binary=None):
                 extra_args=extra_args[i],
                 use_cli=self.options.usecli,
                 start_perf=self.options.perf,
+                net=self.net,
             ))
 
     def start_node(self, i, *args, **kwargs):
@@ -466,7 +469,7 @@ def _initialize_chain(self):
 
             # Create cache directories, run bitcoinds:
             for i in range(MAX_NODES):
-                datadir = initialize_datadir(self.options.cachedir, i)
+                datadir = initialize_datadir(self.options.cachedir, i, self.net)
                 args = [self.options.bitcoind, "-datadir=" + datadir, '-disablewallet']
                 if i > 0:
                     args.append("-connect=127.0.0.1:" + str(p2p_port(0)))
@@ -481,6 +484,7 @@ def _initialize_chain(self):
                     bitcoin_cli=self.options.bitcoincli,
                     coverage_dir=None,
                     cwd=self.options.tmpdir,
+                    net=self.net,
                 ))
                 self.nodes[i].args = args
                 self.start_node(i)
@@ -489,18 +493,19 @@ def _initialize_chain(self):
             for node in self.nodes:
                 node.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[0].generatetoaddress(25 if i != 7 else 24, self.nodes[i % 4].get_deterministic_priv_key().address)
-            sync_blocks(self.nodes)
+            if self.net == "regtest":
+                # 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[0].generatetoaddress(25 if i != 7 else 24, self.nodes[i % 4].get_deterministic_priv_key().address)
+                sync_blocks(self.nodes)
 
-            for n in self.nodes:
-                assert_equal(n.getblockchaininfo()["blocks"], 199)
+                for n in self.nodes:
+                    assert_equal(n.getblockchaininfo()["blocks"], 199)
 
             # Shut them down, and clean up cache directories:
             self.stop_nodes()
@@ -519,7 +524,7 @@ def cache_path(n, *paths):
             from_dir = get_datadir_path(self.options.cachedir, i)
             to_dir = get_datadir_path(self.options.tmpdir, i)
             shutil.copytree(from_dir, to_dir)
-            initialize_datadir(self.options.tmpdir, i)  # Overwrite port/rpcport in bitcoin.conf
+            initialize_datadir(self.options.tmpdir, i, self.net)  # Overwrite port/rpcport in bitcoin.conf
 
     def _initialize_chain_clean(self):
         """Initialize empty blockchain for use by the test.
@@ -527,7 +532,7 @@ def _initialize_chain_clean(self):
         Create an empty blockchain and num_nodes wallets.
         Useful if a test case wants complete control over initialization."""
         for i in range(self.num_nodes):
-            initialize_datadir(self.options.tmpdir, i)
+            initialize_datadir(self.options.tmpdir, i, self.net)
 
     def skip_if_no_py3_zmq(self):
         """Attempt to import the zmq package and skip the test if the import fails."""
diff --git a/test/functional/test_framework/test_node.py b/test/functional/test_framework/test_node.py
index ec5d3b267e35e8..719d59f5a4cc5a 100755
--- a/test/functional/test_framework/test_node.py
+++ b/test/functional/test_framework/test_node.py
@@ -58,7 +58,7 @@ class TestNode():
     To make things easier for the test writer, any unrecognised messages will
     be dispatched to the RPC connection."""
 
-    def __init__(self, i, datadir, *, rpchost, timewait, bitcoind, bitcoin_cli, coverage_dir, cwd, extra_conf=None, extra_args=None, use_cli=False, start_perf=False):
+    def __init__(self, i, datadir, *, rpchost, timewait, bitcoind, bitcoin_cli, coverage_dir, cwd, extra_conf=None, extra_args=None, use_cli=False, start_perf=False, net="regtest"):
         """
         Kwargs:
             start_perf (bool): If True, begin profiling the node with `perf` as soon as
@@ -69,6 +69,7 @@ def __init__(self, i, datadir, *, rpchost, timewait, bitcoind, bitcoin_cli, cove
         self.datadir = datadir
         self.stdout_dir = os.path.join(self.datadir, "stdout")
         self.stderr_dir = os.path.join(self.datadir, "stderr")
+        self.net = net
         self.rpchost = rpchost
         self.rpc_timeout = timewait
         self.binary = bitcoind
@@ -187,7 +188,7 @@ def start(self, extra_args=None, *, cwd=None, stdout=None, stderr=None, **kwargs
         # Delete any existing cookie file -- if such a file exists (eg due to
         # unclean shutdown), it will get overwritten anyway by bitcoind, and
         # potentially interfere with our attempt to authenticate
-        delete_cookie_file(self.datadir)
+        delete_cookie_file(self.datadir, self.net)
 
         # add environment variable LIBC_FATAL_STDERR_=1 so that libc errors are written to stderr and not the terminal
         subp_env = dict(os.environ, LIBC_FATAL_STDERR_="1")
@@ -209,7 +210,7 @@ def wait_for_rpc_connection(self):
                 raise FailedToStartError(self._node_msg(
                     'bitcoind exited with status {} during initialization'.format(self.process.returncode)))
             try:
-                rpc = get_rpc_proxy(rpc_url(self.datadir, self.index, self.rpchost), self.index, timeout=self.rpc_timeout, coveragedir=self.coverage_dir)
+                rpc = get_rpc_proxy(rpc_url(self.datadir, self.index, self.rpchost, self.net), self.index, timeout=self.rpc_timeout, coveragedir=self.coverage_dir)
                 rpc.getblockcount()
                 # If the call to getblockcount() succeeds then the RPC connection is up
                 self.log.debug("RPC successfully started")
diff --git a/test/functional/test_framework/util.py b/test/functional/test_framework/util.py
index 034ed893f4d87b..b5cb1672b9c9ca 100644
--- a/test/functional/test_framework/util.py
+++ b/test/functional/test_framework/util.py
@@ -270,8 +270,8 @@ def p2p_port(n):
 def rpc_port(n):
     return PORT_MIN + PORT_RANGE + n + (MAX_NODES * PortSeed.n) % (PORT_RANGE - 1 - MAX_NODES)
 
-def rpc_url(datadir, i, rpchost=None):
-    rpc_u, rpc_p = get_auth_cookie(datadir)
+def rpc_url(datadir, i, rpchost=None, net="regtest"):
+    rpc_u, rpc_p = get_auth_cookie(datadir, net)
     host = '127.0.0.1'
     port = rpc_port(i)
     if rpchost:
@@ -285,13 +285,13 @@ def rpc_url(datadir, i, rpchost=None):
 # Node functions
 ################
 
-def initialize_datadir(dirname, n):
+def initialize_datadir(dirname, n, net="regtest"):
     datadir = get_datadir_path(dirname, n)
     if not os.path.isdir(datadir):
         os.makedirs(datadir)
     with open(os.path.join(datadir, "bitcoin.conf"), 'w', encoding='utf8') as f:
-        f.write("regtest=1\n")
-        f.write("[regtest]\n")
+        f.write("%s=1\n" % (net))
+        f.write("[%s]\n" % (net))
         f.write("port=" + str(p2p_port(n)) + "\n")
         f.write("rpcport=" + str(rpc_port(n)) + "\n")
         f.write("server=1\n")
@@ -311,7 +311,7 @@ def append_config(datadir, options):
         for option in options:
             f.write(option + "\n")
 
-def get_auth_cookie(datadir):
+def get_auth_cookie(datadir, net="regtest"):
     user = None
     password = None
     if os.path.isfile(os.path.join(datadir, "bitcoin.conf")):
@@ -323,8 +323,8 @@ def get_auth_cookie(datadir):
                 if line.startswith("rpcpassword="):
                     assert password is None  # Ensure that there is only one rpcpassword line
                     password = line.split("=")[1].strip("\n")
-    if os.path.isfile(os.path.join(datadir, "regtest", ".cookie")) and os.access(os.path.join(datadir, "regtest", ".cookie"), os.R_OK):
-        with open(os.path.join(datadir, "regtest", ".cookie"), 'r', encoding="ascii") as f:
+    if os.path.isfile(os.path.join(datadir, net, ".cookie")) and os.access(os.path.join(datadir, net, ".cookie"), os.R_OK):
+        with open(os.path.join(datadir, net, ".cookie"), 'r', encoding="ascii") as f:
             userpass = f.read()
             split_userpass = userpass.split(':')
             user = split_userpass[0]
@@ -334,10 +334,10 @@ def get_auth_cookie(datadir):
     return user, password
 
 # If a cookie file exists in the given datadir, delete it.
-def delete_cookie_file(datadir):
-    if os.path.isfile(os.path.join(datadir, "regtest", ".cookie")):
+def delete_cookie_file(datadir, net="regtest"):
+    if os.path.isfile(os.path.join(datadir, net, ".cookie")):
         logger.debug("Deleting leftover cookie file")
-        os.remove(os.path.join(datadir, "regtest", ".cookie"))
+        os.remove(os.path.join(datadir, net, ".cookie"))
 
 def get_bip9_status(node, key):
     info = node.getblockchaininfo()
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index a0d9f820e69b85..2fb3623b246dd4 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -162,6 +162,7 @@
     'rpc_bind.py --ipv6',
     'rpc_bind.py --nonloopback',
     'mining_basic.py',
+    'mining_signet.py',
     'wallet_bumpfee.py',
     'rpc_named_arguments.py',
     'wallet_listsinceblock.py',