Proof of Work

A basic implementation of the Proof of Work (PoW) algorithm used as Sybil prevention by Bitcoin and other PoW networks. A deeper comparison between PoW and Proof of Stake (PoS) can be found in our article PoW vs PoS: The Next Industrial Revolution.

Method & Python Script

1. Install VS Code: https://code.visualstudio.com or similar application.

2. In VS Code open a new terminal window by navigating to Terminal > New Terminal.

3. Install Homebrew by pasting the following code into the terminal and pressing Enter:

   /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

4. Install Python in the same way:

   brew install python

5. There are no dependencies to install. The script uses only hashlib and datetime, both of which are part of the Python standard library and are already available once Python is installed. Do not try to pip install them: the packages published on PyPI under those names are an obsolete Python 2 backport of hashlib and an unrelated Zope date type, so the command will either fail to build or shadow the standard library.

6. Now, create a project folder and navigate to it in VS Code via File > Open Folder.

7. Create a new Python file in VS Code via File > New File. Name it something like pow.py

8. This script calculates the hash for the text “hello” with five leading zeros. Copy and paste it into pow.py and save it.

# v.0.1
 
from hashlib import sha256
from datetime import datetime
 
def pow(data, zeros, nonce):
    data = str(data).encode("utf-8")
    zeros = zeros * "0"
 
    t1 = datetime.now()
    while True:
        combo = data + f"{nonce}".encode("utf-8")
        hash_ = sha256(combo).hexdigest()
        if hash_.startswith(zeros):
            t2 = datetime.now()
            return nonce, hash_, t2-t1
        else:
            nonce += 1
 
output = pow("hello", 5, 0) # 5 = ~ 1 second
print(output)

9. Run the script from the terminal with:

python3 pow.py

How long it takes

Each additional leading zero multiplies the expected work by sixteen. A hexadecimal digit carries four bits, so a hash with z leading zeros turns up once in 16^z attempts on average – about 1.05 million at five zeros, 16.8 million at six, 268 million at seven. This loop sustains roughly 1.8 million hashes per second on a single core of a 2026 laptop under CPython 3.13, which puts five zeros at about 0.6 seconds, six at about ten seconds and seven at two and a half minutes. Slower hardware, an older interpreter or a longer input shift those numbers but not the factor of sixteen between them.

Individual runs scatter much further than the averages suggest, because the search is memoryless: every nonce is an independent trial with probability 16^−z of succeeding, so the number of attempts is geometrically distributed and its standard deviation is essentially equal to its mean. Two runs of the script above make the point – five zeros finished at nonce 156,056, a seventh of the expected work, while six zeros needed 33,290,382, about twice it. A single fast or slow run says nothing about the difficulty.

That spread is why proof of work is a rate limiter rather than a clock, and why Bitcoin only averages it out at network scale: the protocol recalculates the target every 2,016 blocks from the time those blocks actually took, against an ideal of 1,209,600 seconds – two weeks, or ten minutes a block – so the difficulty tracks whatever hash rate the network is currently pointing at it. The same arithmetic sits behind the energy comparison in PoW vs PoS: raising the zero count costs nothing to verify and everything to produce.

Cost and hardware

Daniel Krawisz's 2013 essay The Proof-of-Work Concept argues that the cost is what makes the scheme work. Miners who each prefer a block that suits them can still agree, because a block that takes difficult, random work to find arrives as the only candidate, and a miner who holds out for a better one has to persuade the rest to follow. Krawisz compares it to the handicap principle in biology, under which a signal is believable only when it is costly to send.

The script uses SHA-256, the function Bitcoin mines with. The CryptoNote paper, published in 2013 under the name Nicolas van Saberhagen, points out that SHA-256 depends only on processor speed and suits multicore and pipelined hardware, which favours the minority of miners with graphics cards, programmable chips (FPGAs) and application-specific chips (ASICs) over the majority mining on ordinary CPUs. Under the heading egalitarian proof of work, it proposed a memory-bound function instead, whose running time is dominated by reads from a large block of memory, so that specialised hardware gains less.

Claims that such functions make mining fairer stayed informal until Dimitris Karakostas, Aggelos Kiayias, Christos Nasikas and Dionysis Zindros defined egalitarianism as how evenly a network's rewards pay per unit of capital invested, whatever its size. Their simulations rank Bitcoin the least egalitarian of four large proof-of-work coins, and Litecoin and Monero, which then mined with the memory-hard functions scrypt and CryptoNight, the most. Proof of stake without delegation came out ahead of all of them.

References

1. Karakostas, Dimitris; Kiayias, Aggelos; Nasikas, Christos and Zindros, Dionysis (2019). Cryptocurrency Egalitarianism: A Quantitative Approach. Tokenomics 2019, OASIcs vol. 71.
2. Krawisz, Daniel (2013). The Proof-of-Work Concept. Satoshi Nakamoto Institute.
3. van Saberhagen, Nicolas (2013). CryptoNote v 2.0. cryptonote.org (archived via the Internet Archive).