我们如何证明比特币区块总是可以解决的？

Question

I'm trying to implement a simple cryptocurrency similar to bitcoin, just to understand it deeply down to the code level.

I understand that a bitcoin block contains a hash of the previous block, many transactions and an reward transaction for the solver.

the miner basically runs SHA256 on this candidate block combined with an random number. As long as the first certain digits of a hash result are zeros, we say this block is solved, and we broadcast the result to the entire network to claim the reward.

but I have never seen anyone proving that a block is solvable at all. I guess this is guaranteed by SHA256? because the solution size is fixed, after trying enough inputs, you are guaranteed to hit every hash result? but how can you prove that the solution distribution of a block is even (uniform), so that you can indeed cover all hash results?

now, suppose a block is indeed always solvable, can I assume that using 64bit for the random integer is enough to solve it? how about 32bit? or I have to use an infinite bit integer?

for example, in the basiccoin project:

the code for proof of work is the following:

    def POW(block, hashes):
    halfHash = tools.det_hash(block)
    block[u'nonce'] = random.randint(0, 10000000000000000000000000000000000000000)
    count = 0
    while tools.det_hash({u'nonce': block['nonce'],
                          u'halfHash': halfHash}) > block['target']:
        count += 1
        block[u'nonce'] += 1
        if count > hashes:
            return {'error': False}
        if restart_signal.is_set():
            restart_signal.clear()
            return {'solution_found': True}
        ''' for testing sudden loss in hashpower from miners.
        if block[u'length']>150:
        else: time.sleep(0.01)
        '''
    return block

this code randoms a number between [0, 10000000000000000000000000000000000000000] as a start point, and then it just increases the value one by one:

block[u'nonce'] += 1

I'm not a python programmer, I don't know how python handles the type of the integer. there is no handling of integer overflow.

I'm trying to implement similar thing with c++, I don't know what kind of integer can guarantee a solution.

Answer 1

but how can you prove that the solution distribution of a block is even (uniform), so that you can indeed cover all hash results?

SHA256 is deterministic so if you rehash the txns it will always provide the same 256 hash. The client nodes keep all the txn and the hashes in the merkle tree for the network clients to propagate and verify the longest possible block chain.

The merkle tree is the essential data structure for recording the hashes of previous blocks. From there the chain of hash confirmations can be tracked from the origin (genesis) block.