Blockchain ([ErLo18], Kapitel 11)

Bitcoin

Block ([ErLo18],Kap. 11.9)

• 4-Byte-Kennzeichnung als Bitcoin-Block
• Angabe Blockgrösse
• 80-Byte Blockheader
• Transaktionszähler
• Die zu bestätigenden Transaktionen

Blockheader ([ErLo18],Kap. 11.10)

# Vergleicht bei SHA256 hashing mit difficulty und nonce.
import hashlib
import datetime

difficulty = 5  # Bit
nonce = 5   # Bit
block = "Blockchain " + str(datetime.datetime.utcnow())

# Wandelt hex-String in binaer-String um
def binaer(hexEingabe):
  rueck = ""
  for a in hexEingabe:
    teil = a if ord(a) < 97 else "1"+chr(ord(a) - 49)
    binaer = str(bin(int(teil)))
    rueck += binaer[2:].rjust(4,'0')
  return rueck


# hasht ein Wort ueber nonce; testet, ob Schwierigkeit erreicht
def schleife(difficulty, nonce):
  versuche = 2**nonce
  vergleich = "".ljust(difficulty,'0')
  treffer = 0
  for a in range(0,versuche):
    wert = (block + str(a)).ljust(50,' ')
    erg = hashlib.sha256(bytearray(wert,'latin-1'))
    hash = binaer(erg.hexdigest())
    if (hash[0:difficulty] == vergleich):
      print("Treffer ",wert, hash)
      treffer += 1
  if (treffer == 0):
    print("Suche war erfolglos !")


schleife(difficulty,nonce)

Wie kann man sich Bitcoin-Transaktionen anzeigen lassen

Wie viele Bitcoins gibt es ([ErLo18],Kap. 11.16)

Was sind die Vor- und Nachteile einer Blockchain

Gibt es Alternativen zu sequentiellem hashing ?

Wie funktioniert bitcoin-core

Infos über Blöcke

class CBlockHeader
{
public:
    // header
    int32_t nVersion;
    uint256 hashPrevBlock;
    uint256 hashMerkleRoot;
    uint32_t nTime;
    uint32_t nBits;
    uint32_t nNonce;
  ...

class CBlock : public CBlockHeader
{
public:
    // network and disk
    std::vector<CTransactionRef> vtx;

    // memory only
    mutable bool fChecked;
  ...

Infos über Transaktionen

class CTransaction
{
public:
    static const int32_t CURRENT_VERSION=2;
    static const int32_t MAX_STANDARD_VERSION=2;

    const std::vector<CTxIn> vin;
    const std::vector<CTxOut> vout;
    const int32_t nVersion;
    const uint32_t nLockTime;

private:
    const uint256 hash;
    const uint256 m_witness_hash;

class CTxIn
{
public:
    COutPoint prevout;
    CScript scriptSig;
    uint32_t nSequence;
    CScriptWitness scriptWitness;
...

class CTxOut
{
public:
    CAmount nValue;
    CScript scriptPubKey;
...

Wie kann man im Quelltext suchen ohne IDE wie Eclipse

jurgen@jurgen-LIFEBOOK-S710:~/bitcoin-master/src$ find . -name "*.cpp" -exec fgrep -l "generateBlocks" {} \;
./rpc/mining.cpp

jurgen@jurgen-LIFEBOOK-S710:~/bitcoin-master/src$ find . -name "*.h" -exec fgrep -l "nNonce" {} \;
./chain.h
./primitives/block.h

init.cpp

AppInitMain [init.cpp]
 ThreadImport
  LoadExternalBlockfile
   ActiveBestChain [validation.cpp]
    ActiveBestChainStep
     ConnectTip
      UpdateTip
       Meldung "UpdateTip: new best=..."

validation.cpp

rpc/mining.cpp

Ort des Minings, also Variation der Nonce

static UniValue generateBlocks(const CTxMemPool& mempool, const CScript& coinbase_script, int nGenerate, uint64_t nMaxTries)
{
    int nHeightEnd = 0;
    int nHeight = 0;

    {   // Don't keep cs_main locked
        LOCK(cs_main);
        nHeight = ::ChainActive().Height();
        nHeightEnd = nHeight+nGenerate;
    }
    unsigned int nExtraNonce = 0;
    UniValue blockHashes(UniValue::VARR);
    while (nHeight < nHeightEnd && !ShutdownRequested())
    {
        std::unique_ptr<CBlockTemplate> pblocktemplate(BlockAssembler(mempool, Params()).CreateNewBlock(coinbase_script));
        if (!pblocktemplate.get())
            throw JSONRPCError(RPC_INTERNAL_ERROR, "Couldn't create new block");
        CBlock *pblock = &pblocktemplate->block;
        {
            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()) {
            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());
    }
    return blockHashes;
}

        std::unique_ptr<CBlockTemplate> pblocktemplate(BlockAssembler(mempool, Params()).CreateNewBlock(coinbase_script));

        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;

Ausgaben in bitcoind

jurgen@jurgen-LIFEBOOK-S710:~/.bitcoin$ ls -lrt
total 11468
drwxrwxr-x 2 jurgen jurgen     4096 Feb  3 21:08 wallets
drwxrwxr-x 5 jurgen jurgen     4096 Feb  3 21:13 testnet3
-rw------- 1 jurgen jurgen       37 Mär 27 17:50 banlist.dat
-rw------- 1 jurgen jurgen       86 Mär 29 09:02 bitcoin.conf
drwx------ 3 jurgen jurgen     4096 Apr  2 17:48 blocks
drwx------ 2 jurgen jurgen     4096 Apr  2 20:49 chainstate
-rw------- 1 jurgen jurgen  1364698 Apr  2 20:52 peers.dat
-rw------- 1 jurgen jurgen       17 Apr  2 20:52 mempool.dat
-rw------- 1 jurgen jurgen   247985 Apr  2 20:52 fee_estimates.dat
-rw------- 1 jurgen jurgen 10094606 Apr  2 20:52 debug.log

jurgen@jurgen-LIFEBOOK-S710:~/.bitcoin/blocks$ ls
blk00000.dat  blk00006.dat  blk00012.dat  rev00004.dat  rev00010.dat
blk00001.dat  blk00007.dat  index         rev00005.dat  rev00011.dat
blk00002.dat  blk00008.dat  rev00000.dat  rev00006.dat  rev00012.dat
blk00003.dat  blk00009.dat  rev00001.dat  rev00007.dat
blk00004.dat  blk00010.dat  rev00002.dat  rev00008.dat
blk00005.dat  blk00011.dat  rev00003.dat  rev00009.dat

Mining aufrufen

    if (::ChainstateActive().IsInitialBlockDownload())
        throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, PACKAGE_NAME " is in initial sync and waiting for blocks...");

    if (false) // ::ChainstateActive().IsInitialBlockDownload())
        throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, PACKAGE_NAME " is in initial sync and waiting for blocks...");
    LogPrintf("Huerde passiert\n");

        if (false) { // pcheckpoint && nHeight < pcheckpoint->nHeight) {
            LogPrintf("ERROR: %s: forked chain older than last checkpoint (height %d)\n", __func__, nHeight);
            return state.Invalid(BlockValidationResult::BLOCK_CHECKPOINT, "bad-fork-prior-to-checkpoint");
        }

bitcoin-cli getblocktemplate '{"rules": ["segwit"]}'

bitcoin-cli generatetoaddress 1 bc1qflg52jg3twfech9qvzreavhssw9en50pqxd0cx 10000

bitcoin-cli getmempoolinfo

Was ist eine Merkle-Root

Mempool/Transactionpool

Nachrichtensystem

    if (strCommand == NetMsgType::HEADERS)
    ...

        connman->PushMessage(pfrom, msgMaker.Make(NetMsgType::HEADERS, vHeaders));

            connman->PushMessage(pfrom, msgMaker.Make(NetMsgType::GETHEADERS, ::ChainActive().GetLocator(pindexLast), uint256()));

    if (strCommand == NetMsgType::HEADERS)
...
       for (unsigned int n = 0; n < nCount; n++) {
            vRecv >> headers[n];
            ReadCompactSize(vRecv); // ignore tx count; assume it is 0.
        }

        return ProcessHeadersMessage(pfrom, connman, headers, chainparams, /*via_compact_block=*/false);

    if (strCommand == NetMsgType::GETHEADERS) {
  ...

        if (::ChainstateActive().IsInitialBlockDownload() && !pfrom->HasPermission(PF_NOBAN)) {
            LogPrint(BCLog::NET, "Ignoring getheaders from peer=%d because node is in initial block download\n", pfrom->GetId());
            return true;
        }

                    connman->PushMessage(pfrom, msgMaker.Make(NetMsgType::GETDATA, vGetData));

    if (strCommand == NetMsgType::BLOCK)
    {
...
        std::shared_ptr pblock = std::make_shared();
        vRecv >> *pblock;

        LogPrint(BCLog::NET, "received block %s peer=%d\n", pblock->GetHash().ToString(), pfrom->GetId());
...
        ProcessNewBlock(chainparams, pblock, forceProcessing, &fNewBlock);

    if (strCommand == NetMsgType::GETBLOCKS) {
        CBlockLocator locator;
        uint256 hashStop;
        vRecv >> locator >> hashStop;

    if (strCommand == NetMsgType::INV) {
        std::vector vInv;
        vRecv >> vInv;
...

        for (CInv &inv : vInv)
        {
            if (interruptMsgProc)
                return true;

            bool fAlreadyHave = AlreadyHave(inv);
            LogPrint(BCLog::NET, "got inv: %s  %s peer=%d\n", inv.ToString(), fAlreadyHave ? "have" : "new", pfrom->GetId());

            if (inv.type == MSG_TX) {
                inv.type |= nFetchFlags;
            }

            if (inv.type == MSG_BLOCK) {
                UpdateBlockAvailability(pfrom->GetId(), inv.hash);
                if (!fAlreadyHave && !fImporting && !fReindex && !mapBlocksInFlight.count(inv.hash)) {
...
                    connman->PushMessage(pfrom, msgMaker.Make(NetMsgType::GETHEADERS, ::ChainActive().GetLocator(pindexBestHeader), inv.hash));
                    LogPrint(BCLog::NET, "getheaders (%d) %s to peer=%d\n", pindexBestHeader->nHeight, inv.hash.ToString(), pfrom->GetId());
                }
            }
            else
            {
                pfrom->AddInventoryKnown(inv);
                if (fBlocksOnly) {
...
                } else if (!fAlreadyHave && !fImporting && !fReindex && !::ChainstateActive().IsInitialBlockDownload()) {
                    RequestTx(State(pfrom->GetId()), inv.hash, current_time);
                }
            }
        }

Aktualisierungsprozess der Blockchain

2020-04-13T07:44:37Z Synchronizing blockheaders, height: 625731 (~100.00%)

        //
        // Message: getdata (blocks)
        //
        std::vector vGetData;
        if (!pto->fClient && ((fFetch && !pto->m_limited_node) || !::ChainstateActive().IsInitialBlockDownload()) && state.nBlocksInFlight < MAX_BLOCKS_IN_TRANSIT_PER_PEER) {
            std::vector vToDownload;
            NodeId staller = -1;
            FindNextBlocksToDownload(pto->GetId(), MAX_BLOCKS_IN_TRANSIT_PER_PEER - state.nBlocksInFlight, vToDownload, staller, consensusParams);
            for (const CBlockIndex *pindex : vToDownload) {
                uint32_t nFetchFlags = GetFetchFlags(pto);
                vGetData.push_back(CInv(MSG_BLOCK | nFetchFlags, pindex->GetBlockHash()));
                MarkBlockAsInFlight(pto->GetId(), pindex->GetBlockHash(), pindex);
                LogPrint(BCLog::NET, "Requesting block %s (%d) peer=%d\n", pindex->GetBlockHash().ToString(),
                    pindex->nHeight, pto->GetId());
            }
...
        }
...
        if (!vGetData.empty())
            connman->PushMessage(pto, msgMaker.Make(NetMsgType::GETDATA, vGetData));

Zusammenhang zwischen private key und public key ([AnAn18], Kap. 4)

Abgeleitete Bitcoin-Blockchains

• Bitcoin (BTC), hashrate* 108 ExtraH/sek
• Bitcoin-Cash(BCH), hashrate* 2,8 ExtraH/sek
• Bitcoin-SV(BSV), hashrate* 1,3 ExtraH/sek

Litecoin

Quellen (gelesener und empfehlenswerter Bücher)