Signet implementation

test/functional/data/rpc_getblockstats.json needs to be touched because:

Signet implementation changes the genesis block for custom chains

Author: kallewoof

contrib/example.conf

@@ -0,0 +1,16 @@
+
+chain=signet
+
+[signet]
+con_genesis_style=signet_old
+signet_blockscript=512103e464a9f3070da4d3e0b34ce971ff36f3e07c47a8f4beadf32e8ea7e2afa8a82451ae
+signet_siglen=77
+# DG seed node
+seednode=178.128.221.177
+bech32_hrp=sb
+pchmessagestart=F0C7706A
+pubkeyprefix=125
+scriptprefix=87
+secretprefix=217
+extpubkeyprefix=043587CF
+extprvkeyprefix=04358394

contrib/signet/issuer/issuer.sh

@@ -0,0 +1,75 @@
+#!/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
+
+let 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
+    let rv=$RANDOM%$randinterval
+    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

src/chain.h

@@ -405,6 +405,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

src/chainparams.cpp

@@ -428,6 +428,10 @@ class CCustomParams : public CRegTestParams {
         consensus.nMinimumChainWork = uint256S(args.GetArg("-con_nminimumchainwork", "0x0"));
         consensus.defaultAssumeValid = uint256S(args.GetArg("-con_defaultassumevalid", "0x00"));
 
+        consensus.blockscript = ParseHex(args.GetArg("-signet_blockscript", ""));
+        g_solution_blocks = !consensus.blockscript.empty();
+        g_solution_block_len = consensus.siglen = args.GetArg("-signet_siglen", 77);
+
         nPruneAfterHeight = (uint64_t)args.GetArg("-npruneafterheight", nPruneAfterHeight);
         fDefaultConsistencyChecks = args.GetBoolArg("-fdefaultconsistencychecks", fDefaultConsistencyChecks);
         fMineBlocksOnDemand = args.GetBoolArg("-fmineblocksondemand", fMineBlocksOnDemand);

src/chainparamsbase.cpp

@@ -24,6 +24,8 @@ void SetupChainParamsBaseOptions()
     gArgs.AddArg("-con_genesis_style=<style>", "Use genesis style <style> (default: signet_new). Allowed values: genesis_style1, signet_new, signet_old", true, OptionsCategory::CHAINPARAMS);
     gArgs.AddArg("-vbparams=deployment:start:end", "Use given start/end times for specified version bits deployment (regtest or custom only)", true, OptionsCategory::CHAINPARAMS);
     gArgs.AddArg("-seednode=<ip>", "Use specified node as seed node. This option can be specified multiple times to connect to multiple nodes. (custom only)", true, OptionsCategory::CHAINPARAMS);
+    gArgs.AddArg("-signet_blockscript", "Blocks must satisfy the given script to be considered valid instead of using pow. If empty, and by default, it is ignored. (custom only)", true, 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 (custom only)", true, OptionsCategory::CHAINPARAMS);
 }
 
 static std::unique_ptr<CBaseChainParams> globalChainBaseParams;

src/miner.cpp

@@ -55,6 +55,9 @@ 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)

src/policy/policy.cpp

@@ -14,6 +14,7 @@
 #include <util.h>
 #include <utilstrencodings.h>
 
+unsigned int GetStandardScriptVerifyFlags() { return STANDARD_SCRIPT_VERIFY_FLAGS; }
 
 CAmount GetDustThreshold(const CTxOut& txout, const CFeeRate& dustRelayFeeIn)
 {

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;
 

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;

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

src/primitives/block.cpp

@@ -10,6 +10,10 @@
 #include <utilstrencodings.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);

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.GetType() & SER_GETHASH)) {
+            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()

src/rpc/blockchain.cpp

@@ -115,16 +115,16 @@ UniValue blockToJSON(const CBlock& block, const CBlockIndex* blockindex, bool tx
 {
     AssertLockHeld(cs_main);
     UniValue result(UniValue::VOBJ);
-    result.pushKV("hash", blockindex->GetBlockHash().GetHex());
+    result.pushKV("hash", block.GetHash().GetHex());
     int confirmations = -1;
     // Only report confirmations if the block is on the main chain
-    if (chainActive.Contains(blockindex))
+    if (blockindex && chainActive.Contains(blockindex))
         confirmations = chainActive.Height() - blockindex->nHeight + 1;
     result.pushKV("confirmations", confirmations);
     result.pushKV("strippedsize", (int)::GetSerializeSize(block, SER_NETWORK, PROTOCOL_VERSION | SERIALIZE_TRANSACTION_NO_WITNESS));
     result.pushKV("size", (int)::GetSerializeSize(block, SER_NETWORK, PROTOCOL_VERSION));
     result.pushKV("weight", (int)::GetBlockWeight(block));
-    result.pushKV("height", blockindex->nHeight);
+    if (blockindex) result.pushKV("height", blockindex->nHeight);
     result.pushKV("version", block.nVersion);
     result.pushKV("versionHex", strprintf("%08x", block.nVersion));
     result.pushKV("merkleroot", block.hashMerkleRoot.GetHex());
@@ -142,18 +142,23 @@ UniValue blockToJSON(const CBlock& block, const CBlockIndex* blockindex, bool tx
     }
     result.pushKV("tx", txs);
     result.pushKV("time", block.GetBlockTime());
-    result.pushKV("mediantime", (int64_t)blockindex->GetMedianTimePast());
+    if (blockindex) result.pushKV("mediantime", (int64_t)blockindex->GetMedianTimePast());
     result.pushKV("nonce", (uint64_t)block.nNonce);
     result.pushKV("bits", strprintf("%08x", block.nBits));
-    result.pushKV("difficulty", GetDifficulty(blockindex));
-    result.pushKV("chainwork", blockindex->nChainWork.GetHex());
-    result.pushKV("nTx", (uint64_t)blockindex->nTx);
+    if (blockindex) result.pushKV("difficulty", GetDifficulty(blockindex));
+    if (blockindex) result.pushKV("chainwork", blockindex->nChainWork.GetHex());
+    if (blockindex) result.pushKV("nTx", (uint64_t)blockindex->nTx);
 
-    if (blockindex->pprev)
+    if (blockindex && blockindex->pprev)
         result.pushKV("previousblockhash", blockindex->pprev->GetBlockHash().GetHex());
-    CBlockIndex *pnext = chainActive.Next(blockindex);
-    if (pnext)
-        result.pushKV("nextblockhash", pnext->GetBlockHash().GetHex());
+    if (blockindex) {
+        CBlockIndex *pnext = chainActive.Next(blockindex);
+        if (pnext)
+            result.pushKV("nextblockhash", pnext->GetBlockHash().GetHex());
+    }
+    if (g_solution_blocks && g_blockheader_payload_map.count(block.GetHash())) {
+        result.pushKV("signet-solution", HexStr(g_blockheader_payload_map.at(block.GetHash())));
+    }
     return result;
 }
 

src/rpc/client.cpp

@@ -55,6 +55,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" },

src/rpc/mining.cpp

@@ -695,7 +695,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) {
@@ -725,6 +725,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);
@@ -942,7 +947,6 @@ static const CRPCCommand commands[] =
     { "mining",             "getblocktemplate",       &getblocktemplate,       {"template_request"} },
     { "mining",             "submitblock",            &submitblock,            {"hexdata","dummy"} },
 
-
     { "generating",         "generatetoaddress",      &generatetoaddress,      {"nblocks","address","maxtries"} },
 
     { "hidden",             "estimatefee",            &estimatefee,            {} },

src/script/interpreter.cpp

@@ -1416,6 +1416,22 @@ 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;

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
 {

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)) {