Rencana Bisnis Mining Farm 50 kW: Hitung CAPEX, OPEX & ROI

Menjalankan rig mining 50 kW adalah skenario batas antara "colokan" rumahan dan data center komersial. Di satu sisi, beban aktif 50 kW masih bisa masuk ke ruang komersial kecil atau properti pribadi dengan trafo sendiri (gardu distribusi). Di sisi lain, ini sudah mencakup sekitar 14 hingga 15 mesin ASIC modern, di mana masing-masing mengeluarkan panas hingga 3,5 kW, menyedot 15 hingga 16 ampere per fasa, dan membutuhkan sirkulasi udara 600 hingga 800 meter kubik per jam.

Panduan ini merangkum rincian praktis seputar perencanaan, pengadaan hardware, instalasi kelistrikan, sistem pendingin, dan otomatisasi untuk farm mining 50 kW. Tanpa basa-basi, teori abstrak, atau penjelasan akademis—hanya angka mentah, perangkat keras, kabel, profil air tanah, dan skrip monitoring siap tempur.

1. Parameter Awal dan Infrastruktur Kelistrikan

Fondasi dari bisnis mining apa pun adalah tarif per kWh dan keandalan gardu listrik. Untuk beban konstan 50 kW yang berjalan 24/7, rating proteksi utama Anda harus dihitung dengan margin keamanan arus 20% (sesuai standar NFPA/IEC untuk beban kontinu).

I_total = P / (√3 · U · cosφ) = 50000 / (√3 · 380 · 0.95) ≈ 79.8 A

Dengan memperhitungkan faktor pengaman 1.25, pemutus arus (MCB/MCCB) utama harus berukuran minimal 100A (3 fasa).

Spesifikasi Panel Hubung Utama (MDB 50 kW)

• Main Breaker: 3P 100A (Kurva C, kapasitas pemutusan minimal 10 kA, contohnya Schneider Electric Acti9 atau ABB S200).
• Distribusi Fasa: 3 fasa L1, L2, L3, dibagi secara rata masing-masing 5 unit per fasa (untuk total 15 unit) guna menghindari ketidakseimbangan fasa dan arus netral berlebih.
• Kabel dari Gardu ke MDB: Kabel tembaga NYY 4x25 mm² atau aluminium NYY 4x50 mm² jika ditanam di dalam trench (dengan asumsi susut tegangan tidak lebih dari 2% pada jarak 50 meter).
• Proteksi Sirkuit Cabang: Setiap ASIC menggunakan MCB terpisah 2P 20A (Kurva C) + kabel tembaga tahan api berisolasi ganda NYM/NYY 3x2.5 mm².
• Sistem Pembumian (Grounding): Grid grounding TN-S atau TN-C-S dengan resistansi maksimal 4 Ohm (dirangkai dari 3 batang tembaga/rod 2.5 meter yang ditancapkan membentuk segitiga dan dilas menggunakan plat strip tembaga/galvanis 40x4 mm).

2. Pemilihan Hardware dan CAPEX (Belanja Modal)

Untuk perhitungan ini, kita pakai standar industri emas—seri Bitmain Antminer S19k Pro / S21 atau MicroBT Whatsminer M50/M60. Agar pas dengan beban 50 kW, konfigurasi optimalnya adalah 14 unit Antminer S21 (200 TH/s) dengan konsumsi standar sekitar 3.500W per mesin.

• Total Hashrate: 14 · 200 TH/s = 2.800 TH/s = 2.8 PH/s
• Total Konsumsi Daya: 14 · 3.500W = 49 kW (masuk dalam batas limit 50 kW setelah dikurangi daya ventilasi).

Tabel Belanja Modal (CAPEX)

3. Pendingin dan Ventilasi: Perhitungan Termodinamika

Kesalahan terbesar pemula adalah memakai AC ruangan biasa. AC memang menyerap kelembapan dan menurunkan suhu lewat siklus freon, tetapi untuk beban panas 50 kW Anda butuh AC berkapasitas 150.000 BTU yang justru akan melahap tambahan daya listrik 15–18 kW lagi.

Mining rig didinginkan murni menggunakan ventilasi aliran udara silang (sistem tiup/tekan udara langsung).

Perhitungan Kebutuhan Volume Udara

Rumus laju aliran udara yang diperlukan:

Q = P_dissip / (ρ · c_p · ΔT)

Keterangan:

• P_dissip = 49.000 W (panas yang dibuang)
• ρ = 1.2 kg/m³ (massa jenis udara pada suhu 20°C)
• c_p = 1.005 J/(kg·K) (kapasitas panas spesifik udara)
• ΔT = 15°C (toleransi kenaikan suhu antara udara masuk dan udara keluar)

Q = 49000 / (1.2 · 1005 · 15) ≈ 2.708 m³/s = 9.750 m³/jam

Memperhitungkan hambatan dari filter udara kasar (G4), Anda wajib merancang kapasitas total kipas minimal 12.000 – 14.000 m³/jam.

Pemisahan Zona (Hot/Cold Aisle)

• Koridor Dingin (Cold Aisle): Udara luar ditarik masuk melewati dinding filter. Tekanan udara di zona ini sedikit lebih tinggi.
• Koridor Panas (Hot Aisle): Mesin ASIC dipasang menyatu pada sekat kedap udara (rak dengan diffuser). Kipas bawaan ASIC membuang udara panas langsung ke ruang tertutup khusus, tempat fan exhaust industri meniupnya keluar ke udara bebas.

4. OPEX dan Biaya Operasional (Perhitungan Bulanan)

Biaya operasional terdiri dari tiga elemen utama: tagihan listrik, sewa tempat, internet, dan pemeliharaan teknis.

Mari gunakan asumsi rata-rata tarif listrik komersial sebesar $0.07 per kWh.

Perhitungan Listrik per Bulan

• Konsumsi per Jam: 49 kW (miner) + 1.5 kW (ventilasi & jaringan) = 50.5 kW
• Konsumsi per Hari: 50.5 · 24 = 1.212 kWh
• Konsumsi per Bulan (30.5 hari): 1.212 · 30.5 = 36.966 kWh
• Biaya Listrik Bulanan: 36.966 · $0.07 = $2,587.62

Pengeluaran Tetap Bulanan (OPEX)

5. Perhitungan Pendapatan, Payback (ROI), dan Model Keuangan

Untuk menghitung proyeksi pendapatan, kita mengacu pada tingkat kesulitan (difficulty) jaringan Bitcoin dan block reward di tahun 2026. Asumsikan 1 TH/s menghasilkan sekitar $0.042 per hari (sebelum potong listrik, dengan kurs BTC ~$65.000).

Proyeksi Pendapatan (Revenue)

• Total Hashrate: 2.800 TH/s
• Pendapatan Harian: 2.800 · $0.042 = $117.60
• Pendapatan Bulanan (30.5 hari): $117.60 · 30.5 = $3,586.80

Laba Bersih (EBITDA / Net Profit)

• Net Profit/mo = Pendapatan ($3,586.80) - OPEX ($3,077.62) = $509.18 (angka akan jauh lebih tinggi saat profitabilitas per TH/s naik; jika harga BTC $90.000, keuntungan terkerek proporsional).

Catatan Penting Sensitivitas ROI terhadap Harga Pasar dan Tarif Listrik:
Jika harga listrik bisa ditekan ke $0.05 / kWh, OPEX listrik akan turun menjadi $1,848.30, dan laba bersih melesat jadi $1,248.50 per bulan. Ini memangkas masa balik modal (payback period) dari skenario buruk menjadi 35-40 bulan yang lebih realistis. Mining menggunakan tarif listrik komersial di atas $0.065–0.07/kWh tanpa momentum bull run atau efisiensi hardware mumpuni berada di zona risiko tinggi.

6. Otomasi & Kontrol: Skrip Python untuk Monitoring (CGMiner / CGMiner API)

Seorang engineer sejati nggak bakal repot ngecek web UI dari 14 perangkat secara manual satu-satu. Semua ASIC miner modern (Antminer, Whatsminer) sudah support protokol CGMiner API (berbasis JSON via TCP socket).

Berikut adalah skrip Python siap-tempur untuk monitoring pool farm-mu. Skrip ini bakal nge-poll semua 14 ASIC di jaringan lokal, narik data hashrate, temperatur chip, dan langsung kirim alert ke Telegram kalau ada performa yang drop atau overheat.

#!/usr/bin/env python3
"""
Monitoring farm ASIC miner via CGMiner API (Port 4028).
Fitur:
  * polling semua perangkat secara paralel;
  * Antminer (key "command") dan Whatsminer (key "cmd") — tipe diatur di MINERS;
  * alert: offline, penurunan hashrate, overheat, field temperatur tidak ditemukan;
  * deduplikasi: event yang sama tidak dikirim lebih sering dari REPEAT_MINUTES;
  * notifikasi pemulihan saat masalah sudah beres;
  * konfirmasi masalah selama CONFIRM_CYCLES polling berturut-turut (mencegah false positive);
  * state disimpan di file, sehingga berjalan lancar baik dalam loop maupun via cron (--once).
Konfigurasi via environment variable:
  TG_BOT_TOKEN, TG_CHAT_ID              — wajib
  TEMP_THRESHOLD (default 85)           — batas suhu chip, °C
  HASHRATE_WARN_TH (default 170)        — hashrate minimum, TH/s
  POLL_INTERVAL_SEC (default 60)        — interval polling dalam mode loop
  REPEAT_MINUTES (default 60)           — pengulangan alert yang sama
  CONFIRM_CYCLES (default 2)            — jumlah polling berturut-turut untuk konfirmasi masalah
Cara menjalankan:
  python3 asic_monitor.py               # infinite loop
  python3 asic_monitor.py --once        # single run (untuk cron / systemd timer)
PENTING: Port 4028 hanya boleh bisa diakses dari jaringan lokal.
Jangan pernah expose port ini ke publik/internet.
"""
import json
import logging
import os
import socket
import sys
import time
from concurrent.futures import ThreadPoolExecutor
import requests
# --------------------------------------------------------------------------
# Konfigurasi
# --------------------------------------------------------------------------
# (ip, tipe): "antminer" atau "whatsminer"
MINERS = [(f"192.168.1.{i}", "antminer") for i in range(101, 115)]  # .101 - .114
# Contoh farm campuran:
# MINERS[0] = ("192.168.1.101", "whatsminer")
API_PORT = 4028
SOCKET_TIMEOUT = 3.0
TG_BOT_TOKEN = os.environ.get("TG_BOT_TOKEN", "")
TG_CHAT_ID = os.environ.get("TG_CHAT_ID", "")
TEMP_THRESHOLD = float(os.environ.get("TEMP_THRESHOLD", "85"))
HASHRATE_WARN_TH = float(os.environ.get("HASHRATE_WARN_TH", "170"))
POLL_INTERVAL_SEC = int(os.environ.get("POLL_INTERVAL_SEC", "60"))
REPEAT_MINUTES = int(os.environ.get("REPEAT_MINUTES", "60"))
CONFIRM_CYCLES = int(os.environ.get("CONFIRM_CYCLES", "2"))
STATE_FILE = os.environ.get("STATE_FILE", "asic_monitor_state.json")
# Prefiks key temperatur chip pada respons `stats` Antminer.
# Sesuaikan dengan firmware-mu: jalankan `stats` dan cek key aslinya.
ANTMINER_TEMP_PREFIXES = ("temp2_", "temp_chip")
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s %(levelname)s %(message)s",
    datefmt="%Y-%m-%d %H:%M:%S",
)
log = logging.getLogger("asic_monitor")
# --------------------------------------------------------------------------
# Telegram
# --------------------------------------------------------------------------
def send_telegram(text: str) -> bool:
    """Mengirim pesan tanpa parse_mode (teks dinamis tidak merusak formatting).
    Return True hanya jika Telegram menerima pesannya."""
    if not TG_BOT_TOKEN or not TG_CHAT_ID:
        log.error("TG_BOT_TOKEN / TG_CHAT_ID belum diset, alert tidak dikirim: %s", text)
        return False
    url = f"https://api.telegram.org/bot{TG_BOT_TOKEN}/sendMessage"
    try:
        r = requests.post(url, json={"chat_id": TG_CHAT_ID, "text": text}, timeout=10)
        if not r.ok:
            log.error("Telegram mengembalikan %s: %s", r.status_code, r.text[:200])
        return r.ok
    except requests.RequestException as e:
        log.error("Gagal mengirim ke Telegram: %s", e)
        return False
# --------------------------------------------------------------------------
# Interaksi CGMiner API
# --------------------------------------------------------------------------
def query_miner(ip: str, kind: str, command: str) -> dict:
    """Mengirim perintah ke CGMiner API. Jika gagal, mengembalikan {"error": "..."}."""
    key = "cmd" if kind == "whatsminer" else "command"
    try:
        with socket.create_connection((ip, API_PORT), timeout=SOCKET_TIMEOUT) as s:
            s.settimeout(SOCKET_TIMEOUT)
            s.sendall(json.dumps({key: command}).encode("utf-8"))
            chunks = []
            while True:
                chunk = s.recv(4096)
                if not chunk:
                    break
                chunks.append(chunk)
        text = b"".join(chunks).decode("utf-8", errors="ignore").replace("\x00", "")
        # Beberapa firmware mengembalikan "}{" tanpa koma antar objek
        text = text.replace("}{", "},{")
        return json.loads(text)
    except Exception as e:  # network, timeout, invalid JSON
        return {"error": f"{type(e).__name__}: {e}"}
def to_float(value):
    """Angka atau string angka -> float, jika tidak maka None."""
    try:
        return float(value)
    except (TypeError, ValueError):
        return None
def get_hashrate_th(summary: dict, kind: str):
    """Hashrate dalam TH/s atau None jika field tidak ditemukan."""
    try:
        s = summary["SUMMARY"][0]
    except (KeyError, IndexError, TypeError):
        return None
    if kind == "whatsminer":
        # MH/s -> TH/s. Rata-rata 5 menit jika ada, jika tidak pakai rata-rata keseluruhan.
        for key in ("MHS 5m", "MHS av"):
            v = to_float(s.get(key))
            if v is not None:
                return v / 1_000_000.0
        return None
    # Antminer: GH/s -> TH/s. Hindari "GHS 5s" (terlalu fluktuatif).
    for key in ("rate_30m", "GHS av"):
        v = to_float(s.get(key))
        if v is not None:
            return v / 1000.0
    return None
def get_max_chip_temp(ip: str, kind: str, summary: dict):
    """Temperatur chip maksimum atau None jika field tidak ditemukan."""
    if kind == "whatsminer":
        try:
            s = summary["SUMMARY"][0]
        except (KeyError, IndexError, TypeError):
            return None
        temps = [to_float(s.get(k)) for k in ("Chip Temp Max", "Temperature")]
        temps = [t for t in temps if t]
        return max(temps) if temps else None
    stats = query_miner(ip, kind, "stats")
    try:
        info = stats["STATS"][1]
    except (KeyError, IndexError, TypeError):
        return None
    temps = []
    for k, v in info.items():
        if k.startswith(ANTMINER_TEMP_PREFIXES):
            t = to_float(v)
            if t:  # 0 = board tidak mengirim nilai
                temps.append(t)
    return max(temps) if temps else None
# --------------------------------------------------------------------------
# Cek Perangkat Tunggal
# --------------------------------------------------------------------------
def check_miner(ip: str, kind: str) -> dict:
    """Mengembalikan {issue_key: alert_text} untuk masalah yang aktif."""
    issues = {}
    summary = query_miner(ip, kind, "summary")
    if "error" in summary:
        # Offline: pengecekan berikutnya tidak ada artinya
        return {"offline": f"⚠️ {ip}: API tidak merespons ({summary['error']})"}
    th = get_hashrate_th(summary, kind)
    if th is None:
        issues["parse"] = f"❌ {ip}: gagal mengambil hashrate dari summary (cek firmware/tipe)"
    elif th < HASHRATE_WARN_TH:
        issues["hashrate"] = f"📉 {ip}: hashrate {th:.1f} TH/s (ambang batas {HASHRATE_WARN_TH:.0f})"
    temp = get_max_chip_temp(ip, kind, summary)
    if temp is None:
        issues["temp_keys"] = f"❓ {ip}: field temperatur tidak ditemukan, cek key di stats"
    elif temp > TEMP_THRESHOLD:
        issues["temp"] = f"🔥 {ip}: overheat, chip pada {temp:.0f}°C (ambang batas {TEMP_THRESHOLD:.0f})"
    return issues
# --------------------------------------------------------------------------
# State & Deduplikasi
# --------------------------------------------------------------------------
def load_state() -> dict:
    try:
        with open(STATE_FILE, encoding="utf-8") as f:
            return json.load(f)
    except (OSError, ValueError):
        return {"sent": {}, "streak": {}}
def save_state(state: dict) -> None:
    try:
        tmp = STATE_FILE + ".tmp"
        with open(tmp, "w", encoding="utf-8") as f:
            json.dump(state, f)
        os.replace(tmp, STATE_FILE)
    except OSError as e:
        log.error("Gagal menyimpan state: %s", e)
def run_cycle(state: dict) -> None:
    sent, streak = state["sent"], state["streak"]
    now = time.time()
    with ThreadPoolExecutor(max_workers=len(MINERS)) as pool:
        results = list(pool.map(lambda m: (m[0], check_miner(*m)), MINERS))
    for ip, issues in results:
        # 1) masalah aktif
        for key, text in issues.items():
            sid = f"{ip}|{key}"
            streak[sid] = streak.get(sid, 0) + 1
            if streak[sid] < CONFIRM_CYCLES:
                continue
            last = sent.get(sid)
            if last is None or now - last >= REPEAT_MINUTES * 60:
                if send_telegram(text):
                    sent[sid] = now
        # 2) masalah yang sudah beres
        prefix = f"{ip}|"
        for sid in [s for s in list(streak) if s.startswith(prefix)]:
            key = sid[len(prefix):]
            if key in issues:
                continue
            streak.pop(sid, None)
            if sid in sent:  # notifikasi pemulihan hanya jika sebelumnya dikirim alert
                if send_telegram(f"✅ {ip}: masalah '{key}' telah teratasi"):
                    sent.pop(sid, None)
    ok = sum(1 for _, i in results if not i)
    log.info("Polling selesai: %d/%d aman", ok, len(results))
    save_state(state)
# --------------------------------------------------------------------------
def main() -> None:
    state = load_state()
    state.setdefault("sent", {})
    state.setdefault("streak", {})
    if "--once" in sys.argv:
        run_cycle(state)
        return
    log.info("Memulai monitoring: %d perangkat, interval %d dtk", len(MINERS), POLL_INTERVAL_SEC)
    while True:
        try:
            run_cycle(state)
        except Exception:
            log.exception("Uncaught exception dalam loop polling")
        time.sleep(POLL_INTERVAL_SEC)
if __name__ == "__main__":
    main()

7. Checklist Pra-Peluncuran (Engineering Sign-Off)

• 1. Stress Test Beban Listrik: Nyalakan heat gun/heater 50 kW selama 4 jam sebelum memasang miner. Cek suhu koneksi pada main breaker dan busbar menggunakan termometer infrared. Suhu kontak tidak boleh melebihi 65°C.
• 2. Pengukuran Grounding: Panggil lab kelistrikan untuk mengukur impedansi loop fasa-netral dan resistansi dispersi sistem grounding (harus < 4 Ohm).
• 3. Pengecekan Aliran Udara (Airflow): Pastikan kerapatan filter G4 tidak menciptakan kevakuman di dalam ruangan (pintu ke cold aisle harus bisa dibuka dengan mudah tanpa hambatan tekanan saat exhaust fan menyala).
• 4. Konfigurasi Watchdog: Aktifkan fitur bawaan Hardware Auto-Reboot di firmware miner (LUXOS, VNISH, atau Stock) sebagai pengaman jika pool disconnect atau kehilangan IP.

Cara Jalankan:

export TG_BOT_TOKEN="..." TG_CHAT_ID="..."
python3 asic_monitor.py

8. Perizinan, Perjanjian PPA, dan Akuntansi Fiskal Internasional

Menjalankan rig 50 kW di yurisdiksi mana pun memerlukan status resmi sebagai konsumen komersial. Mining "gelap" yang dicolokkan ke stopkontak rumah tangga biasa pasti akan berujung pada surat teguran dari PLN/utilitas setempat, denda berat karena melanggar batas daya, dan penggunaan jaringan secara ilegal.

Skema Perizinan dan Struktur Hukum

• Pendaftaran Badan Usaha Operasional (LLC / PT / Inc.): Fasilitas ini didaftarkan di bawah badan hukum perseroan terbatas standar. Ini wajib agar kita bisa legal meneken kontrak sewa tempat komersial dan perjanjian interkoneksi jaringan listrik.
• Perjanjian PPA (Power Purchase Agreement): Dokumen kunci fasilitas ini adalah kontrak komersial suplai daya listrik (PPA) dengan penyedia utilitas atau pemilik gardu induk (GI). Poin-poin yang dikunci dalam kontrak meliputi:
  • Kapasitas aktif teralokasi: 50 kW di bawah kategori keandalan Kelas III (dengan beban kontinu 24/7 yang diizinkan).
  • Titik batas kepemilikan (Point of Common Coupling): 0.4 kV di sisi terminal tegangan rendah trafo.
  • Skema tarif: Biaya tetap per kWh (target < $0.065–0.07).
• Impor Perangkat (Kode HS 8471): Pengadaan ASIC miner dilakukan melalui kontrak B2B langsung. Kode Harmonized System (HS Code) internasional untuk perangkat ini adalah 8471 50 000 0 (unit pemrosesan data). Saat bea cukai bersih (jalur hijau/resmi), PPN impor (VAT/GST) dan bea masuk dilunasi. Dokumen Pemberitahuan Impor Barang (PIB) dan invoice komersial disimpan untuk melegitimasi asal-usul aset modal di neraca perusahaan.
• Pencatatan Fiskal dan Pencairan Dana (Off-ramping): Pendapatan mining dihasilkan dalam bentuk BTC langsung dari pool. Untuk menutupi OPEX bulanan (listrik, sewa), digunakan akun institusional (Corporate Account) di bursa kripto atau OTC desk yang sudah melewati verifikasi KYB (Know Your Business). Dana fiat hasil pencairan ditransfer ke rekening bank perusahaan secara wire transfer untuk membayar tagihan listrik secara rutin.

9. Logistik dan QC Perangkat

Total berat 14 unit Antminer S21 dalam kemasan pabrik berkisar antara 230–250 kg.

Protokol Quality Control (QC Saat Barang Diterima)

• 1. Pemeriksaan Visual Kemasan: Cek segel indikator tamper-evident dan pastikan kardus tidak ada yang rusak.
• 2. Shake Test (Pemeriksaan Heatsink): Getaran ekstrem saat pengiriman internasional bisa melonggarkan baut pengencang atau melepaskan heatsink chip individual (terutama pada unit bekas). Goyangkan perangkat secara perlahan—tidak boleh ada suara komponen longgar di dalamnya.
• 3. Uji Resistansi (Cold Test): Sebelum mencolokkan daya 220V, gunakan multimeter untuk memastikan tidak ada korsleting pada jalur daya hashboard (resistansi jalur VDD harus sesuai dengan spesifikasi pabrik, sekitar puluhan Ohm).
• 4. Testbench (15 Menit): Nyalakan bergantian di sirkuit terisolasi. Pastikan hashrate target tercapai (200 TH/s), ketiga hashboard terbaca normal (3/3 Boards detected), dan tingkat error hardware rendah (HW Errors < 0.5%).

10. Keamanan dan Isolasi Jaringan

Rig penambangan 50 kW adalah target empuk, baik untuk pencurian fisik maupun serangan siber (pembajakan trafik stratum, injeksi malware).

Skema Topologi Jaringan:
[ Internet (WAN) ]
          &│
     [ Cadangan 4G/LTE ]
           &│
   ┌───────┴────────┐
   │ Router / WAF │ (MikroTik / OPNsense)
   │ Firewall │ ── WireGuard VPN (Hanya Akses Jarak Jauh)
   └───────┬────────┘
           │ (VLAN Terisolasi 10.0.10.0/24)
  ┌────────┼─────────────────┬─────────────────┐
  │        │                 │                 │
[ASIC 1] [ASIC 2] ...    [ASIC 14]     [Script Node]
10.0.10.101 10.0.10.102  10.0.10.114    10.0.10.250 (Python Watchdog)

Parameter Konfigurasi Jaringan

• Isolasi Total dari WAN: ASIC berada dalam segmen VLAN tertutup tanpa IP publik eksternal.
• Port 4028 Tertutup (CGMiner API): Akses ke port penarikan metrik hanya diizinkan untuk IP server monitoring internal.
• Enkripsi Stratum/TLS: Mengarahkan trafik ke pool menggunakan Stratum V2 atau Stratum over TLS untuk mencegah serangan Man-in-the-Middle (MitM) berupa pengalihan alamat dompet di level ISP.

11. Ringkasan Engineer (Checklist Deployment)

• 1. Kelistrikan: Periksa penampang kabel VVGng-LS 3x2.5 mm² untuk setiap soket C19, kencangkan semua terminal di Main Distribution Panel (MDP) menggunakan kunci momen (torque wrench) setelah 48 jam beroperasi di bawah beban.
• 2. Ventilasi: Ukur selisih suhu antara intake dan exhaust. Jika $\Delta T > 18^\circ\text{C}$, tingkatkan frekuensi kipas exhaust melalui inverter (VFD).
• 3. Monitoring: Deploy skrip kontrol otomatis ASIC dengan sistem alert jika hashrate turun di bawah 170 TH/s.
• 4. Manajemen Risiko Finansial: Perhitungan titik impas (break-even) harus memperhitungkan potensi kenaikan difficulty network sebesar 15–20% per tahun.