#!/usr/bin/env python3
"""PPLNS planner for the DirectPool Bitcoin Cash shared pool (non-custodial).

CashStratum runs in pool mode with the "payoutplan" option. It pays the
coinbase to whatever outputs this planner lists in PLAN_FILE, so every block
pays the miners directly and the pool never holds their coins.

What this service does:

  * Reads CashStratum's share logs (logdir/<height>/<workbase>.sharelog) and
    keeps the accepted shares of the last WINDOW_MAX_DAYS days, grouped in
    BUCKET_SECS buckets per address.
  * PPLNS window: the most recent shares whose difficulty adds up to the
    network difficulty times WINDOW_MULTIPLIER (same rule as the Bitcoin
    pool), never older than WINDOW_MAX_DAYS.
  * Deferred payouts, same algorithm as the Bitcoin pool: an address whose
    share is below MIN_PAYOUT_SATS, or beyond MAX_OUTPUTS, keeps a credit in
    an append-only ledger and is paid in a later block.
  * Every PLAN_EVERY seconds writes PLAN_FILE ("<script hex> <weight>" per
    line) and SUMMARY_FILE (JSON read by the stats API).
  * Watches the chain for blocks whose coinbase carries POOL_TAG, and records
    for each one what every address was entitled to and what the coinbase
    actually paid. Orphaned blocks are listed in orphans.txt and ignored.

Standard library only.
"""

import base64
import hashlib
import json
import os
import re
import time
import urllib.error
import urllib.request
from datetime import datetime, timezone

CRED_DIR = os.environ.get("CREDENTIALS_DIRECTORY", "/nonexistent")
RPC_PASS_FILE = os.path.join(CRED_DIR, "rpcpass")
RPC_USER = os.environ.get("BCH_RPC_USER", "pool")
RPC_URL = os.environ.get("BCH_RPC_URL", "http://127.0.0.1:8432")
EXPECTED_CHAIN = os.environ.get("BCH_CHAIN", "main")
ADDR_PREFIX = os.environ.get("BCH_ADDR_PREFIX", "bitcoincash")

LOG_DIR = os.environ.get("POOL_LOG_DIR", "/opt/cashstratum-pplns/logs")
STATE_DIR = os.environ.get("STATE_DIR", "/var/lib/bch-pplns")
PLAN_FILE = os.environ.get("PLAN_FILE", os.path.join(STATE_DIR, "plan", "plan.txt"))
SUMMARY_FILE = os.environ.get("SUMMARY_FILE", os.path.join(STATE_DIR, "plan", "summary.json"))
POOL_TAG = os.environ.get("POOL_TAG", "/directpool.io/pplns/")

FEE_PERCENT = float(os.environ.get("BCH_POOL_FEE", "1"))           # must match poolfee in the pool conf
FEE_ADDRESS = os.environ.get("BCH_FEE_ADDRESS", "")                 # must match pooladdress
MIN_PAYOUT_SATS = int(os.environ.get("MIN_PAYOUT_SATS", "10000"))
MAX_OUTPUTS = int(os.environ.get("MAX_OUTPUTS", "200"))             # CashStratum accepts at most 200
WINDOW_MULTIPLIER = float(os.environ.get("WINDOW_MULTIPLIER", "1.0"))
WINDOW_MAX_DAYS = float(os.environ.get("WINDOW_MAX_DAYS", "7"))
WINDOW_DIFF_OVERRIDE = float(os.environ.get("WINDOW_DIFF_OVERRIDE", "0"))  # tests only
BUCKET_SECS = int(os.environ.get("BUCKET_SECS", "300"))
PLAN_EVERY = float(os.environ.get("PLAN_EVERY", "10"))
CHAIN_EVERY = float(os.environ.get("CHAIN_EVERY", "5"))

SHARES_FILE = os.path.join(STATE_DIR, "shares.log")
SCAN_FILE = os.path.join(STATE_DIR, "scan.json")
CHAIN_FILE = os.path.join(STATE_DIR, "chain.json")
LEDGER_FILE = os.path.join(STATE_DIR, "ledger.jsonl")
ORPHANS_FILE = os.path.join(STATE_DIR, "orphans.txt")
DUST = 546

# ---------------------------------------------------------------- addresses

CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l"
B58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
LEGACY_VERSIONS = {"bitcoincash": (0x00, 0x05)}  # testnet/regtest use 0x6f/0xc4


def _polymod(values):
    gen = (0x98F2BC8E61, 0x79B76D99E2, 0xF33E5FB3C4, 0xAE2EABE2A8, 0x1E4F43E470)
    c = 1
    for d in values:
        c0 = c >> 35
        c = ((c & 0x07FFFFFFFF) << 5) ^ d
        for i in range(5):
            if (c0 >> i) & 1:
                c ^= gen[i]
    return c ^ 1


def _prefix_expand(prefix):
    return [ord(x) & 0x1F for x in prefix] + [0]


def _convertbits(data, frombits, tobits, pad):
    acc = bits = 0
    out = []
    maxv = (1 << tobits) - 1
    for v in data:
        acc = (acc << frombits) | v
        bits += frombits
        while bits >= tobits:
            bits -= tobits
            out.append((acc >> bits) & maxv)
    if pad and bits:
        out.append((acc << (tobits - bits)) & maxv)
    elif not pad and (bits >= frombits or ((acc << (tobits - bits)) & maxv)):
        return None
    return out


def cashaddr_encode(kind, h160, prefix=ADDR_PREFIX):
    """kind 0 = P2PKH, 1 = P2SH (20-byte hashes only)."""
    payload = _convertbits([kind << 3] + list(h160), 8, 5, True)
    checksum = _polymod(_prefix_expand(prefix) + payload + [0] * 8)
    chk = [(checksum >> 5 * (7 - i)) & 0x1F for i in range(8)]
    return prefix + ":" + "".join(CHARSET[d] for d in payload + chk)


def cashaddr_decode(addr, prefix=ADDR_PREFIX):
    a = addr.strip()
    if a.lower() != a and a.upper() != a:
        return None
    a = a.lower()
    if ":" in a:
        p, _, body = a.partition(":")
        if p != prefix:
            return None
    else:
        body = a
    if not body or any(ch not in CHARSET for ch in body):
        return None
    data = [CHARSET.index(ch) for ch in body]
    if _polymod(_prefix_expand(prefix) + data) != 0:
        return None
    raw = _convertbits(data[:-8], 5, 8, False)
    if not raw or len(raw) != 21:
        return None
    version = raw[0]
    if version not in (0, 8):  # only 20-byte P2PKH (0) and P2SH (8), like CashStratum
        return None
    return (0 if version == 0 else 1), bytes(raw[1:])


def legacy_decode(addr, prefix=ADDR_PREFIX):
    n = 0
    for ch in addr:
        if ch not in B58:
            return None
        n = n * 58 + B58.index(ch)
    try:
        raw = n.to_bytes(25, "big")
    except OverflowError:
        return None
    if hashlib.sha256(hashlib.sha256(raw[:21]).digest()).digest()[:4] != raw[21:]:
        return None
    p2pkh, p2sh = LEGACY_VERSIONS.get(prefix, (0x6F, 0xC4))
    if raw[0] == p2pkh:
        return 0, raw[1:21]
    if raw[0] == p2sh:
        return 1, raw[1:21]
    return None


def canonical(username):
    """CashStratum username (address, maybe with .worker) -> canonical cashaddr, or None."""
    name = re.split(r"[._]", username or "", maxsplit=1)[0]
    dec = cashaddr_decode(name) or legacy_decode(name)
    return cashaddr_encode(*dec) if dec else None


def script_for(address):
    kind, h = cashaddr_decode(address)
    return ("76a914" + h.hex() + "88ac") if kind == 0 else ("a914" + h.hex() + "87")


def address_for_script(hexscript):
    s = hexscript.lower()
    if len(s) == 50 and s.startswith("76a914") and s.endswith("88ac"):
        return cashaddr_encode(0, bytes.fromhex(s[6:46]))
    if len(s) == 46 and s.startswith("a914") and s.endswith("87"):
        return cashaddr_encode(1, bytes.fromhex(s[4:44]))
    return None


# ---------------------------------------------------------------- helpers

def iso(ts):
    return None if ts is None else datetime.fromtimestamp(ts, tz=timezone.utc).isoformat().replace("+00:00", "Z")


def log(msg):
    print(msg, flush=True)


def write_atomic(path, text):
    tmp = path + ".tmp"
    with open(tmp, "w") as f:
        f.write(text)
        f.flush()
        os.fsync(f.fileno())
    os.chmod(tmp, 0o644)
    os.replace(tmp, path)


_RPC_AUTH = None


def rpc(method, params=None):
    global _RPC_AUTH
    if _RPC_AUTH is None:
        with open(RPC_PASS_FILE) as f:
            _RPC_AUTH = base64.b64encode(f"{RPC_USER}:{f.read().strip()}".encode()).decode()
    body = json.dumps({"jsonrpc": "1.0", "id": "pplns", "method": method, "params": params or []}).encode()
    req = urllib.request.Request(RPC_URL, data=body, headers={"Content-Type": "application/json",
                                                             "Authorization": "Basic " + _RPC_AUTH})
    try:
        with urllib.request.urlopen(req, timeout=20) as resp:
            data = json.loads(resp.read())
    except urllib.error.HTTPError as exc:
        data = json.loads(exc.read())
    if data.get("error"):
        raise RuntimeError(f"{method}: {data['error']}")
    return data["result"]


def fee_cut(total):
    """Same arithmetic as CashStratum: (double)value / 100 * poolfee, truncated; dust is skipped."""
    if FEE_PERCENT <= 0 or not FEE_ADDRESS:
        return 0
    cut = int(total / 100 * FEE_PERCENT)
    return cut if cut >= DUST else 0


def proportional(weights, amount):
    """Split amount by weights (address -> float). Floors, remainder to the last address in sorted order."""
    total = sum(weights.values())
    out = {}
    if total <= 0 or amount <= 0:
        return out
    keys = sorted(weights)
    given = 0
    for k in keys[:-1]:
        v = int(amount * weights[k] / total)
        out[k] = v
        given += v
    out[keys[-1]] = amount - given
    return {k: v for k, v in out.items() if v > 0}


# ---------------------------------------------------------------- ledger

def read_ledger():
    entries = []
    try:
        with open(LEDGER_FILE) as f:
            for n, line in enumerate(f, 1):
                if line.strip():
                    entries.append(json.loads(line))  # a corrupt ledger must stop the planner
    except FileNotFoundError:
        pass
    return entries


def read_orphans():
    try:
        with open(ORPHANS_FILE) as f:
            return {line.strip() for line in f if line.strip()}
    except FileNotFoundError:
        return set()


def balances_from(entries, orphans):
    seen, bal = set(), {}
    for e in entries:
        if e["block_hash"] in orphans or e["block_hash"] in seen:
            continue
        seen.add(e["block_hash"])
        for a, v in e["entitlement"].items():
            bal[a] = bal.get(a, 0) + int(v)
        for a, v in e["paid"].items():
            bal[a] = bal.get(a, 0) - int(v)
    return {a: v for a, v in bal.items() if v != 0}


def select_payouts(entitlement, balances, miner_reward, min_payout, max_outputs):
    """Port of select_payouts() from the Bitcoin pool's deferred-payout patch."""
    targets = {}
    for a, v in entitlement.items():
        targets[a] = targets.get(a, balances.get(a, 0)) + v
    for a, b in balances.items():
        if b > 0 and a not in targets:
            targets[a] = b
    ranked = sorted(((a, t) for a, t in targets.items() if t > 0), key=lambda x: (-x[1], x[0]))
    if not ranked:
        return dict(entitlement)
    payees = [x for x in ranked if x[1] >= min_payout][:max_outputs]
    if not payees:
        payees = ranked[:max_outputs]
    payees.sort(key=lambda x: x[0])
    total_target = sum(t for _, t in payees)
    out, given = {}, 0
    for i, (a, t) in enumerate(payees):
        amount = miner_reward - given if i == len(payees) - 1 else miner_reward * t // total_target
        given += amount
        if amount > 0:
            out[a] = amount
    return out


# ---------------------------------------------------------------- shares

class Shares:
    def __init__(self):
        self.buckets = {}   # bucket start -> {address: diff}
        self.offsets = {}   # sharelog path -> bytes read
        self.last_share = {}

    def add(self, t, address, diff, persist=None):
        b = int(t) - int(t) % BUCKET_SECS
        slot = self.buckets.setdefault(b, {})
        slot[address] = slot.get(address, 0.0) + diff
        if t > self.last_share.get(address, 0):
            self.last_share[address] = t
        if persist is not None:
            persist.append("%.3f %s %.10g\n" % (t, address, diff))

    def load(self):
        cutoff = time.time() - WINDOW_MAX_DAYS * 86400 - BUCKET_SECS
        try:
            with open(SHARES_FILE) as f:
                for line in f:
                    parts = line.split()
                    if len(parts) == 3 and float(parts[0]) >= cutoff:
                        self.add(float(parts[0]), parts[1], float(parts[2]))
        except FileNotFoundError:
            pass
        try:
            with open(SCAN_FILE) as f:
                self.offsets = json.load(f).get("offsets", {})
        except (FileNotFoundError, json.JSONDecodeError):
            self.offsets = {}

    def prune(self):
        cutoff = time.time() - WINDOW_MAX_DAYS * 86400 - BUCKET_SECS
        old = [b for b in self.buckets if b < cutoff]
        for b in old:
            del self.buckets[b]
        if old:  # rewrite the share file without the expired lines
            tmp = SHARES_FILE + ".tmp"
            with open(SHARES_FILE) as src, open(tmp, "w") as dst:
                for line in src:
                    parts = line.split()
                    if len(parts) == 3 and float(parts[0]) >= cutoff:
                        dst.write(line)
            os.replace(tmp, SHARES_FILE)

    def scan(self):
        """Read new lines from the share logs of the three most recent heights."""
        try:
            dirs = sorted(d for d in os.listdir(LOG_DIR) if re.fullmatch(r"[0-9a-f]{8}", d))[-3:]
        except FileNotFoundError:
            return 0
        lines, live = [], set()
        for d in dirs:
            base = os.path.join(LOG_DIR, d)
            try:
                names = [n for n in os.listdir(base) if n.endswith(".sharelog")]
            except FileNotFoundError:
                continue
            for n in names:
                path = os.path.join(base, n)
                live.add(path)
                pos = self.offsets.get(path, 0)
                try:
                    size = os.path.getsize(path)
                    if size <= pos:
                        continue
                    with open(path, "rb") as f:
                        f.seek(pos)
                        chunk = f.read(size - pos)
                except OSError:
                    continue
                end = chunk.rfind(b"\n")
                if end < 0:
                    continue
                self.offsets[path] = pos + end + 1
                for raw in chunk[: end + 1].splitlines():
                    try:
                        rec = json.loads(raw)
                    except ValueError:
                        continue
                    if rec.get("result") is not True:
                        continue
                    address = canonical(rec.get("username") or rec.get("workername"))
                    diff = float(rec.get("diff") or 0)
                    if not address or diff <= 0:
                        continue
                    sec, _, nsec = str(rec.get("createdate", "")).partition(",")
                    try:
                        t = int(sec) + (int(nsec) / 1e9 if nsec else 0)
                    except ValueError:
                        t = time.time()
                    self.add(t, address, diff, persist=lines)
        if lines:
            with open(SHARES_FILE, "a") as f:
                f.writelines(lines)
                f.flush()
                os.fsync(f.fileno())
        # forget offsets of share logs we no longer look at
        self.offsets = {p: o for p, o in self.offsets.items() if p in live}
        write_atomic(SCAN_FILE, json.dumps({"offsets": self.offsets}))
        return len(lines)

    def window(self, target, now):
        """Most recent shares adding up to target difficulty. Returns ({address: diff}, total, oldest_t)."""
        cutoff = now - WINDOW_MAX_DAYS * 86400
        acc, total, oldest = {}, 0.0, None
        for b in sorted(self.buckets, reverse=True):
            if b + BUCKET_SECS <= cutoff:
                break
            slot = self.buckets[b]
            size = sum(slot.values())
            if size <= 0:
                continue
            take = 1.0 if total + size <= target else (target - total) / size
            for a, d in slot.items():
                acc[a] = acc.get(a, 0.0) + d * take
            total += size * take
            oldest = b
            if total >= target:
                break
        return acc, total, oldest


# ---------------------------------------------------------------- main loop

class Planner:
    def __init__(self):
        self.shares = Shares()
        self.netdiff = None
        self.reward = None
        self.last_net = 0
        self.tip_height = None
        self.scanned_height = None
        self.floor = 0
        self.seen = {}  # height -> block hash already examined
        self.last_plan_text = None
        self.last_plan_write = 0
        self.ledger = read_ledger()
        self.orphans = read_orphans()

    def refresh_network(self, now):
        if now - self.last_net < 60 and self.netdiff is not None:
            return
        info = rpc("getblockchaininfo")
        if info.get("chain") != EXPECTED_CHAIN:
            raise RuntimeError(f"node is on chain {info.get('chain')}, expected {EXPECTED_CHAIN}")
        self.netdiff = float(info["difficulty"])
        self.tip_height = int(info["blocks"])
        try:
            self.reward = int(rpc("getblocktemplate", [{}])["coinbasevalue"])
        except Exception as exc:
            log(f"template unavailable: {exc}")
        self.last_net = now

    def target(self):
        return WINDOW_DIFF_OVERRIDE if WINDOW_DIFF_OVERRIDE > 0 else self.netdiff * WINDOW_MULTIPLIER

    def entitlement(self, miner_reward, now):
        weights, total, oldest = self.shares.window(self.target(), now)
        return proportional(weights, miner_reward), weights, total, oldest

    def write_plan(self, now):
        if self.reward is None or self.netdiff is None:
            return
        miner_reward = self.reward - fee_cut(self.reward)
        ent, weights, total, oldest = self.entitlement(miner_reward, now)
        balances = balances_from(self.ledger, self.orphans)
        payouts = select_payouts(ent, balances, miner_reward, MIN_PAYOUT_SATS, MAX_OUTPUTS) if ent or any(
            v > 0 for v in balances.values()) else {}
        lines = ["# DirectPool BCH PPLNS payout plan, written %s\n" % iso(now)]
        lines += ["%s %d\n" % (script_for(a), v) for a, v in sorted(payouts.items())]
        text = "".join(lines)
        body = "".join(lines[1:])
        if body != self.last_plan_text or now - self.last_plan_write >= 60:
            write_atomic(PLAN_FILE, text)
            self.last_plan_text, self.last_plan_write = body, now
        wsum = sum(weights.values())
        miners = {}
        for a in set(weights) | set(balances) | set(payouts):
            miners[a] = {"windowDiff": weights.get(a, 0.0),
                         "windowPercent": 100.0 * weights.get(a, 0.0) / wsum if wsum else 0.0,
                         "estimatedSats": ent.get(a, 0), "balanceSats": balances.get(a, 0),
                         "nextBlockSats": payouts.get(a, 0),
                         "lastShareAt": iso(self.shares.last_share.get(a))}
        summary = {
            "updatedAt": iso(now), "feePercent": FEE_PERCENT, "minPayoutSats": MIN_PAYOUT_SATS,
            "maxOutputs": MAX_OUTPUTS, "windowTargetDiff": self.target(), "windowDiff": total,
            "windowStartAt": iso(oldest), "windowMaxDays": WINDOW_MAX_DAYS,
            "windowMultiplier": WINDOW_MULTIPLIER, "minerRewardSats": miner_reward,
            "paidNextBlock": len(payouts), "miners": miners,
            "blocks": [{"height": e["height"], "hash": e["block_hash"], "foundAt": iso(e.get("found_at")),
                        "minerRewardSats": e["miner_reward_sats"], "paidOutputs": len(e["paid"]),
                        "orphaned": e["block_hash"] in self.orphans} for e in reversed(self.ledger[-50:])],
        }
        write_atomic(SUMMARY_FILE, json.dumps(summary))

    def record_block(self, block, now):
        h = block["hash"]
        if any(e["block_hash"] == h for e in self.ledger):
            return
        cb = block["tx"][0]
        total, paid = 0, {}
        for out in cb["vout"]:
            sats = round(float(out["value"]) * 1e8)
            total += sats
            if sats == 0:
                continue
            addr = address_for_script(out["scriptPubKey"]["hex"])
            if addr is None:
                raise RuntimeError(f"block {h}: coinbase output without a P2PKH/P2SH script")
            paid[addr] = paid.get(addr, 0) + sats
        cut = fee_cut(total)
        if cut:
            fee_key = canonical(FEE_ADDRESS)
            if paid.get(fee_key, 0) < cut:
                raise RuntimeError(f"block {h}: coinbase pays the fee address less than the fee")
            paid[fee_key] -= cut
            if paid[fee_key] == 0:
                del paid[fee_key]
        miner_reward = total - cut
        ent, _, _, _ = self.entitlement(miner_reward, now)
        if sum(paid.values()) != miner_reward or sum(ent.values()) != miner_reward:
            log(f"ledger totals differ for {h}: reward {miner_reward}, paid {sum(paid.values())}, "
                f"entitled {sum(ent.values())}")
        entry = {"block_hash": h, "height": int(block["height"]), "found_at": int(block["time"]),
                 "recorded_at": int(now), "miner_reward_sats": miner_reward,
                 "entitlement": dict(sorted(ent.items())), "paid": dict(sorted(paid.items()))}
        with open(LEDGER_FILE, "a") as f:
            f.write(json.dumps(entry) + "\n")
            f.flush()
            os.fsync(f.fileno())
        self.ledger.append(entry)
        log(f"block {entry['height']} {h}: reward {miner_reward} sats to {len(paid)} addresses, "
            f"{len(ent)} entitled")

    def scan_chain(self, now):
        """Look at every new block (up to 100 per cycle) for our coinbase tag."""
        tip = int(rpc("getblockcount"))
        if self.scanned_height is None:
            try:
                with open(CHAIN_FILE) as f:
                    saved = json.load(f)
                self.scanned_height = int(saved["height"])
                self.floor = int(saved.get("floor", 0))
            except (FileNotFoundError, ValueError, KeyError, json.JSONDecodeError):
                # First start: only blocks found from now on belong to this ledger.
                self.scanned_height = tip
                self.floor = tip + 1
                write_atomic(CHAIN_FILE, json.dumps({"height": tip, "floor": self.floor}))
            self.scanned_height = min(self.scanned_height, tip)
        tag = POOL_TAG.encode().hex()
        start = self.scanned_height + 1
        # Re-check the last few heights too: after a reorg one of them may now be our block.
        for height in range(max(self.floor, start - 6), min(tip, start + 99) + 1):
            bhash = rpc("getblockhash", [height])
            if self.seen.get(height) == bhash:
                continue
            block = rpc("getblock", [bhash, 2])
            if tag in block["tx"][0]["vin"][0].get("coinbase", ""):
                self.record_block(block, now)
            self.seen[height] = bhash
            self.scanned_height = max(self.scanned_height, height)
        for height in [h for h in self.seen if h < tip - 20]:
            del self.seen[height]
        if self.scanned_height >= start:
            write_atomic(CHAIN_FILE, json.dumps({"height": self.scanned_height, "floor": self.floor}))

    def check_orphans(self):
        changed = False
        tip = int(rpc("getblockcount"))
        for e in self.ledger:
            if e["height"] < tip - 200:
                continue
            try:
                conf = int(rpc("getblockheader", [e["block_hash"]]).get("confirmations", 0))
            except RuntimeError:
                conf = -1
            if conf < 0 and e["block_hash"] not in self.orphans and tip >= e["height"] + 2:
                self.orphans.add(e["block_hash"])
                changed = True
                log(f"block {e['height']} {e['block_hash']} orphaned, its ledger entry no longer counts")
            elif conf >= 0 and e["block_hash"] in self.orphans:
                self.orphans.discard(e["block_hash"])
                changed = True
                log(f"block {e['height']} {e['block_hash']} is back in the main chain")
        if changed:
            write_atomic(ORPHANS_FILE, "".join(h + "\n" for h in sorted(self.orphans)))

    def run(self):
        os.makedirs(STATE_DIR, exist_ok=True)
        os.makedirs(os.path.dirname(PLAN_FILE), exist_ok=True)
        self.shares.load()
        balances = balances_from(self.ledger, self.orphans)
        log(f"PPLNS planner: {len(self.ledger)} ledger blocks, {len(balances)} balances, "
            f"min payout {MIN_PAYOUT_SATS}, max outputs {MAX_OUTPUTS}, window x{WINDOW_MULTIPLIER} "
            f"(max {WINDOW_MAX_DAYS} days)")
        last_plan = last_chain = last_orphan = last_prune = 0
        while True:
            now = time.time()
            try:
                self.refresh_network(now)
                self.shares.scan()
                if now - last_chain >= CHAIN_EVERY:
                    self.scan_chain(now)
                    last_chain = now
                if now - last_orphan >= 60:
                    self.check_orphans()
                    last_orphan = now
                if now - last_plan >= PLAN_EVERY:
                    self.write_plan(now)
                    last_plan = now
                if now - last_prune >= 3600:
                    self.shares.prune()
                    last_prune = now
            except Exception as exc:
                log(f"cycle failed: {exc}")
            time.sleep(1)


if __name__ == "__main__":
    Planner().run()