payout: make in-flight payments survive a restart

The exec queue was memory-only, and FlushMaturePayouts erased a matured entry
from pending_payouts.json *before* handing it over. Any restart in that window
lost those payments with no record that anyone was owed anything. It was not
hypothetical: a container restart on 2026-07-30 silently dropped a backlog of
~1,156 BTF, and there was nothing left to reconstruct it from.

Re-queueing blindly would have double-paid whoever had already been sent to,
so the payment needs to be idempotent rather than merely persistent.

In-flight work is now a persisted list of per-payment records
(paying_payouts.json), one per (block, address) -- the granularity SendMoney
works at, and therefore the granularity at which a payment can be half-done
when the process dies. Records are written, via a temp file and rename so a
crash cannot truncate them, *before* the ledger entry is erased, so the debt
is always described by at least one of the two files. Each attempt updates the
record (retries, deferrals, backoff); settling it removes the record and
rewrites the file, which is what stops a restart from paying twice.

On startup ReconcilePayouts runs before the payout thread:
  - a record whose payment the wallet already shows -- matched on the payout
    comment plus the exact amount and destination -- is dropped, not resent.
    SendMoney commits the transaction to the wallet before it returns, so a
    crash immediately after sending is recoverable.
  - a ledger entry that has already been exploded into records is dropped,
    which is the crash-in-the-window case where both files describe one debt.

The wallet check is deliberately biased towards "already paid": skipping a
payment is visible in the log and recoverable, paying twice is neither.

Verified live: sampling paying_payouts.json during a payout burst caught 3
records / 18.56 BTF mid-flight, cleared once paid, and the paid lines now
carry the txid.

(cherry picked from commit d0248f2e65dbe745f2e9b1d09e1f53a4354d3640)

1 files changed, 338 insertions, 124 deletions

diff --git a/src/rpc.cpp b/src/rpc.cpp
index 11020d8..ae94289 100644
--- a/src/rpc.cpp
+++ b/src/rpc.cpp
@@ -315,25 +315,117 @@ static void LoadPendingPayouts()
     }
 }
 
-// Payouts ready to execute are moved here under gPayoutExecMutex.
-// A dedicated thread drains this list so SendMoney (which takes cs_main)
-// never runs on the event loop thread and can't stall miner I/O.
-static std::vector<PendingPayout> gPayoutExecQueue;
-static std::mutex                 gPayoutExecMutex;
-static std::atomic<bool>          gPayoutThreadRunning{false};
+// A payment in flight: one record per (payout entry, address) pair, which is
+// the granularity SendMoney works at and therefore the granularity at which a
+// payment can be half-done when the process dies.
+//
+// This list is persisted. It used to be a memory-only queue, and matured
+// entries were erased from pending_payouts.json *before* being handed to it,
+// so any restart in between lost those payments with no record that anyone
+// was owed anything: a container restart on 2026-07-30 silently dropped
+// ~1,156 BTF that way. Writing the records before removing the ledger entry,
+// and reconciling against the wallet on startup, is what makes a restart
+// survivable.
+struct PayingRecord {
+    int         blockHeight    = 0;
+    uint256     blockHash      = 0; // zero = predates hash keying, see PendingPayout
+    int         matureAtHeight = 0;
+    std::string address;
+    int64       amount     = 0;
+    int         retries    = 0;
+    int         deferrals  = 0;
+    int64       retryAfter = 0;
+};
+static std::vector<PayingRecord> gPaying; // guarded by gPayoutExecMutex
+static std::mutex                gPayoutExecMutex;
+static std::atomic<bool>         gPayoutThreadRunning{false};
+
+static std::string PayingFilePath()
+{
+    return GetAppDir() + "/paying_payouts.json";
+}
+
+// Caller must hold gPayoutExecMutex.
+static void SavePayingLocked()
+{
+    nlohmann::json arr = nlohmann::json::array();
+    for (const auto& r : gPaying) {
+        nlohmann::json obj;
+        obj["blockHeight"]    = r.blockHeight;
+        obj["blockHash"]      = r.blockHash.ToString();
+        obj["matureAtHeight"] = r.matureAtHeight;
+        obj["address"]        = r.address;
+        obj["amount"]         = r.amount;
+        obj["retries"]        = r.retries;
+        obj["deferrals"]      = r.deferrals;
+        arr.push_back(obj);
+    }
+    std::string path = PayingFilePath();
+    // Write to a temporary file and rename, so a crash mid-write cannot leave
+    // a truncated list of who is still owed money.
+    std::string tmp = path + ".tmp";
+    FILE* f = fopen(tmp.c_str(), "w");
+    if (!f) {
+        LogPrint("payout", "[payout] WARNING: could not write %s\n", tmp.c_str());
+        return;
+    }
+    std::string s = arr.dump(2);
+    fwrite(s.c_str(), 1, s.size(), f);
+    fflush(f);
+    fclose(f);
+    if (rename(tmp.c_str(), path.c_str()) != 0)
+        LogPrint("payout", "[payout] WARNING: could not rename %s -> %s\n",
+                 tmp.c_str(), path.c_str());
+}
+
+static void LoadPaying()
+{
+    std::string path = PayingFilePath();
+    FILE* f = fopen(path.c_str(), "r");
+    if (!f) return;
+    fseek(f, 0, SEEK_END);
+    long sz = ftell(f);
+    fseek(f, 0, SEEK_SET);
+    std::string s(sz, '\0');
+    fread(&s[0], 1, sz, f);
+    fclose(f);
+    try {
+        nlohmann::json arr = nlohmann::json::parse(s);
+        for (const auto& obj : arr) {
+            PayingRecord r;
+            r.address        = obj["address"].get<std::string>();
+            r.amount         = obj["amount"].get<int64>();
+            r.matureAtHeight = obj["matureAtHeight"].get<int>();
+            if (obj.contains("blockHash") && obj["blockHash"].is_string())
+                r.blockHash.SetHex(obj["blockHash"].get<std::string>());
+            if (obj.contains("blockHeight") && obj["blockHeight"].is_number())
+                r.blockHeight = obj["blockHeight"].get<int>();
+            if (obj.contains("retries") && obj["retries"].is_number())
+                r.retries = obj["retries"].get<int>();
+            if (obj.contains("deferrals") && obj["deferrals"].is_number())
+                r.deferrals = obj["deferrals"].get<int>();
+            gPaying.push_back(r);
+        }
+        LogPrint("payout", "[payout] loaded %zu in-flight payment(s) from disk\n",
+                 gPaying.size());
+    } catch (const std::exception& e) {
+        LogPrint("payout", "[payout] WARNING: failed to parse %s: %s\n",
+                 path.c_str(), e.what());
+    }
+}
 
 // Is the block that funds this payout still on the main chain?
 //
 // A zero hash means the entry was written before payouts recorded one, so
 // there is nothing to check and we assume it is good -- voiding those would
 // mean refusing to pay miners on the strength of a missing field.
-static bool PayoutBlockStillOnChain(const PendingPayout& pp)
+static bool PayoutBlockStillOnChain(const uint256& blockHash)
 {
-    if (pp.blockHash == 0)
+    if (blockHash == 0)
         return true;
     CRITICAL_BLOCK(cs_main)
     {
-        std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(pp.blockHash);
+        std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(blockHash);
         if (mi == mapBlockIndex.end() || mi->second == NULL)
             return false;
         return mi->second->IsInMainChain();
@@ -341,6 +433,99 @@ static bool PayoutBlockStillOnChain(const PendingPayout& pp)
     return false;
 }
 
+static std::string PayoutComment(int blockHeight)
+{
+    return strprintf("Pool payout height %d", blockHeight);
+}
+
+// Did we already send this payment before dying? Looks for a wallet
+// transaction of ours carrying this payout's comment and paying exactly this
+// amount to this address.
+//
+// Biased towards reporting "already paid" on any doubt: skipping a payment a
+// miner is owed is visible and recoverable from the log, while paying twice
+// is neither.
+static bool WalletAlreadyPaid(const PayingRecord& r)
+{
+    uint160 h160;
+    if (!AddressToHash160(r.address, h160))
+        return false;
+    CScript want;
+    want << OP_DUP << OP_HASH160 << h160 << OP_EQUALVERIFY << OP_CHECKSIG;
+    const std::string comment = PayoutComment(r.blockHeight);
+
+    CRITICAL_BLOCK(cs_mapWallet)
+    {
+        for (std::map<uint256, CWalletTx>::iterator it = mapWallet.begin();
+             it != mapWallet.end(); ++it) {
+            CWalletTx& wtx = it->second;
+            // The comment is written only by the payout path, so its presence
+            // already identifies the transaction as one of ours.
+            std::map<std::string, std::string>::const_iterator ci =
+                wtx.mapValue.find("comment");
+            if (ci == wtx.mapValue.end() || ci->second != comment)
+                continue;
+            foreach (const CTxOut& txout, wtx.vout)
+                if (txout.nValue == r.amount && txout.scriptPubKey == want)
+                    return true;
+        }
+    }
+    return false;
+}
+
+// Startup reconciliation. Drops in-flight records the wallet shows were
+// already sent, and drops ledger entries that were already exploded into
+// records (which happens if we died between writing the records and rewriting
+// the ledger -- both files then describe the same debt).
+static void ReconcilePayouts()
+{
+    std::lock_guard<std::mutex> lk(gPayoutExecMutex);
+
+    size_t settled = 0;
+    int64  settledAmount = 0;
+    for (auto it = gPaying.begin(); it != gPaying.end(); ) {
+        if (WalletAlreadyPaid(*it)) {
+            settledAmount += it->amount;
+            settled++;
+            it = gPaying.erase(it);
+        } else {
+            ++it;
+        }
+    }
+    if (settled) {
+        LogPrint("payout", "[payout] %zu in-flight payment(s) totalling %s were"
+                 " already sent before the last shutdown -- not resending\n",
+                 settled, FormatMoney(settledAmount).c_str());
+        SavePayingLocked();
+    }
+
+    size_t dropped = 0;
+    for (auto it = gPendingPayouts.begin(); it != gPendingPayouts.end(); ) {
+        bool exploded = false;
+        for (const auto& r : gPaying)
+            if (r.matureAtHeight == it->matureAtHeight && r.blockHash == it->blockHash) {
+                exploded = true;
+                break;
+            }
+        if (exploded) {
+            LogPrint("payout", "[payout] ledger entry for block %d is already"
+                     " in flight -- dropping the duplicate\n", it->blockHeight);
+            it = gPendingPayouts.erase(it);
+            dropped++;
+        } else {
+            ++it;
+        }
+    }
+    if (dropped) SavePendingPayouts();
+
+    if (!gPaying.empty()) {
+        int64 owed = 0;
+        for (const auto& r : gPaying) owed += r.amount;
+        LogPrint("payout", "[payout] resuming %zu in-flight payment(s) totalling %s\n",
+                 gPaying.size(), FormatMoney(owed).c_str());
+    }
+}
+
 static void QueuePayouts(int blockHeight,
                          const uint256& blockHash,
                          const std::map<std::string, uint64>& shareCount,
@@ -418,19 +603,13 @@ static void QueuePayouts(int blockHeight,
                         : "");
 }
 
-// Called from event loop: move matured entries to the exec queue (fast).
-// NOT crash-safe, despite the ordering below looking like it is.
+// Called from event loop: move matured entries into the in-flight list (fast).
 //
-// A matured payout is erased from gPendingPayouts, the file is rewritten
-// without it, and only then does it reach the exec queue -- which lives in
-// memory alone. SavePendingPayouts writes gPendingPayouts and nothing else;
-// there is no exec-queue section of the file to recover from. Die anywhere
-// between the rewrite and SendMoney and those miners are simply never paid,
-// with no record that they were owed anything.
-//
-// Making this safe needs the payment to be idempotent -- record the txid and
-// check the wallet for it on restart -- rather than a reordering, since
-// re-queueing blindly would double-pay whoever was already sent to.
+// Ordering matters and is deliberate: the in-flight records are written and
+// fsync'd to their own file *before* the ledger entry is erased, so the debt
+// is always described by at least one of the two files. Dying in the window
+// where both describe it is handled at startup by ReconcilePayouts, which
+// drops the ledger entry it can see is already in flight.
 static void FlushMaturePayouts()
 {
     // Void obligations whose funding block lost a reorg. The coin that was
@@ -438,7 +617,7 @@ static void FlushMaturePayouts()
     // coin the pool owes to somebody else.
     bool voided = false;
     for (auto it = gPendingPayouts.begin(); it != gPendingPayouts.end(); ) {
-        if (PayoutBlockStillOnChain(*it)) { ++it; continue; }
+        if (PayoutBlockStillOnChain(it->blockHash)) { ++it; continue; }
         int64 total = 0;
         for (auto& kv : it->amounts) total += kv.second;
         LogPrint("payout", "[payout] block %d (%s) was orphaned -- voiding %zu"
@@ -459,8 +638,23 @@ static void FlushMaturePayouts()
         ++it;
     }
     if (!ready.empty()) {
-        // Erase from pending then save before handing off to exec thread,
-        // so the file never contains an entry that is already being sent.
+        // Record the individual payments first, and only then drop the ledger
+        // entries that produced them.
+        {
+            std::lock_guard<std::mutex> lk(gPayoutExecMutex);
+            for (const auto& pp : ready) {
+                for (const auto& kv : pp.amounts) {
+                    PayingRecord r;
+                    r.blockHeight    = pp.blockHeight;
+                    r.blockHash      = pp.blockHash;
+                    r.matureAtHeight = pp.matureAtHeight;
+                    r.address        = kv.first;
+                    r.amount         = kv.second;
+                    gPaying.push_back(r);
+                }
+            }
+            SavePayingLocked();
+        }
         for (auto it = gPendingPayouts.begin(); it != gPendingPayouts.end(); ) {
             if (nBestHeight >= it->matureAtHeight)
                 it = gPendingPayouts.erase(it);
@@ -468,13 +662,45 @@ static void FlushMaturePayouts()
                 ++it;
         }
         SavePendingPayouts();
-        std::lock_guard<std::mutex> lk(gPayoutExecMutex);
-        for (auto& pp : ready)
-            gPayoutExecQueue.push_back(std::move(pp));
     }
 }
 
-// Payout execution thread: drains gPayoutExecQueue, calls SendMoney.
+// Identity of a payment, for finding its record again after SendMoney.
+// amounts is a map keyed by address, so (block, address) is already unique.
+static bool SamePayment(const PayingRecord& a, const PayingRecord& b)
+{
+    return a.matureAtHeight == b.matureAtHeight
+        && a.blockHash      == b.blockHash
+        && a.address        == b.address
+        && a.amount         == b.amount;
+}
+
+// Settle a payment: it is either done or abandoned, either way it stops being
+// owed. Removing the record and rewriting the file is what makes the payment
+// not happen twice after a restart.
+static void ForgetPayment(const PayingRecord& r)
+{
+    std::lock_guard<std::mutex> lk(gPayoutExecMutex);
+    for (auto it = gPaying.begin(); it != gPaying.end(); ++it)
+        if (SamePayment(*it, r)) { gPaying.erase(it); break; }
+    SavePayingLocked();
+}
+
+// Persist an updated attempt count / backoff for a payment still owed.
+static void ReschedulePayment(const PayingRecord& r)
+{
+    std::lock_guard<std::mutex> lk(gPayoutExecMutex);
+    for (auto& e : gPaying)
+        if (SamePayment(e, r)) {
+            e.retries    = r.retries;
+            e.deferrals  = r.deferrals;
+            e.retryAfter = r.retryAfter;
+            break;
+        }
+    SavePayingLocked();
+}
+
+// Payout execution thread: works through gPaying, calls SendMoney.
 // Runs independently of the event loop so slow wallet operations
 // (SendMoney takes cs_main) never stall miner I/O.
 static void PayoutThreadFn(void*)
@@ -483,111 +709,94 @@ static void PayoutThreadFn(void*)
     LogPrint("payout", "[payout] payout thread started\n");
 
     while (!fShutdown && gPoolRunning) {
-        std::vector<PendingPayout> batch;
+        std::vector<PayingRecord> batch;
         {
             std::lock_guard<std::mutex> lk(gPayoutExecMutex);
-            batch.swap(gPayoutExecQueue);
+            int64 now = GetTime();
+            for (const auto& r : gPaying)
+                if (r.retryAfter <= now)
+                    batch.push_back(r);
         }
 
-        for (auto& pp : batch) {
-            if (pp.retryAfter > GetTime()) {
-                std::lock_guard<std::mutex> lk(gPayoutExecMutex);
-                gPayoutExecQueue.push_back(pp);
-                continue;
-            }
-            // Re-check here and not only at maturity: an entry can sit in this
-            // queue for hours across retries, and the reorg that kills its
+        for (PayingRecord r : batch) {
+            // Re-check here and not only at maturity: a payment can sit in this
+            // list for hours across retries, and the reorg that kills its
             // funding block can land at any point in that window.
-            if (!PayoutBlockStillOnChain(pp)) {
-                int64 total = 0;
-                for (auto& kv : pp.amounts) total += kv.second;
+            if (!PayoutBlockStillOnChain(r.blockHash)) {
                 LogPrint("payout", "[payout] block %d (%s) orphaned while queued"
-                         " -- dropping %zu payment(s) totalling %s\n",
-                         pp.blockHeight, pp.blockHash.ToString().substr(0, 14).c_str(),
-                         pp.amounts.size(), FormatMoney(total).c_str());
+                         " -- dropping %s to %s\n",
+                         r.blockHeight, r.blockHash.ToString().substr(0, 14).c_str(),
+                         FormatMoney(r.amount).c_str(), r.address.c_str());
+                ForgetPayment(r);
                 continue;
             }
-            LogPrint("payout", "[payout] executing payments for block matured at %d"
-                     " (%zu miners)\n", pp.matureAtHeight, pp.amounts.size());
-            for (auto& kv : pp.amounts) {
-                uint160 h160;
-                if (!AddressToHash160(kv.first, h160)) {
-                    // Should not happen -- bad addresses are filtered in QueuePayouts
-                    LogPrint("payout", "[payout] SKIPPED bad address '%s'\n",
-                             kv.first.c_str());
-                    continue;
-                }
-                CScript sc;
-                sc << OP_DUP << OP_HASH160 << h160 << OP_EQUALVERIFY << OP_CHECKSIG;
-                CWalletTx wtx;
-                wtx.mapValue["comment"] = strprintf("Pool payout height %d",
-                                                     pp.blockHeight);
-
-                // Waiting for coin to mature is not a failure, so it must not
-                // consume the retry budget. Burning a retry every 60s means a
-                // payment the pool fully intends to honour can hit GIVING UP
-                // 24h later purely because the subsidy funding it had not
-                // matured yet -- the miner is then silently never paid.
-                int64 nSpendable = GetBalance();
-                if (nSpendable < kv.second) {
-                    PendingPayout dp;
-                    dp.blockHeight    = pp.blockHeight;
-                    dp.blockHash      = pp.blockHash;
-                    dp.matureAtHeight = pp.matureAtHeight;
-                    dp.amounts[kv.first] = kv.second;
-                    dp.retries    = pp.retries;          // unchanged on purpose
-                    dp.deferrals  = pp.deferrals + 1;
-                    dp.retryAfter = GetTime() + 60;
-                    // Hourly, not every minute: a dry pool would otherwise
-                    // write one line per payment per minute forever.
-                    if (dp.deferrals == 1 || dp.deferrals % 60 == 0)
-                        LogPrint("payout", "[payout] deferring %s to %s -- only %s"
-                                 " spendable (waiting %d min so far)\n",
-                                 FormatMoney(kv.second).c_str(), kv.first.c_str(),
-                                 FormatMoney(nSpendable).c_str(), dp.deferrals);
-                    std::lock_guard<std::mutex> lk(gPayoutExecMutex);
-                    gPayoutExecQueue.push_back(std::move(dp));
-                    continue;
-                }
 
-                if (SendMoney(sc, kv.second, wtx)) {
-                    LogPrint("payout", "[payout] paid %s to %s\n",
-                             FormatMoney(kv.second).c_str(), kv.first.c_str());
-                } else if (pp.retries < 1440) {
-                    // Transient failures (immature coinbase, reorg, locked
-                    // wallet) must not silently burn the payment -- requeue
-                    // with backoff. Permanent cases (orphaned coinbase) give
-                    // up loudly after 1440 tries (~24 h).
-                    PendingPayout rp;
-                    rp.blockHeight    = pp.blockHeight;
-                    rp.blockHash      = pp.blockHash;
-                    rp.matureAtHeight = pp.matureAtHeight;
-                    rp.amounts[kv.first] = kv.second;
-                    rp.retries = pp.retries + 1;
-                    rp.deferrals = pp.deferrals;
-                    rp.retryAfter = GetTime() + 60;
-                    {
-                        std::lock_guard<std::mutex> lk(gPayoutExecMutex);
-                        gPayoutExecQueue.push_back(std::move(rp));
-                    }
-                    LogPrint("payout", "[payout] FAILED to pay %s to %s"
-                             " (%s spendable at the time) -- retry %d/1440 in 60s\n",
-                             FormatMoney(kv.second).c_str(), kv.first.c_str(),
-                             FormatMoney(nSpendable).c_str(),
-                             pp.retries + 1);
-                } else {
-                    // Reaching here now means 1440 attempts that were NOT
-                    // insufficient-funds waits (those defer instead) against a
-                    // block still on the main chain -- i.e. a real wallet fault,
-                    // not a maturity or reorg question.
-                    LogPrint("payout", "[payout] GIVING UP on %s to %s after %d"
-                             " retries -- block %d is still on-chain and %s was"
-                             " spendable, so this is a wallet fault, not maturity"
-                             " -- payment forfeited\n",
-                             FormatMoney(kv.second).c_str(), kv.first.c_str(),
-                             pp.retries, pp.blockHeight,
-                             FormatMoney(nSpendable).c_str());
-                }
+            uint160 h160;
+            if (!AddressToHash160(r.address, h160)) {
+                // Should not happen -- bad addresses are filtered in QueuePayouts
+                LogPrint("payout", "[payout] SKIPPED bad address '%s'\n",
+                         r.address.c_str());
+                ForgetPayment(r);
+                continue;
+            }
+            CScript sc;
+            sc << OP_DUP << OP_HASH160 << h160 << OP_EQUALVERIFY << OP_CHECKSIG;
+
+            // Waiting for coin to mature is not a failure, so it must not
+            // consume the retry budget. Burning a retry every 60s means a
+            // payment the pool fully intends to honour can hit GIVING UP
+            // 24h later purely because the subsidy funding it had not
+            // matured yet -- the miner is then silently never paid.
+            int64 nSpendable = GetBalance();
+            if (nSpendable < r.amount) {
+                r.deferrals++;
+                r.retryAfter = GetTime() + 60;
+                // Hourly, not every minute: a dry pool would otherwise
+                // write one line per payment per minute forever.
+                if (r.deferrals == 1 || r.deferrals % 60 == 0)
+                    LogPrint("payout", "[payout] deferring %s to %s -- only %s"
+                             " spendable (waiting %d min so far)\n",
+                             FormatMoney(r.amount).c_str(), r.address.c_str(),
+                             FormatMoney(nSpendable).c_str(), r.deferrals);
+                ReschedulePayment(r);
+                continue;
+            }
+
+            CWalletTx wtx;
+            wtx.mapValue["comment"] = PayoutComment(r.blockHeight);
+
+            if (SendMoney(sc, r.amount, wtx)) {
+                // The wallet holds the transaction before this returns, so a
+                // crash here is recoverable: ReconcilePayouts finds it by
+                // comment+address+amount and does not resend.
+                ForgetPayment(r);
+                LogPrint("payout", "[payout] paid %s to %s (tx %s)\n",
+                         FormatMoney(r.amount).c_str(), r.address.c_str(),
+                         wtx.GetHash().ToString().substr(0, 12).c_str());
+            } else if (r.retries < 1440) {
+                // Transient failures (reorg, locked wallet) must not silently
+                // burn the payment -- retry with backoff. Insufficient funds
+                // never lands here; it defers above.
+                r.retries++;
+                r.retryAfter = GetTime() + 60;
+                ReschedulePayment(r);
+                LogPrint("payout", "[payout] FAILED to pay %s to %s"
+                         " (%s spendable at the time) -- retry %d/1440 in 60s\n",
+                         FormatMoney(r.amount).c_str(), r.address.c_str(),
+                         FormatMoney(nSpendable).c_str(), r.retries);
+            } else {
+                // Reaching here means 1440 attempts that were NOT
+                // insufficient-funds waits (those defer instead) against a
+                // block still on the main chain -- i.e. a real wallet fault,
+                // not a maturity or reorg question.
+                LogPrint("payout", "[payout] GIVING UP on %s to %s after %d"
+                         " retries -- block %d is still on-chain and %s was"
+                         " spendable, so this is a wallet fault, not maturity"
+                         " -- payment forfeited\n",
+                         FormatMoney(r.amount).c_str(), r.address.c_str(),
+                         r.retries, r.blockHeight,
+                         FormatMoney(nSpendable).c_str());
+                ForgetPayment(r);
             }
         }
 
@@ -1631,6 +1840,11 @@ void ThreadRPCServer(void*)
     }
 
     LoadPendingPayouts();
+    LoadPaying();
+    // Must run before the payout thread starts, so nothing is resent that the
+    // wallet already shows as sent, and nothing is owed twice because we died
+    // between recording the payments and rewriting the ledger.
+    ReconcilePayouts();
 
     _beginthread(AcceptLoopFn, 0, NULL);
     _beginthread(LocalAcceptFn, 0, NULL);