Topic: Understanding The Satoshi Codebase (Series) PART 1 - (Read 857 times)

Fun fact, you actually will find something like that.

Since halving an integer is the same as shifting all of the bits in the integer one bit to the right, the block of code that determines the block subsidy uses a right bit shift. The size of the integer being shifted is 64 bits, so after 64 bit shifts (so 64 halvings), the subsidy will be 0. However, this is not the case. After bit shifting 63 times, it is undefined behavior is C++ to shift it again for a 64th time. On many platforms, this will actually result in the entire 64 bit value wrapping around and returning to its original value which would cause the block subsidy to return to 50 Bitcoin on the 64th bit shift. So to prevent this from actually happening, there is a line that is like:

This is described (along with several jokes) in BIP 42 (the BIP is an April fool's joke, but the bug it describes is very real and has been fixed). You can see the code for this here.

There is no code that limits the subsidy... it is mathematically decided.

Since the amount rewarded by Bitcoin is /2 every 210000 blocks (about 4 years), this reward will reach zero 34 years after the genesis approximately
You can refer to this table in order to have a better idea about how it happens.

https://en.bitcoin.it/wiki/Controlled_supply

So you will not find something like


Also the number of coins mined is not 21 Millions, it is an approximation. The real number is 20999999.97690000
But of course it is more convenient to round it to 21 Millions.

Thanks for pointing that out it should have been called the raw block not geneisis block was quite tired when posting.

I will fix the above and I think you are correct I did make a mistake with the header thank you for pointing this out @pooya87

sorry but this post doesn't make any sense!
first of all what you are posting below this is not genesis block.
secondly the block header you posted doesn't exist since the block that has 0<...>02B431... as its previous block is block #556397 which has a different everything from version to merkle root.
and finally i think you made a mistake with the hash of the header since hash (2x SHA256) of what you posted in #2 is:
but the value you posted in #4 is not even close to this, not even 32 byte (it is 64 bytes)

A quick breakdown of a raw block and all it's parts broken down in a much simpler way to understand.

1. BlockHeader




2. Raw headers in hex




3. Coinbase transaction



4. Computed block hash

Now lets say the nonce value is to move to 22.

The new computed value for Block Hash would become



Now lets break down the Raw header in Hex





Each time the hash changes until the block hash is equal to or below this number in order to be valid.


** Work In Progress **

I am going to cover the entire early code base in one topic so people don't need to hunt about to find the things they want to know.
I think it would be a good way for people to visualize bitcoin and understand the underlying code behind it.

Its not just about op codes the entire codebase will be layed out here to help people understand it a little better or to allow a quick reference point  for questions regarding all things bitcoin.

Hi,

They are already described here, why do you want to redescribe them ?

Updating the OP_Code sections to include the descriptions of each OP code.
Looking for collaboration on this to try have the entire codebase in sections if anyone is willing to help with this please send me a PM to being collaboration

Thank you,  I was thinking of asking the topic to be moved to a more suitable area of the forum say "technical" section.

I thought posting here as a guide could serve as a reference to the early codebase and allow people to try to understand how bicoin works under the hood as they say.

But I do agree possibly the beginner section is not such a good place for the topic.

Magic.

Oh man, posting this in Beginners & Help it fits anywhere but not here. Its for computer scientist only which is rare case in overall public.
Anyway good guide, detailed, well formatted. GJ.

in bitcoin fixed point math is used to calculate the block subsidies.


This BIP might also be of some use to you.

https://github.com/bitcoin/bips/blob/master/bip-0042.mediawiki

In later versions of the codebase  V0.5.1 we can see this defined as a int64 value in main.h file near the top.

as :  static const int64 MAX_MONEY = 21000000 * COIN;

Fantastic work. Could you please point me out to the part that defines total supply to be 21m?

Original Op Codes - Bitcoin includes a script system for transactions.

In simple, a script is a just a list of instructions that is recorded with each transaction that describe how the next user wanting to spend the Bitcoins being transferred can gain access to them.

The script for a Bitcoin transaction to a Bitcoin address simply enduce future spending of the bitcoins with two things that must be provided.
 
    1. a public key that when hashed results in the destination address in the script.
    2. a signature to prove ownership of the private key corresponding to the public key.

Definition

Operation codes from the Bitcoin Script language which push data or perform functions within a pubkey script or signature script.

OP Code descriptions taken from https://en.bitcoin.it/wiki/
Op Code list taken from

File - script.h
@Lines 7-293




   
  


   


  
   
 
  

Part 4 - BitcoinMiner - In this section of code we can see the working of the early client and how the block is processed by the client before being submitted to the network as a valid POW.

File - main.cpp
lines 2168 - 2390
Reference - https://github.com/bitcoin/bitcoin/releases/tag/v0.1.5

//////////////////////////////////////////////////////////////////////////////
//
// BitcoinMiner
//






        

        // This section will create the coinbase transaction (TX)
        //
              
        // In this section we see the code to create a new block.
        //
      
        // Again this section will create a coinbase transaction (TX)
        //
              
        //Here we see the creation of a new block
        
      
        // We must first add our coinbase tx as first transaction

        
        // The code then collect's the latest transactions into the block

    
                    // Transaction fee requirements, mainly only needed for flood control
                    // Under 10K (about 80 inputs) is free for first 100 transactions
                    // Base rate is 0.01 per KB

                    
        
        // Prebuild hash buffer
        //
      

        // Search
        //
      
                    //// debug print for valid proof of work found
                  
                    // Save key
                                    // Process this block the same as if we had received it from another node
                  
            // Update nTime every few seconds
          
** Work in progress **

Reserved Part 3 - POW Checking

Block Checking & Submit Blocks

File - main.cpp
Line -  1154 -1295


    // This section checks the Size limits


    // This section of code if for checking the timestamp of the block, a timestamp is valid if it is greater than the median timestamp of last 11 blocks and less than the network-adjusted time + 2 hours


    // This section checks to make sure the first transaction is a coinbase transaction and everything else is not a coinbase TX


    // Check transactions


    // This section checks that the proof of work matches claimed amount


    // It is then passed to check the merkleroot


Now the code will check for AcceptBlock by checking the following aspects.

bool CBlock::AcceptBlock()

    // In this section the code performs a check for duplicate block.

  
    // Here the code will get the previous block index

    
    // It will then check the timestamp against previous block

  
    // It then performs a check on the proof of work

  
    // Here the code will write the block to history file

 
The next section is commented out of the code and I am still looking for some references for the code below and relations to VAtoms.

    // // Add atoms to user reviews for coins created

    
Next the code looks to process the block by the following.

bool ProcessBlock(CNode* pfrom, CBlock* pblock)

    // Check for duplicate
  
    // Preliminary checks

    // If don't already have its previous block, shunt it off to holding area until we get it
  
        // Ask this guy to fill in what we're missing
  
    // Store to disk
 
    // Recursively process any orphan blocks that depended on this one
  
At this point the miner would be very happy! as the block has passed the checked and can be called Valid.
The code then prints below :

Understanding The Satoshi Codebase : Bitcoin V0.1.5

With the influx of new users to bitcoin I think it is important people understand some of the underlying code behind bitcoin in this I will highlight parts of the codebase that people might find  interesting or have heard words such as genesis block ect and are not quite sure what or where to find this in the codebase.

I would like to create a topic that users can contribute from the early code base and create a reference resource that people can quickly reference to learn about the early codebase.

Posts should in the format of  
Heading = Part 1 Genesis block
File Name Ref = main.cpp
Line = 1467

(Context / text / code reference)

please use code tags.

We will be looking at Version 0.1.5 which can be downloaded from the following link.

https://github.com/bitcoin/bitcoin/releases/tag/v0.1.5

Please only use V0.1.5 for this purpose.
================================================


Part 1. Genesis Block.

Blockchain link : https://www.blockchain.com/btc/block/000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f

Reference : File  main.cpp

Line 1467




The genesis block is the beginning of the blockchain,  
This block is hard coded into the application of bitcoin.  

You can see from the above code on the first line we see

0x000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f

This is the block hash which can be found by searching in any block explorer which would give you




We can also see the reward of 50 Bitcoin for the block in :


The reward was sent to 1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa ,



How is the bitcoin reward set in bitcoin?

If we move to lines 657 to 729 in main.cpp we see the following :


On line 677 we can see the block reward for bitcoin


This was the initial block reward for bitcoin minting a new block would yield a reward of 50 bitcoin to the lucky miner at this time CPU is thought to have been the only mining that was available though as there has been research into this and thoughts are GPU mining did not surface until around 2011 time.

Every 4 years or 210,000 blocks bitcoin undergoes what is called the halving.  Where block reward subsidy is halved starting from 50 bitcoin the protocol follows the following structure in the codebase.  


The estimated next date for bitcoin halving is 24 May 2020 09:01:59

Currently the block reward is 12.5 Bitcoins this will drop to 6.25 bitcoins around this time.  
Current information on bitcoin : Correct at time of writing..



The bitcoin difficulty re-target is also part of this code :


In this process we see the following

First is to translate the bits of block N + 2015 to a BigNum target and then calculate the timespan between blocks N and N +2015 into a inumber of seconds.

We would then multiply the old target by the timespan then to divide the result by the timespan ie. 2 weeks = 1209600 s this integer is arithmetic so it is rounded down and the result would be the new target.

The difficulty retarget is such that is should retarget ever 2 weeks you can check the difficulty retargeting on charts such as.

https://fork.lol/pow/retarget
https://bitcoinwisdom.com/bitcoin/difficulty

In part 2 we will look at the networking and P2P structure of the codebase,

Please feel free to contribute to this project it will become a great resource for people to reference without having to trawl the internet for information.