Bitcoin のブロックは、トランザクション(送金などの記録)をまとめて履歴に足す単位です。先頭に 80 バイトのブロックヘッダが付き、そこにブロックを作った時刻が 4 バイトで入っています。

次のコードは、続けて作られた 973,961 番と 973,962 番のブロックから時刻を取り出し、後のブロックから前のブロックを引きます。ブロックはおよそ 10 分に 1 個なので、差は正で、数百秒ほどになると予想するのではないでしょうか。何が出力されるでしょうか。

import json
import struct

blocks = {b["height"]: b for b in json.load(open("output/blocks.json"))}
period = [blocks[h] for h in range(973728, 975744)]  # 本記事で読む 2,016 個


def header_time(height):
    raw = bytes.fromhex(blocks[height]["header"])  # 80 バイトのヘッダ
    return struct.unpack("<I", raw[68:72])[0]       # 68〜71 バイト目が時刻


print(header_time(973962) - header_time(973961))

出力は -372 です。後に作られたブロックの方が、6 分ほど前の時刻を持っています。この 2 個だけの珍しい例ではなく、2026 年 10 月 29 日〜11 月 14 日の 2,016 個のうち 58 個が、前のブロックより古い時刻でした。

横軸は直前ブロックとの時刻差(分)、縦軸はブロックの数。973,728〜975,743 番の 2,016 個のうち、0 より左の赤い棒が 58 個(2.9%)あり、最も古いのは −372 秒。0〜10 分の棒が最も高く、右に行くほど低くなる。60 分を超える 8 個は省略

直前ブロックとの時刻差(973,728〜975,743 番の 2,016 個)

ブロックの時刻で入金を集計したり、時刻の順にブロックを並べたりすると、この逆転にぶつかります。時刻が逆転した 2 個が日付の境目をまたぐと、後のブロックが前日の集計に入ります。ブロックの中身を表示するエクスプローラという Web サイトでブロックを眺めて、時刻が戻っていることに気づく人もいるでしょう。


本記事では、2026 年 11 月 17 日に、エクスプローラの 1 つである mempool.space が公開する API から取得した 973,728〜975,743 番のブロック 2,016 個を手元で読み、次の問いに順に答えます。

  • ブロックには何が入っていて、ハッシュ値はどう計算するのか。
  • ヘッダの時刻は、どこまでずれてよいのか。
  • 時刻で並ばないなら、ブロックの順番は何で決まるのか。
  • ブロックの高さと報酬は、どこに書かれているのか。
  • ブロックの大きさの上限は 1 MB なのか。
  • チェーンの末尾が分かれた時、どのブロックが残るのか。

Blockchain Basics では、ブロックを並べる理由と改ざんを防ぐ仕組みの全体を説明しています。本記事は、Bitcoin のブロックが持つ中身と、その値を読む時の注意に絞ります。


ヘッダの 80 バイト

ブロックは、80 バイトのヘッダと、その後に続くトランザクションの並びでできています。ヘッダは 6 つの項目を決まった順に並べたもので、973,962 番のヘッダを分けると次のようになります。

80 バイトの帯を項目ごとに区切った図。0〜4 バイト目がバージョン、4〜36 が直前ブロックのハッシュ値、36〜68 が merkle root、68〜72 が時刻、72〜76 が bits、76〜80 が nonce。時刻の 4 バイト 67bbe56a を小さい桁から読むと 1793440615(2026-10-31 09:56:55 UTC)。下に 80 バイトに SHA-256 を 2 回掛けた結果 254451a2…0000 と、表示する順に逆に並べた 0000…2514425 を並べている

973,962 番のブロックヘッダとハッシュ値

直前ブロックのハッシュ値が、ブロック同士をつなぐ項目です。merkle root は、ブロックに入れたトランザクション全体を 32 バイトにまとめた値で、どのトランザクションを入れたかをヘッダに結び付けます。木の仕組みは Merkle Tree、Bitcoin での求め方は Bitcoin Merkle Tree で説明しています。

bits と nonce は Proof of Work で使う項目です。Proof of Work では、条件を満たすハッシュ値を計算で探し当てた参加者がブロックを作れます。この参加者をマイナーと呼びます。bits はハッシュ値が満たすべき条件(ターゲット)を縮めて書いた値で、nonce はマイナーが条件を満たすまで変えていく 32 ビットの数です。


ハッシュ値を 80 バイトから計算する

ブロックのハッシュ値は、ヘッダの 80 バイトに SHA-256 を 2 回掛けた値です。トランザクションの中身は、merkle root を通してだけハッシュ値に入ります。取得した 2,016 個のヘッダで、計算したハッシュ値が API の値と一致するかを見ました。

import hashlib


def parse_header(hx):
    raw = bytes.fromhex(hx)
    version, = struct.unpack("<i", raw[0:4])
    prev = raw[4:36][::-1].hex()       # 表示する順に逆に並べる
    merkle = raw[36:68][::-1].hex()
    t, bits, nonce = struct.unpack("<III", raw[68:80])
    block_hash = hashlib.sha256(hashlib.sha256(raw).digest()).digest()
    return dict(size=len(raw), version=version, prev=prev, merkle=merkle,
                time=t, bits=bits, nonce=nonce,
                hash_raw=block_hash.hex(), hash_shown=block_hash[::-1].hex())


ok = 0
for b in period:  # 973,728〜975,743 番
    h = parse_header(b["header"])
    ok += (h["hash_shown"] == b["id"] and h["prev"] == blocks[b["height"] - 1]["id"]
           and h["time"] == b["timestamp"] and h["size"] == 80)
print("headers checked:", ok, "/", len(period))
headers checked: 2016 / 2016

全てのヘッダが 80 バイトで、計算したハッシュ値は API の値と一致しました。ただし、一致させるには計算結果のバイトを逆に並べる必要があります。図の下にある 2 行のように、計算したままの値は 0 が末尾に並び、エクスプローラや Bitcoin Core の RPC が返す値は 0 が先頭に並びます。Bitcoin Core は、ブロックの列を複製して持ち、中身を検査するコンピュータ、つまりノードで動く主要な実装です。

逆に並べて表示するのは、Bitcoin Core がハッシュ値を小さい桁が先頭に来る 256 ビットの数として扱い、表示の時だけ大きい桁から書くためです。Proof of Work の条件は、この数がターゲット以下であることなので、表示した値の先頭に 0 が並びます。直前ブロックのハッシュ値と merkle root も、ヘッダの中では計算したままの順で入っています。自分でヘッダを組み立てたり、バイト列を比べたりする時は、どちらの順の値を持っているかを先に決めておく必要があります。


ヘッダに書かれていない値

ヘッダには、そのブロック自身のハッシュ値も、何番目のブロックかを表す高さも入っていません。ハッシュ値はヘッダから計算する値で、高さは、最初のブロックである genesis ブロックまで直前ブロックのハッシュ値を辿って数える値です。API や RPC が返す height や id は、ノードが計算して付けた値です。

トランザクションの数もヘッダに入っていません。ヘッダの後に、個数を表す可変長の整数と、トランザクションの本体が続きます。取得した期間のトランザクションは 1 ブロックあたり平均 3,973 個、最も多いブロックで 11,360 個でした。

ヘッダは本体と切り離して扱えます。975,743 番までのヘッダを全て集めても 80 バイト × 975,744 個で約 78 MB です。ヘッダの列だけでも、ブロックのつながりと Proof of Work は検証できます。

ただし、署名の正しさや同じコインの二重使用を検証するには、トランザクションの本体が必要です。ヘッダだけでトランザクションが入ったことを示す方法は、Bitcoin Merkle Tree の SPV(Simplified Payment Verification)の節で扱っています。


バージョンが 1,164 通りある

ヘッダは、最初の 4 バイトがバージョンです。名前からは、ブロックの形式が変わった時だけ変わる値に見えます。ところが、2,016 個のブロックが持つバージョンは 1,164 通りありました。

バージョンの 32 ビットを左から 31 番目〜0 番目の順に並べ、2,016 個のブロックでビットが 1 だった割合を色の濃さで示した図。29 番目は 100%、13〜28 番目は 20〜45%、それ以外は 0%

バージョンの 32 ビットごとに、1 だったブロックの割合

変わっていたのは 13〜28 番目のビットだけで、29 番目は全てのブロックで 1 でした。Bitcoin で規則を変える時は、BIP(Bitcoin Improvement Proposal)という提案書を出し、番号で呼びます。29 番目が 1 なのは、BIP9 の手順で新しい規則への賛否を表す時の形です。13〜28 番目は、BIP320 がマイナーの自由に使える範囲として空けたビットで、マイナーは nonce を使い切った時にここを変えます。

nonce だけでは足りないのは、必要な計算の回数が桁違いに多いからです。

難易度は、最初のブロックと比べて今のターゲットが何倍厳しいかを表す数で、ターゲットが小さいほど大きくなります。973,962 番を作った頃の難易度は約 1.48 × 1014 で、条件を満たすヘッダを 1 つ見つけるまでに、平均で難易度 × 232 ≈ 6.4 × 1023 回のハッシュ計算が必要です。nonce が取れる値は 232 ≈ 4.3 × 109 通りなので、1 ブロックを見つけるまでに nonce の範囲を約 1.5 × 1014 回使い切ります。

そのため、マイナーは nonce を使い切るたびに、バージョンのビット、時刻、コインベーストランザクションの中身のどれかを変えて、ヘッダを作り直します。コインベーストランザクションは、ブロックの最初に置く報酬のトランザクションです。


時刻が受け入れられる範囲

ブロックの時刻は、ブロックを作ったマイナーが書き込みます。どのノードも同じ時計を持っていないため、ノードは時刻に厳しい条件を付けられません。Bitcoin Core がブロックを受け入れる処理で時刻に課す条件は、次の 2 つだけです。

  • 下限: 直前 11 個のブロックが持つ時刻の中央値より後であること。
  • 上限: 受け取ったノードの時計より 2 時間を超えて先ではないこと。

下限の中央値は Median Time Past(MTP)と呼ばれます。11 個のうち 1 個が極端な時刻を書いても、中央値はほとんど動きません。上限の 2 時間は、Bitcoin Core の MAX_FUTURE_BLOCK_TIME という定数です。時計がずれたノードが正しいブロックを拒まないよう、どちらも緩く取ってあります。この緩さが時刻の扱いにどう響くかは、Proof of History でも取り上げています。


実際に書かれた時刻

API は各ブロックの MTP を mediantime として返します。自分で直前 11 個の中央値を計算して、この値と一致するかを見てから、時刻が下限からどれだけ離れているかを数えました。

import statistics


def mtp(height):
    return statistics.median(blocks[height - i]["timestamp"] for i in range(11))


checked = [b for b in period if b["height"] - 11 >= 973727]
same = sum(mtp(b["height"] - 1) == blocks[b["height"] - 1]["mediantime"] for b in checked)
print("our MTP == API mediantime:", same, "/", len(checked))
margin = [(b["height"], b["timestamp"] - blocks[b["height"] - 1]["mediantime"]) for b in period]
print("time - MTP of parent: min", min(margin, key=lambda d: d[1]),
      "median", statistics.median(m for _, m in margin))
our MTP == API mediantime: 2006 / 2006
time - MTP of parent: min (974479, 899) median 3649.5

下限に最も近いブロックでも、MTP より 899 秒後の時刻でした。前のブロックより古い 58 個も、MTP より 1,275 秒以上後で、下限には遠く届きません。

上限は、ブロックがノードに届いた時刻と比べます。mempool.space の API は、そのノードがブロックを最初に受け取った時刻を firstSeen として返します。記録がある 1,065 個で、ヘッダの時刻から firstSeen を引いた値を並べたのが次の図です。

横軸は mempool.space が受け取った時刻との差(分)。上の段は下限(直前 11 個の時刻の中央値)で、−183〜−15 分に散らばる。下の段はヘッダの時刻で、−1.4〜+8.7 分の狭い範囲に集まる。+120 分に上限の赤い破線があり、最も遅い下限の −15 分から上限までは、全てのブロックで許される範囲として薄い緑で塗っている

許される範囲と、実際に書かれた時刻(受け取った時刻の記録がある 1,065 個)

ヘッダの時刻は、受け取った時刻の 1.4 分前から 8.7 分後に収まっていました。許される範囲が 2 時間以上あるのに対して、使われているのは 10 分ほどです。一方で、198 個(18.6%)は受け取った時刻より先の時刻を持っていました。マイナーがブロックを見つけてから届くまでには時間が掛かるので、ヘッダの時刻が受け取った時刻より先なら、そのマイナーは時計を進めて書いたことになります。


時刻が逆転する理由

受け取った時刻と並べると、冒頭の 973,961 番と 973,962 番で逆転が起きた理由が見えます。次の動画は、4 個のブロックが届いた時刻を上の線に、ヘッダの時刻を下の線に打ち、同じブロックを線で結んだものです。

上の線が mempool.space の受け取った時刻、下の線がヘッダの時刻。973,960 番が届き、ほぼ真下の時刻と結ばれる。973,961 番は 09:56 に届くが、ヘッダの時刻は 402 秒先の 10:03 で、線が右へ大きく傾く。32 秒後に届いた 973,962 番は、真下の 09:56 と結ばれ、2 本の線が交差して赤くなる。最後に 973,963 番が届く。実測の時刻を 80 倍速で再生し、最後の状態で 3 秒止まる

ブロックを受け取った時刻とヘッダの時刻(973,960〜973,963 番、実測の時刻を 80 倍速で再生)

973,962 番の時刻は、届く 2 秒前で、ほぼ正確でした。ずれていたのは 973,961 番の方で、届いた時刻より 402 秒先の時刻を書いていました。973,962 番は 973,961 番の 32 秒後に届いているので、正しい時刻を書けば前のブロックより古くなります。

58 個の逆転のうち、両方のブロックに firstSeen がある組は 33 組です。この 33 組を同じ形で並べると、全ての組で同じことが起きていました。

縦軸はヘッダの時刻から受け取った時刻を引いた値(秒)。左の赤い点が前のブロック、右の青い点が時刻が前より古いブロックで、33 組を線で結ぶ。左の点は全て 0 より上の 8〜473 秒、右の点は −75〜+80 秒に集まる

時刻が逆転した 33 組の、受け取った時刻との差

前のブロックは全て、受け取った時刻より先の時刻(8〜473 秒)を書いていました。後のブロックは受け取った時刻の前後 80 秒に収まっています。つまり、時刻が戻ったブロックの多くは、時計が遅れていたのではなく、未来寄りの時刻を書いた直前ブロックに追い越されただけです。手元のデータで言えるのは、記録のある 33 組についてで、残りの 25 組は受け取った時刻が分からないため判断できません。


時刻が難易度に効く

時刻の緩さは、表示の順番だけの問題ではありません。Bitcoin は 2,016 ブロックごとに、その期間の最初と最後のブロックが持つ時刻から掛かった時間を求め、難易度を調整します。調整の仕組みと公開データでの実例は、Proof of Work で説明しています。

時刻をずらせれば、掛かった時間を長く見せて難易度を下げられます。計算力の過半を持つマイナーが期間の境目で時刻を操作して難易度を下げ続ける手は、timewarp attack と呼ばれます。

BIP54 は、Bitcoin で最悪の場合 38 日で難易度を最小まで下げられると見積もり、各期間で最初に来るブロックの時刻が、直前ブロックより 2 時間を超えて戻らないようにする規則を提案しています。テストネットの testnet4 には、戻せる幅を 10 分にした同じ形の規則が最初から入っています。


順番を決めるもの

Bitcoin には履歴を管理する中央のサーバーが無く、トランザクションが届く順番は参加者ごとに違います。同じコインを別々の相手に送る 2 つのトランザクションがあれば、届いた順では、どちらを有効にするかが参加者ごとに食い違います。ブロックの列を全員で共有し、列に並んだ順番でトランザクションの採否を決めるのが、ブロックを並べる理由です。コインの表し方は UTXO で説明しています。

時刻で並ばないなら、ブロックの順番を決めるのは直前ブロックのハッシュ値です。各ヘッダが直前ブロックのハッシュ値を持つので、ヘッダを後ろから辿ると 1 本の列になります。先ほどのコードは、2,016 個の全てで直前ブロックのハッシュ値が 1 つ前にあるブロックの id と一致することも見ていました。

高さは、この列の先頭からの位置です。ブロックを並べる時は、時刻ではなく高さで並べます。Bitcoin の論文が示すとおり、ブロックに入ったことは、そのブロックより前にトランザクションがあった証拠になります。一方、ヘッダの時刻は、いつ入ったかの正確な記録にはなりません。

直前ブロックのハッシュ値を変えると自分のハッシュ値も変わるので、途中のブロックを書き換えると後ろのブロックを全て作り直すことになります。作り直したブロックのハッシュ値は Proof of Work の条件を満たさなくなるので、1 個ごとに nonce を探し直す必要があります。その間も他のマイナーは元の列を伸ばすので、書き換えた列が採用されるには、計算量の合計で元の列を上回らなければなりません。ハッシュ値の性質は Hash Function で説明しています。


時刻の範囲で区切る時は MTP を使う

それでも「ある時刻より後のブロック」を扱いたい場面はあります。その時は、ヘッダの時刻ではなく MTP を使います。

取得した期間の mediantime は、高さの順に 1 度も減っていませんでした。各ブロックの時刻は直前の MTP より後でなければならないので、MTP は減らない値になります。新しいブロックが加わると、直前 11 個の窓から最も古い 1 個が抜け、MTP より大きい時刻が 1 個入ります。中央値より大きい値が入るので、中央値は下がりません。

Bitcoin 自身も、トランザクションを指定の時刻までブロックに入れられなくする time lock の判定に、BIP113 から MTP を使っています。ヘッダの時刻で判定すると、マイナーが時刻を進めて書き、まだ入れられないはずのトランザクションの手数料を早く受け取れるためです。MTP は直前 6 個分ほど遅れるので、取得した期間ではヘッダの時刻より中央値で約 1 時間(3,649.5 秒)前の値でした。


高さと報酬を書く場所

ブロックに入る最初のトランザクションは、コインベーストランザクション(coinbase transaction)と呼ばれる特別なものです。入力に使うコインを持たず、ブロックを作ったマイナーに、新しく発行する Bitcoin とブロックに入れたトランザクションの手数料を渡します。高さと報酬は、このトランザクションに書かれます。

BIP34 により、コインベーストランザクションの入力にある scriptSig という欄は、高さを最初に置く決まりです。973,962 番では、scriptSig の先頭 4 バイトが 03 8a dc 0e で、03 が続く 3 バイトの長さ、8a dc 0e を小さい桁から読むと 973,962 になります。

def bip34(cb):
    raw = bytes.fromhex(cb)
    n = raw[0]
    return int.from_bytes(raw[1:1 + n], "little")


print("BIP34 height == height:",
      sum(bip34(b["coinbaseRaw"]) == b["height"] for b in period), "/", len(period))
cb = blocks[973962]["coinbaseRaw"]
print("973962 coinbase scriptSig:", cb[:8], "->", bip34(cb), "ascii:",
      "".join(chr(c) if 32 <= c < 127 else "." for c in bytes.fromhex(cb)[:28]))
BIP34 height == height: 2016 / 2016
973962 coinbase scriptSig: 038adc0e -> 973962 ascii: .....Mined by AntPool ..)...

2,016 個の全てで、scriptSig の先頭から読んだ高さはブロックの高さと一致しました。高さの後ろは自由に書ける欄で、973,962 番には Mined by AntPool という文字列が入っています。マイナーが nonce を使い切った時にヘッダを作り直す材料も、この欄です。ここを変えるとコインベーストランザクションのハッシュ値が変わり、merkle root が変わるので、ヘッダ全体が新しくなります。


報酬の出力と witness の記録

トランザクションは、使うコインを指す入力と、金額と受け取り手を書く出力からできています。

973,962 番のコインベーストランザクションには、出力が 7 個ありました。金額のある出力は 2 個で、合計 3.1269089 BTC です。このうち 3.125 BTC が新しく発行された分で、残りがトランザクションの手数料から受け取った分です。受け取った報酬は、100 ブロック後まで使えません。チェーンの末尾が入れ替わると、そのブロックの報酬ごと消えるからです。

残りの 5 個は、金額を持たずデータだけを書く OP_RETURN という形の出力で、そのうち 1 個は 6a24aa21a9ed で始まります。これは SegWit(Segregated Witness)の witness commitment です。

SegWit は、トランザクションの署名などを witness という領域に分け、トランザクションのハッシュ値である txid の計算から外しました。merkle root は txid から求めるので、witness は merkle root にも入りません。代わりに、witness を含めて別の木を作り、そのルートから求めたハッシュ値をこの出力に書いて、ヘッダに結び付けています。txid から witness を外した理由は Bitcoin Merkle Tree で説明しています。


高さが無かった頃に起きたこと

BIP34 の前は、コインベーストランザクションに高さを書く決まりがありませんでした。そのため、同じマイナーが同じ宛先に同じ金額を送るコインベーストランザクションを作ると、中身が同じになり、txid も同じになります。実際に 2010 年、2 組のブロックでこれが起きています。

高さコインベーストランザクションの txid
91,722e3bf3d07d4b0375638d5f1db5255fe07ba2c4cb067cd81b84ee974b6585fb468
91,812d5d27987d2a3dfc724e359870c6644b40e497bdc0589a033220fe15429d88599
91,842d5d27987d2a3dfc724e359870c6644b40e497bdc0589a033220fe15429d88599
91,880e3bf3d07d4b0375638d5f1db5255fe07ba2c4cb067cd81b84ee974b6585fb468

ノードは未使用の出力を txid で管理するため、後のブロックが作った出力が、前のブロックが作った出力を上書きしました。Bitcoin Core は今も、91,722 番と 91,812 番の報酬を使えない出力として扱っています。BIP30 は、使い切っていない txid と同じ txid のトランザクションを含むブロックを無効にし、この 2 組だけを例外にしました。高さを書く BIP34 は、コインベーストランザクションの中身をブロックごとに必ず変えるための規則です。

ただし、BIP34 より前のコインベーストランザクションには、先頭が偶然、未来の高さを書いたように見えるものがあります。Bitcoin Core のコメント によると、これから最初にぶつかり得るのは 1,983,702 番で、そこから BIP30 の検査をまた行う必要があります。BIP54 は、コインベーストランザクションの nLockTime という欄に高さから 1 を引いた値を書かせて、この重複を無くす案も含んでいます。


大きさの上限

ブロックの大きさの上限は、1 MB と紹介されることがあります。取得した 2,016 個では、1,972 個が 1,000,000 バイトを超え、大きさの中央値は 1,639,247 バイト、最大は 3,972,779 バイトでした。

横軸はブロックの大きさ(100 万バイト)、縦軸は weight(100 万)。大半の点は weight 4.0 の赤い破線に張り付き、大きさは 1.1〜4.0 の間に横に広がる。1,000,000 バイトより小さいブロックは、大きさに比例して weight が増える直線に並ぶ

ブロックの大きさと weight(2,016 個)

今の上限は大きさではなく、SegWit で入った weight という量で決まります。witness 以外のバイトを 4 倍、witness のバイトを 1 倍に数えた合計で、上限は 4,000,000 です。図のように、大半のブロックは weight の上限に張り付いています。weight が 3,990,000 を超えたブロックは 1,929 個でした。

同じ weight でも、witness が多いほどバイト数は大きくなります。署名や、witness に画像などのデータを載せたトランザクションが多いブロックは、4 MB 近くまで大きくなります。逆に、トランザクションをコインベーストランザクションの 1 個しか持たないブロックも 5 個ありました。ノードの保存容量や帯域を見積もる時は、1 MB ではなく、この 1〜4 MB の幅で考えます。


上限に張り付いているということは、入りきらないトランザクションが待っているということです。マイナーは、各ノードがまだブロックに入っていないトランザクションを溜めておく置き場である mempool からトランザクションを選び、weight あたりの手数料が高いものから入れて、受け取る手数料を大きくします。混雑した時に手数料の低い送金がなかなかブロックに入らないのは、この選び方のためです。


チェーンの末尾が分かれた時

ほぼ同時に 2 人のマイナーがブロックを見つけると、同じ直前ブロックのハッシュ値を持つブロックが 2 個できます。直前ブロックのハッシュ値で順番が決まるので、この時チェーンの末尾は 2 本に分かれます。

3 つの段階を左から並べた図。1 では高さ H−1 のブロックの後ろに、高さ H の A と B が並び、A に送金 t が入っていて t の承認数は 1。2 では B の後ろに高さ H+1 の C が付き、B の列の方が計算量の合計が大きい。3 では B の列が選ばれて A が灰色になり、送金 t が承認数 0 で mempool に戻る

末尾が分かれてから、片方の列が選ばれるまで(模式図)

ブロックを受け取ったノードは、Proof of Work とトランザクションの中身を検査してから、列の末尾に足します。2 本とも規則を満たす時は、計算量の合計が最も大きい列を正しいチェーンとして選びます。

この計算量は実際に試した回数ではなく、各ブロックのターゲットから求める値で、難易度が同じなら長い列ほど大きくなります。片方の列に次のブロックが付いて計算量の合計が大きくなると、ノードはその列へ乗り換え、もう片方の列は捨てられます。多くの場合は次の 1 ブロックで決まりますが、両方の列にブロックが付き続ければ、分岐も続きます。

採用する列の切り替えは reorg(reorganization)と呼ばれます。捨てられたブロックにだけ入っていたトランザクションは、検査を通れば mempool に戻り、次のブロックを待ちます。新しい列で同じコインが既に使われていれば、戻れずに消えます。分岐が起きて片方が残る様子は、Proof of Work で 2 人のマイナーを動かして再現しています。


承認数

トランザクションを含むブロックを 1 つ目として、その後ろに積まれたブロックまで数えた数を承認数(confirmations)と呼びます。先端にあるブロックの高さから、トランザクションを含むブロックの高さを引き、1 を足した値です。

承認数が多いほど、そのブロックを外すために作り直すブロックが増え、前の節で見た計算量の合計で上回ることが難しくなります。そのため、承認数が増えるほど、そのブロックが捨てられる列に入っている見込みは小さくなります。改ざんのコストが積み上がる仕組みは Blockchain Basics でも説明しています。

ただし、承認数がいくつになっても、巻き戻りが起こり得ないことにはなりません。何個待てば十分かは Finality、1 件の送金がブロックに入るまでの流れは Bitcoin Transaction Lifecycle で扱っています。

末尾が入れ替わると、同じ高さに別のブロックが入ります。ブロックを保存する時は、高さだけでなくハッシュ値も一緒に持ち、直前ブロックのハッシュ値が自分の持つ値とつながるかを見る必要があります。


ブロックのデータを読む前に

ブロックを読むプログラムを書く時や、エクスプローラの値を自分のデータと突き合わせる時は、次の 5 点で判断します。

  1. 順番は高さと、直前ブロックのハッシュ値で決める。ヘッダの時刻で並べない。
  2. 時刻で区切る集計は、減らない MTP(mediantime)を使う。
  3. ハッシュ値を比べる時は、計算したままの順か、表示する順かを揃える。
  4. 同じ高さのブロックが入れ替わる前提で、ハッシュ値を保存して照合する。
  5. 大きさの見積もりは weight の 4,000,000 から考え、1 MB を前提にしない。

冒頭の −372 秒は、ブロックの時刻がマイナーの申告で、2 時間ほどの幅で許されていることから来ていました。973,961 番のように時刻を先に書くブロックは、取得した期間で 1,065 個中 198 個あります。時刻の逆転は珍しい事故ではなく、時刻で並べる処理を書けばいずれ出会う値です。

取得したデータと集計の全体は analyze.py、取得の手順は README.txt にあります。