Bitcoin

# secp256k1 のパラメータ
P = 2**256 - 2**32 - 977
N = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141  # 生成元Gの位数
G = (
    0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798,
    0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8,
)


def point_add(p1, p2):
    """楕円曲線上の点の加算（Noneは無限遠点）"""
    if p1 is None:
        return p2
    if p2 is None:
        return p1
    (x1, y1), (x2, y2) = p1, p2
    if x1 == x2 and (y1 + y2) % P == 0:
        return None
    if p1 == p2:
        lam = 3 * x1 * x1 * pow(2 * y1, -1, P) % P  # 接線の傾き
    else:
        lam = (y2 - y1) * pow(x2 - x1, -1, P) % P  # 直線の傾き
    x3 = (lam * lam - x1 - x2) % P
    return (x3, (lam * (x1 - x3) - y1) % P)


def scalar_mult(k, point=G):
    """double-and-add によるスカラー倍"""
    result = None
    while k:
        if k & 1:
            result = point_add(result, point)
        point = point_add(point, point)
        k >>= 1
    return result


# Mastering Bitcoin で使われている例の秘密鍵
k = 0x1E99423A4ED27608A15A2616A2B0E9E52CED330AC530EDCC32C8FFC6A526AEDD
K = scalar_mult(k)
print("x =", hex(K[0]))
print("y =", hex(K[1]))
print("曲線上にあるか:", (K[1] ** 2 - K[0] ** 3 - 7) % P == 0)

import hashlib

B58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"


def base58check(version: bytes, payload: bytes) -> str:
    data = version + payload
    checksum = hashlib.sha256(hashlib.sha256(data).digest()).digest()[:4]
    data += checksum
    n = int.from_bytes(data, "big")
    s = ""
    while n:
        n, r = divmod(n, 58)
        s = B58_ALPHABET[r] + s
    # 先頭の0x00バイトは '1' で表す
    pad = len(data) - len(data.lstrip(b"\x00"))
    return "1" * pad + s


def hash160(b: bytes) -> bytes:
    return hashlib.new("ripemd160", hashlib.sha256(b).digest()).digest()


def serialize_pubkey(K, compressed=True) -> bytes:
    x, y = K
    if compressed:
        return (b"\x02" if y % 2 == 0 else b"\x03") + x.to_bytes(32, "big")
    return b"\x04" + x.to_bytes(32, "big") + y.to_bytes(32, "big")


for compressed in [False, True]:
    pub = serialize_pubkey(K, compressed)
    addr = base58check(b"\x00", hash160(pub))
    print(f"{'圧縮' if compressed else '非圧縮'}公開鍵: {pub.hex()[:20]}...  アドレス: {addr}")

import hmac


def sign(privkey: int, z: int) -> tuple[int, int]:
    # デモ用：k' を秘密鍵とメッセージから決定論的に作る（RFC 6979の簡略版）
    k_nonce = int.from_bytes(hmac.new(privkey.to_bytes(32, "big"), z.to_bytes(32, "big"), "sha256").digest(), "big") % N
    r = scalar_mult(k_nonce)[0] % N
    s = pow(k_nonce, -1, N) * (z + r * privkey) % N
    return r, s


def verify(pubkey, z: int, sig: tuple[int, int]) -> bool:
    r, s = sig
    s_inv = pow(s, -1, N)
    Q = point_add(scalar_mult(z * s_inv % N), scalar_mult(r * s_inv % N, pubkey))
    return Q is not None and Q[0] % N == r


msg = b"Alice pays Bob 0.015 BTC"
z = int.from_bytes(hashlib.sha256(hashlib.sha256(msg).digest()).digest(), "big")
sig = sign(k, z)
print("署名 r =", hex(sig[0])[:20], "...")
print("正しいメッセージ:", verify(K, z, sig))

z_fake = int.from_bytes(hashlib.sha256(hashlib.sha256(b"Alice pays Bob 100 BTC").digest()).digest(), "big")
print("改ざんされたメッセージ:", verify(K, z_fake, sig))
print("別人の公開鍵:", verify(scalar_mult(12345), z, sig))

def run_script(script: list, z: int) -> bool:
    """P2PKHに必要な命令だけを実装した簡易Scriptインタプリタ"""
    stack = []
    for op in script:
        if op == "OP_DUP":
            stack.append(stack[-1])
        elif op == "OP_HASH160":
            stack.append(hash160(stack.pop()))
        elif op == "OP_EQUALVERIFY":
            if stack.pop() != stack.pop():
                return False
        elif op == "OP_CHECKSIG":
            pub, sig = stack.pop(), stack.pop()
            x = int.from_bytes(pub[1:33], "big")
            y = pow(x**3 + 7, (P + 1) // 4, P)  # 圧縮公開鍵からyを復元
            if y % 2 != pub[0] - 2:
                y = P - y
            stack.append(verify((x, y), z, sig))
        else:
            stack.append(op)  # データはそのままpush
    return bool(stack) and stack[-1] is True


bob_priv = 0xB0B
bob_pub = serialize_pubkey(scalar_mult(bob_priv))
locking = ["OP_DUP", "OP_HASH160", hash160(bob_pub), "OP_EQUALVERIFY", "OP_CHECKSIG"]

z = int.from_bytes(hashlib.sha256(b"spend Bob's UTXO").digest(), "big")
print("Bobが署名:", run_script([sign(bob_priv, z), bob_pub] + locking, z))

mallory_priv = 0xBAD
mallory_pub = serialize_pubkey(scalar_mult(mallory_priv))
print("Malloryが自分の鍵で署名:", run_script([sign(mallory_priv, z), mallory_pub] + locking, z))
print("MalloryがBobの公開鍵を騙る:", run_script([sign(mallory_priv, z), bob_pub] + locking, z))

import matplotlib.pyplot as plt
import japanize_matplotlib  # noqa: F401

HALVING_INTERVAL = 210_000
reward = 50 * 10**8  # satoshi
supply, era = 0, 0
heights, supplies = [0], [0]
while reward > 0:
    supply += reward * HALVING_INTERVAL
    era += 1
    heights.append(era * HALVING_INTERVAL)
    supplies.append(supply / 10**8 / 10**4)
    reward //= 2  # 半減（satoshi未満は切り捨て）

print(f"半減回数: {era}, 総発行量: {supply / 10**8:,.8f} BTC")

years = [2009 + h * 10 / 60 / 24 / 365 for h in heights]  # 1ブロック10分として換算
fig, ax = plt.subplots(figsize=(6, 3.5))
ax.plot(years, supplies)  # 各期間内は一定ペースで発行されるので線形補間
ax.set(xlabel="年（目安）", ylabel="累積発行量 [万BTC]", title="bitcoinの供給スケジュール", xlim=(2009, 2150))
plt.show()