Bitcoin & Crypto Node Tools

# Snap install (easiest — manages updates automatically)
sudo snap install bitcoin-core

# Verify CLI is accessible
bitcoin-core.cli --version
bitcoin-core.cli getblockchaininfo | jq '{chain, blocks, headers, synced:.verificationprogress}'

# For manual installs — set alias if using bitcoin-cli directly
alias btc="bitcoin-cli -rpcuser=user -rpcpassword=pass"

# ~/.bitcoin/bitcoin.conf
server=1
rpcuser=user
rpcpassword=<strong-random-password>
rpcallowip=127.0.0.1
txindex=1       # required for getransaction on any tx (not just wallet)
daemon=1        # run as background daemon
maxconnections=40

import json, subprocess, time, os
from datetime import datetime, timezone

BOX_WIDTH     = 100
POLL_INTERVAL = 10   # seconds between height checks

def run_cli(*args):
    # Runs bitcoin-core.cli and returns stdout string, or None on error
    try:
        r = subprocess.run(["bitcoin-core.cli", *args],
                            stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True)
        return r.stdout.decode().strip()
    except subprocess.CalledProcessError as e:
        print(f"[!] CLI error: {e.stderr.decode().strip()}")
        return None

def get_current_block_height():
    raw = run_cli("getblockcount")
    return int(raw) if raw else None

def get_block_data(height):
    block_hash = run_cli("getblockhash", str(height))
    if not block_hash: return None
    block_json = run_cli("getblock", block_hash, "1")
    return json.loads(block_json) if block_json else None

def display_block(block):
    ts   = datetime.fromtimestamp(block['time'], tz=timezone.utc).strftime('%Y-%m-%d %H:%M:%S UTC')
    rows = [
        ("Height",       block['height']),
        ("Hash",         block['hash']),
        ("Time",         ts),
        ("Transactions", block['nTx']),
        ("Size (bytes)",  block['size']),
        ("Weight",       block['weight']),
        ("Difficulty",   f"{block['difficulty']:,.0f}"),
        ("Merkle Root",  block['merkleroot']),
        ("Nonce",        block['nonce']),
        ("Version",      block['versionHex']),
    ]
    border = "+" + "─" * (BOX_WIDTH - 2) + "+"
    print(border)
    print(f"│{'NEW BLOCK DETECTED'.center(BOX_WIDTH-2)}│")
    print(border)
    for label, value in rows:
        line = f"  {label:<15}{value}"
        print(f"│{str(line):<{BOX_WIDTH-2}}│")
    print(border)

def main():
    print("[*] Bitcoin Block Monitor — polling every 10 seconds")
    last_height = None
    while True:
        height = get_current_block_height()
        if height and height != last_height:
            block = get_block_data(height)
            if block:
                display_block(block)
                # Append to log
                with open("bitcoin_block_log.txt", "a") as f:
                    f.write(json.dumps({"height": height, "hash": block['hash'],
                                          "time": block['time'], "ntx": block['nTx']}) + "\n")
                last_height = height
        time.sleep(POLL_INTERVAL)

if __name__ == "__main__":
    main()

#!/usr/bin/env bash
CLI="${BITCOIN_CLI:-/snap/bin/bitcoin-core.cli}"
RPC_USER="${BITCOIN_RPC_USER:-user}"
RPC_PASS="${BITCOIN_RPC_PASS:-pass}"
RPC_HOST="127.0.0.1"
RPC_PORT="8332"

# ── Method 1: By block height via CLI (recommended) ──────────────
GENESIS_HASH=$("$CLI" getblockhash 0)
"$CLI" getblock "$GENESIS_HASH" | jq '{hash, height, time, nTx, size, difficulty, merkleroot, nonce}'

# ── Method 2: Header only (lighter / faster) ──────────────────────
"$CLI" getblockheader "$GENESIS_HASH" | jq '{hash, height, time, difficulty, mediantime, chainwork}'

# ── Method 3: Raw block data (hex) ────────────────────────────────
"$CLI" getblock "$GENESIS_HASH" 0    # verbosity 0 = raw hex serialization

# ── Method 4: Full JSON decode (verbosity 2 — all tx data) ────────
"$CLI" getblock "$GENESIS_HASH" 2 | jq '.tx[0] | {txid, locktime, vout: .vout[0]}'

# ── Method 5: JSON-RPC over HTTP (curl) ───────────────────────────
curl -s --user "$RPC_USER:$RPC_PASS" \
  --data-binary '{"jsonrpc":"1.0","id":"genesis","method":"getblock","params":["'$GENESIS_HASH'",1]}' \
  -H 'content-type: text/plain;' \
  "http://$RPC_HOST:$RPC_PORT/" | jq '.result | {hash, height, time, nTx}'

# ── Method 6: REST API (no auth required — local only) ────────────
curl -s "http://127.0.0.1:8332/rest/block/$GENESIS_HASH.json" | jq '{hash, height, time, nTx}'

{
  "hash":       "000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f",
  "height":     0,
  "time":       1231006505,   ← 2009-01-03 18:15:05 UTC — Satoshi's timestamp
  "nTx":        1,            ← one coinbase transaction only
  "size":       285,
  "difficulty": 1,
  "merkleroot": "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b",
  "nonce":      2083236893    ← proof of work nonce
}

#!/bin/bash

# Boundary block heights — start and end of each halving epoch
BLOCK_HEIGHTS=(1 209999 210000 419999 420000 629999 630000 839999 840000 1049999)

RED='\033[0;31m'; GREEN='\033[0;32m'; WHITE='\033[1;37m'; NC='\033[0m'

for ((i=0; i<${#BLOCK_HEIGHTS[@]}-1; i+=2)); do
    PHASE_START=${BLOCK_HEIGHTS[$i]}
    PHASE_END=${BLOCK_HEIGHTS[$((i+1))]}
    echo -e "${RED}Phase $((i/2+1)): Blocks $PHASE_START — $PHASE_END${NC}"

    # ── Fetch start block ──────────────────────────────────────────
    START_HASH=$(bitcoin-core.cli getblockhash "$PHASE_START" 2>/dev/null)
    if [[ $? -eq 0 ]]; then
        START_DATA=$(bitcoin-core.cli getblock "$START_HASH" 2)
        # coinbase value = first output of first (coinbase) transaction
        VALUE=$(echo "$START_DATA" | jq -r '.tx[0].vout[0].value')
        TS=$(echo "$START_DATA"    | jq -r '.time')
        DATE=$(date -d @$TS '+%Y-%m-%d %H:%M:%S')
        echo -e "  Start — height $PHASE_START | coinbase: ${WHITE}${VALUE} BTC${NC} | $DATE"
    fi

    # ── Fetch end block ────────────────────────────────────────────
    END_HASH=$(bitcoin-core.cli getblockhash "$PHASE_END" 2>/dev/null)
    if [[ $? -eq 0 ]]; then
        END_DATA=$(bitcoin-core.cli getblock "$END_HASH" 2)
        VALUE=$(echo "$END_DATA" | jq -r '.tx[0].vout[0].value')
        TS=$(echo "$END_DATA"    | jq -r '.time')
        DATE=$(date -d @$TS '+%Y-%m-%d %H:%M:%S')
        echo -e "  End   — height $PHASE_END   | coinbase: ${WHITE}${VALUE} BTC${NC} | $DATE"
    fi
    sleep 1
done

# Phase 5 — post-4th-halving spot checks
echo -e "${RED}Phase 5: Spot checks 850000 – 880000${NC}"
for HEIGHT in 850000 860000 870000 880000; do
    HASH=$(bitcoin-core.cli getblockhash "$HEIGHT" 2>/dev/null) || { echo "  height $HEIGHT not yet mined"; continue; }
    DATA=$(bitcoin-core.cli getblock "$HASH" 2)
    VALUE=$(echo "$DATA" | jq -r '.tx[0].vout[0].value')
    TS=$(echo "$DATA"    | jq -r '.time')
    echo -e "  Height $HEIGHT | coinbase: ${WHITE}${VALUE} BTC${NC} | $(date -d @$TS '+%Y-%m-%d')"
    sleep 1
done

import requests, time, shutil, os

CURRENCIES    = ['BTC', 'ETH', 'LTC', 'DOGE']
UPDATE_SECS   = 10
FRAME_WIDTH   = 44

def fetch_price(currency):
    try:
        r = requests.get(f"https://api.coinbase.com/v2/prices/{currency}-USD/spot", timeout=5)
        r.raise_for_status()
        return float(r.json()['data']['amount'])
    except: return None

def format_change(cur, prev):
    if cur is None: return "\033[33mUnavailable\033[0m"
    if prev is None: return f"{cur:.2f}"
    diff = cur - prev
    color = "\033[32m" if diff >= 0 else "\033[31m"
    sign  = "+" if diff > 0 else ""
    return f"{color}{cur:.2f} ({sign}{diff:.2f})\033[0m"

def display(prev_prices):
    print("\033[H", end="")       # cursor to top — no scroll
    bar = "═" * FRAME_WIDTH
    print(bar)
    print("  CRYPTO PRICES (USD)".center(FRAME_WIDTH))
    print(bar)
    for c in CURRENCIES:
        price = fetch_price(c)
        print(f"  {c:5} {format_change(price, prev_prices.get(c))}")
        if price: prev_prices[c] = price
    print(bar)
    print("  [Q] Quit".center(FRAME_WIDTH))

def main():
    prev = {}
    try:
        while True:
            display(prev)
            time.sleep(UPDATE_SECS)
    except KeyboardInterrupt:
        print("\nExiting.")

if __name__ == "__main__":
    main()

════════════════════════════════════════════
         CRYPTO PRICES (USD)
════════════════════════════════════════════
  BTC   105432.18 (+218.40)
  ETH    3891.55 (-12.30)
  LTC      87.42 (+0.15)
  DOGE      0.3812 (+0.0021)
════════════════════════════════════════════
              [Q] Quit

import requests, json, sys

CURRENCIES  = ['BTC', 'ETH', 'LTC', 'DOGE']
API_TIMEOUT = 5

def fetch_price(currency):
    try:
        r = requests.get(f"https://api.coinbase.com/v2/prices/{currency}-USD/spot", timeout=API_TIMEOUT)
        r.raise_for_status()
        return float(r.json()['data']['amount'])
    except: return None

if __name__ == "__main__":
    prices = {c: fetch_price(c) for c in CURRENCIES}
    print(json.dumps(prices, indent=2))

import requests, time, sys, os, select

CURRENCIES      = ['BTC', 'ETH', 'LTC', 'DOGE']
API_TIMEOUT     = 5
UPDATE_INTERVAL = 10

def fetch_price(currency):
    url = f"https://api.coinbase.com/v2/prices/{currency}-USD/spot"
    try:
        r = requests.get(url, timeout=API_TIMEOUT)
        r.raise_for_status()
        return float(r.json()['data']['amount'])
    except requests.exceptions.RequestException as e:
        print(f"Error fetching {currency}: {e}", file=sys.stderr)
        return None

def format_change(current, previous):
    if current is None: return "\033[33mUnavailable\033[0m"
    if previous is None: return f"{current:.2f}"
    diff = current - previous
    if   diff > 0: return f"\033[32m{current:.2f} (+{diff:.2f})\033[0m"
    elif diff < 0: return f"\033[31m{current:.2f} ({diff:.2f})\033[0m"
    else:          return f"{current:.2f} (=)"

def display(prev_prices):
    os.system('clear')
    print("═" * 44)
    print(f"  {'Currency':<8}  {'Price (USD)'}")
    print("─" * 44)
    for c in CURRENCIES:
        price = fetch_price(c)
        print(f"  {c:<8}  {format_change(price, prev_prices.get(c))}")
        if price: prev_prices[c] = price
    print("═" * 44)

def main():
    prev_prices = {}
    try:
        while True:
            display(prev_prices)
            # Non-blocking stdin check — quit if input arrives
            if sys.stdin in select.select([sys.stdin], [], [], UPDATE_INTERVAL)[0]:
                break
    except KeyboardInterrupt: pass
    print("\nExiting.")

if __name__ == "__main__":
    main()