wallet: run the node on a SQLite backend (opt-in)

Adds -walletbackend=sqlite: an opt-in flag that runs the node on
<datadir>/wallet.sqlite instead of wallet.dat. It requires an export to
exist first (no silent migration) and prints a step-by-step guide when
one does not; wallet.dat is never opened or touched, so a plain restart
goes back to Berkeley DB.

- LoadWalletFromSQLiteRuntime opens the export read-write, keeps the
  handle open as the active backend, loads records into memory through
  the same visitor/reconcile/finish path as the read-only staging load,
  and never fabricates a default key.
- Shutdown checkpoints and closes the SQLite backend; a kill before that
  loses nothing because WAL + synchronous=FULL already made every
  committed write durable.
- Self-test proves runtime writes persist across a close and reopen.

BDB stays the default: nothing activates the SQLite runtime unless the
flag is given. One-shot audit/recovery commands still use Berkeley DB.

1 files changed, 25 insertions, 0 deletions

diff --git a/src/selftest.cpp b/src/selftest.cpp
index 9fa0938..098eed6 100644
--- a/src/selftest.cpp
+++ b/src/selftest.cpp
@@ -1230,6 +1230,31 @@ static int RunWalletSQLiteSelfTest()
 
                 nFail += Check(!FileExists((strRuntimeDir + "/wallet.dat").c_str()),
                                "active SQLite runtime does not create wallet.dat") ? 0 : 1;
+
+                // Durability: close the backend (checkpoints the WAL), reopen
+                // the same file, and confirm what CWalletDB wrote is still
+                // there. This is the write-survives-a-restart property the real
+                // -walletbackend=sqlite node depends on.
+                WalletSQLiteRuntimeClose();
+                bool fReopened =
+                    WalletSQLiteRuntimeOpen(strRuntimePath, strError);
+                nFail += Check(fReopened,
+                               "SQLite runtime wallet reopens after close") ? 0 : 1;
+                if (fReopened)
+                {
+                    int64 nPersisted = 0;
+                    CPrivKey vchPersistedPrivKey;
+                    vector<unsigned char> vchPersistedDefaultKey;
+                    nFail += Check(CWalletDB("r").ReadSetting("runtime-sqlite-setting",
+                                                              nPersisted) &&
+                                   nPersisted == 909090 &&
+                                   CWalletDB("r").ReadDefaultKey(vchPersistedDefaultKey) &&
+                                   vchPersistedDefaultKey == vchRuntimePubKey &&
+                                   CWalletDB("r").ReadKey(vchRuntimePubKey,
+                                                          vchPersistedPrivKey) &&
+                                   vchPersistedPrivKey == vchRuntimePrivKey,
+                                   "SQLite runtime writes persist across a close and reopen") ? 0 : 1;
+                }
             }
 
             WalletSQLiteRuntimeClose();