BSV blockchainBSV blockchain

Blockchain

A block on the BSV blockchain is a header plus a list of transactions, and each header names the header before it. Miners add blocks by finding a header whose hash is below a target, a rule called proof of workThe work a miner does to find a block header whose hash is below the target. How transactions and fees work covers the transactions inside a block. On this page you can mine blocks in an interactive chain and run two short scripts that hash a block header and check a Merkle path.

The examples run with Node.js after npm install @bsv/sdk and were written against @bsv/sdk 4.0.1.

What a block contains

A block is its header followed by its transactions, and the 80 byte header is the part that gets hashed. Edit a block below and mine it to see how the header hash, the target and the link to the next block fit together.

Edit a block, then mine it. Every block after it breaks.

Target
leading zeros
Block 1Valid
Merkle root
5e22ee...867e
Previous hash
0000...0000
Nonce
74
000cb9036a3ead...
Block 2Valid
Merkle root
decbe8...e0c3
Previous hash
000cb9...84e0
Nonce
4,550
00055e06bb2d63...
Block 3Valid
Merkle root
014f1e...265f
Previous hash
00055e...6365
Nonce
7,165
000028a611d477...
Bits 0x1f100000Hashes tried 0
All three blocks are valid.

The block header

FieldSizeWhat it holds
Version4 bytesThe block version
Previous block hash32 bytesThe hash of the header before this one
Merkle rootOne hash that stands for all the transactions in a block32 bytesOne hash that stands for every transaction in the block
Time4 bytesSeconds since 1970-01-01 UTC
Bits4 bytesThe target, in a compact form
NonceA number the miner changes to get a different hash4 bytesA number the miner changes to search for a valid hash

The block hash is the double SHA-256 of the header, and it is written with its bytes reversed, which is how explorers show it. The header below is the first block, and its hash starts with zeros because it is below the target.

header.mjs
import { Hash, Utils } from '@bsv/sdk'

// The 80 byte header of the first block, as hex
const header =
  '01000000' + // version
  '0000000000000000000000000000000000000000000000000000000000000000' + // previous block hash
  '3ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a' + // Merkle root
  '29ab5f49' + // time
  'ffff001d' + // bits
  '1dac2b7c' // nonce

const hash = Utils.toHex(Hash.hash256(Utils.toArray(header, 'hex')).reverse())

console.log(header.length / 2, 'bytes')
console.log(hash)
80 bytes
000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f

Time, height and depth

Numbers in the header are stored little endian, so the time 29ab5f49 is 1,231,006,505, which is January 3, 2009, at 18:15:05 UTC. A transaction has no time of its own. It takes the time of the block that includes it.

The position of a block in the chain is its height, counted from zero at the first block. How many blocks sit on top of it is its depth.

How blocks form a chain

Each header holds the hash of the header before it, so changing any block changes its hash and breaks the link in the next one. To change an old block, a miner would have to redo its proof of work and that of every block after it. The first block has no parent, so its previous hash is all zeros, as in the header above.

Proof of work

A block counts only if its hash meets the target, and finding such a hash takes work.

Finding a valid hash

A miner has a valid block when the hash of its header, read as a 256 bit number, is below the target. The miner changes the nonce until the hash is below the target. The nonce has only 32 bits, so miners also change a field in the coinbase transactionThe first transaction in a block, which pays the miner, which changes the Merkle root and gives them a new set of headers to try.

The target and difficulty

The bits field holds the target in compact form. The first byte is an exponent and the next three are the start of the number, so 0x1d00ffff means 0xffff followed by zeros, the target at difficultyHow much harder a target is to meet than the easiest one 1. Difficulty measures how much harder a target is than that one, so a lower target means a higher difficulty. The network adjusts the target so blocks keep arriving about 10 minutes apart on average.

Miners hash the header and not the transactions. The transactions are covered through the Merkle root, so searching for a valid hash costs the same for a block with one transaction as for a block with a million.

Merkle trees

A Merkle treeA tree of hashes in which pairs are hashed together until one hash is left lets a block header stand for every transaction in the block.

The tree and the root

Each transaction ID in a block is a leaf of a Merkle tree, and the leaves are hashed in pairs, level by level, until one hash is left, the Merkle root. A block with one transaction has that transaction’s ID as its root, which is why the first block’s root is the ID of its only transaction.

A Merkle path

A Merkle path is the hashes a verifier needs to get from one transaction to the root. Given the path and the transaction ID, anyone can compute the root and compare it with the one in a block header, without the rest of the transactions. MerklePath in @bsv/sdk does this.

merkle.mjs
import { Hash, MerklePath, Utils } from '@bsv/sdk'

const bytes = (hex) => Utils.toArray(hex, 'hex').reverse()
const leaf = (text) => Utils.toHex(Hash.hash256(Utils.toArray(text, 'utf8')).reverse())
const parent = (left, right) => Utils.toHex(Hash.hash256([...bytes(left), ...bytes(right)]).reverse())

const [a, b, c, d] = ['tx a', 'tx b', 'tx c', 'tx d'].map(leaf)

const proof = new MerklePath(100, [
  [{ offset: 0, hash: a, txid: true }, { offset: 1, hash: b }],
  [{ offset: 1, hash: parent(c, d) }]
])

console.log(proof.computeRoot(a))
console.log(parent(parent(a, b), parent(c, d)))
ebabf2603108438b09fd9ad221b193f8bd35b78d12bf732d2f0d278ed478ca24
ebabf2603108438b09fd9ad221b193f8bd35b78d12bf732d2f0d278ed478ca24
  • bytes, leaf and parent are helpers. Hashes are written the way explorers show them, so each helper reverses the bytes before and after hashing.
  • a, b, c and d are four stand-in transaction IDs, and 100 is an arbitrary block height.
  • Each entry of the path has an offset, its position in that level of the tree, and txid: true marks the transaction the path proves.
  • The proof for a holds only two hashes, b and the hash of c and d, and it gives the same root as hashing the whole tree. A path that does not contain the transaction ID is rejected.

BEEFBackground Evaluation Extended Format (BRC-62) packages these paths with the transactions they prove, and BEEF (BRC-62) covers the format.

The coinbase transaction and block rewards

Every block pays its miner through its first transaction.

The coinbase transaction

The first transaction in every block is the coinbase transaction, and the miner who found the block creates it. It has a single input with a previous transaction hash of all zeros and an output index of 0xFFFFFFFF, because it spends nothing, and its outputs pay the miner.

The block subsidy

A block pays its miner the block subsidy plus the fees of the transactions it includes. The subsidy started at 50 BSV, which is 5,000,000,000 satoshisThe smallest unit of BitcoinSV (BSV), 100,000,000 satoshis make 1 BSV, and halves every 210,000 blocks, about every four years. It reaches zero after 33 halvings, around the year 2140. A miner can only spend coinbase outputs after 100 more blocks have been added.

When blocks compete

Two miners can find a valid block at about the same time, so the network briefly has two blocks that build on the same parent. A node builds on the first valid one it saw. When the next block extends one of them, the chain with the most proof of work wins, and miners move to it. A valid block that does not end up in that chain is an orphan blockA valid block that is not part of the chain with the most proof of work, and its transactions go back to the pool of unconfirmed transactions unless the winning chain already holds them.

A transaction with one block on top of it can still be reversed if that block loses, and each further block makes that less likely. How transactions and fees work shows how an app sees a transaction move from signed to confirmed.

To learn more about blocks on the BSV blockchain, review these articles: