beignet 0.2.0 → 0.3.0

package/dist/lightning/storage/sqlite-storage.js

@@ -6,22 +6,42 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SqliteStorage = void 0;
 const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
 const serialization_1 = require("./serialization");
+const encryption_1 = require("./encryption");
 class SqliteStorage {
-    constructor(dbPath, onCorruptRow) {
+    constructor(dbPath, onCorruptRow, opts) {
+        this.forwardingEventsMaxRows = 100000;
         this.db = new better_sqlite3_1.default(dbPath);
         this.onCorruptRow = onCorruptRow;
+        this.encryptionKey = opts?.encryptionKey;
     }
     reportCorruptRow(error) {
+        if (error instanceof encryption_1.StorageEncryptedError) {
+            throw error;
+        }
         if (this.onCorruptRow) {
             this.onCorruptRow(error);
         }
     }
+    _enc(value) {
+        return this.encryptionKey ? (0, encryption_1.encryptValue)(this.encryptionKey, value) : value;
+    }
+    _dec(value) {
+        if (!(0, encryption_1.isEncryptedValue)(value))
+            return value;
+        if (!this.encryptionKey) {
+            throw new encryption_1.StorageEncryptedError();
+        }
+        return (0, encryption_1.decryptValue)(this.encryptionKey, value);
+    }
     open(opts) {
         this.db.pragma('journal_mode = WAL');
         this.db.pragma(`synchronous = ${opts?.synchronous ?? 'FULL'}`);
         this.db.pragma('foreign_keys = ON');
         this.db.pragma('busy_timeout = 5000');
         this._createTables();
+        if (this.encryptionKey) {
+            this._encryptExistingData();
+        }
     }
     checkpoint() {
         this.db.pragma('wal_checkpoint(TRUNCATE)');
@@ -32,6 +52,38 @@ class SqliteStorage {
     async backup(destPath) {
         await this.db.backup(destPath);
     }
+    _encryptExistingData() {
+        const key = this.encryptionKey;
+        if (!key)
+            return;
+        this.db.transaction(() => {
+            for (const { table, pk, columns } of SqliteStorage.ENCRYPTED_COLUMNS) {
+                const rows = this.db
+                    .prepare(`SELECT ${pk}, ${columns.join(', ')} FROM ${table}`)
+                    .all();
+                for (const row of rows) {
+                    const updates = [];
+                    const params = [];
+                    for (const col of columns) {
+                        const raw = row[col];
+                        if (raw === null || raw === undefined)
+                            continue;
+                        const text = typeof raw === 'string' ? raw : String(raw);
+                        if ((0, encryption_1.isEncryptedValue)(text))
+                            continue;
+                        updates.push(`${col} = ?`);
+                        params.push((0, encryption_1.encryptValue)(key, text));
+                    }
+                    if (updates.length === 0)
+                        continue;
+                    params.push(row[pk]);
+                    this.db
+                        .prepare(`UPDATE ${table} SET ${updates.join(', ')} WHERE ${pk} = ?`)
+                        .run(...params);
+                }
+            }
+        })();
+    }
     _createTables() {
         this.db.exec(`
 			CREATE TABLE IF NOT EXISTS channels (
@@ -152,6 +204,61 @@ class SqliteStorage {
 				created_at INTEGER NOT NULL,
 				completed_at INTEGER
 			);
+
+			CREATE TABLE IF NOT EXISTS channel_policies (
+				channel_id TEXT PRIMARY KEY,
+				policy_json TEXT NOT NULL
+			);
+
+			CREATE TABLE IF NOT EXISTS peer_storage_blobs (
+				peer_pubkey TEXT PRIMARY KEY,
+				blob TEXT NOT NULL,
+				received_at INTEGER NOT NULL
+			);
+
+			CREATE TABLE IF NOT EXISTS forwarding_events (
+				id INTEGER PRIMARY KEY AUTOINCREMENT,
+				settled_at INTEGER NOT NULL,
+				in_channel_id TEXT NOT NULL,
+				out_channel_id TEXT NOT NULL,
+				in_scid TEXT,
+				out_scid TEXT,
+				amount_in_msat TEXT NOT NULL,
+				amount_out_msat TEXT NOT NULL,
+				fee_msat TEXT NOT NULL
+			);
+			CREATE INDEX IF NOT EXISTS idx_forwarding_events_settled_at ON forwarding_events(settled_at);
+
+			CREATE TABLE IF NOT EXISTS watchtower_sessions (
+				session_id TEXT PRIMARY KEY,
+				tower_uri TEXT NOT NULL,
+				tower_pubkey TEXT NOT NULL,
+				session_key TEXT NOT NULL,
+				blob_type INTEGER NOT NULL,
+				max_updates INTEGER NOT NULL,
+				sweep_fee_rate TEXT NOT NULL,
+				seq_num INTEGER NOT NULL,
+				last_applied INTEGER NOT NULL,
+				created_at INTEGER NOT NULL
+			);
+			CREATE INDEX IF NOT EXISTS idx_watchtower_sessions_tower ON watchtower_sessions(tower_uri);
+
+			CREATE TABLE IF NOT EXISTS watchtower_updates (
+				id INTEGER PRIMARY KEY AUTOINCREMENT,
+				tower_uri TEXT NOT NULL,
+				channel_id TEXT NOT NULL,
+				hint TEXT NOT NULL,
+				encrypted_blob TEXT NOT NULL,
+				seq_num INTEGER NOT NULL,
+				acked INTEGER NOT NULL,
+				created_at INTEGER NOT NULL
+			);
+			CREATE INDEX IF NOT EXISTS idx_watchtower_updates_pending ON watchtower_updates(tower_uri, acked);
+
+			CREATE TABLE IF NOT EXISTS wallet_data (
+				key TEXT PRIMARY KEY,
+				value TEXT NOT NULL
+			);
 		`);
         this._runMigrations();
     }
@@ -160,7 +267,7 @@ class SqliteStorage {
         const json = JSON.stringify(serialized);
         this.db
             .prepare('INSERT OR REPLACE INTO channels (channel_id, state_json, peer_pubkey) VALUES (?, ?, ?)')
-            .run(id, json, peerPubkey);
+            .run(id, this._enc(json), peerPubkey);
     }
     loadChannel(id) {
         const row = this.db
@@ -169,7 +276,7 @@ class SqliteStorage {
         if (!row)
             return null;
         return {
-            state: (0, serialization_1.deserializeChannelState)(JSON.parse(row.state_json)),
+            state: (0, serialization_1.deserializeChannelState)(JSON.parse(this._dec(row.state_json))),
             peerPubkey: row.peer_pubkey
         };
     }
@@ -182,7 +289,7 @@ class SqliteStorage {
             try {
                 results.push({
                     channelId: row.channel_id,
-                    state: (0, serialization_1.deserializeChannelState)(JSON.parse(row.state_json)),
+                    state: (0, serialization_1.deserializeChannelState)(JSON.parse(this._dec(row.state_json))),
                     peerPubkey: row.peer_pubkey
                 });
             }
@@ -200,7 +307,7 @@ class SqliteStorage {
         const json = JSON.stringify(serialized);
         this.db
             .prepare('INSERT OR REPLACE INTO payments (payment_hash, payment_json) VALUES (?, ?)')
-            .run(paymentHash, json);
+            .run(paymentHash, this._enc(json));
     }
     loadPayment(paymentHash) {
         const row = this.db
@@ -208,7 +315,7 @@ class SqliteStorage {
             .get(paymentHash);
         if (!row)
             return null;
-        return (0, serialization_1.deserializePaymentInfo)(JSON.parse(row.payment_json));
+        return (0, serialization_1.deserializePaymentInfo)(JSON.parse(this._dec(row.payment_json)));
     }
     loadAllPayments() {
         const rows = this.db
@@ -219,7 +326,7 @@ class SqliteStorage {
             try {
                 results.push({
                     paymentHash: row.payment_hash,
-                    payment: (0, serialization_1.deserializePaymentInfo)(JSON.parse(row.payment_json))
+                    payment: (0, serialization_1.deserializePaymentInfo)(JSON.parse(this._dec(row.payment_json)))
                 });
             }
             catch (err) {
@@ -236,7 +343,7 @@ class SqliteStorage {
     savePreimage(paymentHash, preimage) {
         this.db
             .prepare('INSERT OR REPLACE INTO preimages (payment_hash, preimage) VALUES (?, ?)')
-            .run(paymentHash, preimage.toString('hex'));
+            .run(paymentHash, this._enc(preimage.toString('hex')));
     }
     loadPreimage(paymentHash) {
         const row = this.db
@@ -244,7 +351,7 @@ class SqliteStorage {
             .get(paymentHash);
         if (!row)
             return null;
-        return Buffer.from(row.preimage, 'hex');
+        return Buffer.from(this._dec(row.preimage), 'hex');
     }
     loadAllPreimages() {
         const rows = this.db
@@ -255,7 +362,7 @@ class SqliteStorage {
             try {
                 results.push({
                     paymentHash: row.payment_hash,
-                    preimage: Buffer.from(row.preimage, 'hex')
+                    preimage: Buffer.from(this._dec(row.preimage), 'hex')
                 });
             }
             catch (err) {
@@ -290,7 +397,7 @@ class SqliteStorage {
     saveHtlcPaymentMapping(key, paymentHashHex) {
         this.db
             .prepare('INSERT OR REPLACE INTO htlc_payment_map (htlc_key, payment_hash_hex) VALUES (?, ?)')
-            .run(key, paymentHashHex);
+            .run(key, this._enc(paymentHashHex));
     }
     loadAllHtlcPaymentMappings() {
         const rows = this.db
@@ -301,7 +408,7 @@ class SqliteStorage {
             try {
                 results.push({
                     key: row.htlc_key,
-                    paymentHashHex: row.payment_hash_hex
+                    paymentHashHex: this._dec(row.payment_hash_hex)
                 });
             }
             catch (err) {
@@ -316,7 +423,7 @@ class SqliteStorage {
     saveForwardedHtlc(outKey, inChannelId, inHtlcId) {
         this.db
             .prepare('INSERT OR REPLACE INTO forwarded_htlcs (out_key, in_channel_id, in_htlc_id) VALUES (?, ?, ?)')
-            .run(outKey, inChannelId.toString('hex'), inHtlcId.toString());
+            .run(outKey, this._enc(inChannelId.toString('hex')), this._enc(inHtlcId.toString()));
     }
     loadAllForwardedHtlcs() {
         const rows = this.db
@@ -327,8 +434,8 @@ class SqliteStorage {
             try {
                 results.push({
                     outKey: row.out_key,
-                    inChannelId: Buffer.from(row.in_channel_id, 'hex'),
-                    inHtlcId: BigInt(row.in_htlc_id)
+                    inChannelId: Buffer.from(this._dec(row.in_channel_id), 'hex'),
+                    inHtlcId: BigInt(this._dec(row.in_htlc_id))
                 });
             }
             catch (err) {
@@ -346,7 +453,7 @@ class SqliteStorage {
         const json = (0, serialization_1.serializeChainMonitorState)(state);
         this.db
             .prepare('INSERT OR REPLACE INTO chain_monitors (channel_id, state_json) VALUES (?, ?)')
-            .run(channelId, json);
+            .run(channelId, this._enc(json));
     }
     loadChainMonitor(channelId) {
         const row = this.db
@@ -354,7 +461,7 @@ class SqliteStorage {
             .get(channelId);
         if (!row)
             return null;
-        return (0, serialization_1.deserializeChainMonitorState)(row.state_json);
+        return (0, serialization_1.deserializeChainMonitorState)(this._dec(row.state_json));
     }
     loadAllChainMonitors() {
         const rows = this.db
@@ -365,7 +472,7 @@ class SqliteStorage {
             try {
                 results.push({
                     channelId: row.channel_id,
-                    state: (0, serialization_1.deserializeChainMonitorState)(row.state_json)
+                    state: (0, serialization_1.deserializeChainMonitorState)(this._dec(row.state_json))
                 });
             }
             catch (err) {
@@ -424,7 +531,7 @@ class SqliteStorage {
     savePaymentSecret(paymentHashHex, secret) {
         this.db
             .prepare('INSERT OR REPLACE INTO payment_secrets (payment_hash_hex, secret) VALUES (?, ?)')
-            .run(paymentHashHex, secret.toString('hex'));
+            .run(paymentHashHex, this._enc(secret.toString('hex')));
     }
     loadAllPaymentSecrets() {
         const rows = this.db
@@ -435,7 +542,7 @@ class SqliteStorage {
             try {
                 results.push({
                     paymentHashHex: row.payment_hash_hex,
-                    secret: Buffer.from(row.secret, 'hex')
+                    secret: Buffer.from(this._dec(row.secret), 'hex')
                 });
             }
             catch (err) {
@@ -459,11 +566,12 @@ class SqliteStorage {
             description: invoice.description,
             expiry: invoice.expiry,
             createdAt: invoice.createdAt,
-            hold: invoice.hold
+            hold: invoice.hold,
+            cancelledAt: invoice.cancelledAt
         });
         this.db
             .prepare('INSERT OR REPLACE INTO invoices (payment_hash_hex, invoice_json) VALUES (?, ?)')
-            .run(paymentHashHex, json);
+            .run(paymentHashHex, this._enc(json));
     }
     loadAllInvoices() {
         const rows = this.db
@@ -472,7 +580,7 @@ class SqliteStorage {
         const results = [];
         for (const row of rows) {
             try {
-                const parsed = JSON.parse(row.invoice_json);
+                const parsed = JSON.parse(this._dec(row.invoice_json));
                 results.push({
                     paymentHashHex: row.payment_hash_hex,
                     invoice: {
@@ -484,7 +592,8 @@ class SqliteStorage {
                         description: parsed.description,
                         expiry: parsed.expiry,
                         createdAt: parsed.createdAt,
-                        hold: parsed.hold
+                        hold: parsed.hold,
+                        cancelledAt: parsed.cancelledAt
                     }
                 });
             }
@@ -527,24 +636,33 @@ class SqliteStorage {
     saveChannelKeyIndex(channelId, channelIndex) {
         this.db
             .prepare('INSERT OR REPLACE INTO channel_key_indices (channel_id, channel_index) VALUES (?, ?)')
-            .run(channelId, channelIndex);
+            .run(channelId, this.encryptionKey ? this._enc(String(channelIndex)) : channelIndex);
+    }
+    _decodeChannelIndex(value) {
+        return typeof value === 'number' ? value : Number(this._dec(value));
     }
     loadChannelKeyIndex(channelId) {
         const row = this.db
             .prepare('SELECT channel_index FROM channel_key_indices WHERE channel_id = ?')
             .get(channelId);
-        return row ? row.channel_index : null;
+        return row ? this._decodeChannelIndex(row.channel_index) : null;
     }
     loadNextChannelIndex() {
-        const row = this.db
-            .prepare('SELECT MAX(channel_index) as max_idx FROM channel_key_indices')
-            .get();
-        return row && row.max_idx !== null ? row.max_idx + 1 : 1;
+        const rows = this.db
+            .prepare('SELECT channel_index FROM channel_key_indices')
+            .all();
+        let maxIdx = null;
+        for (const row of rows) {
+            const idx = this._decodeChannelIndex(row.channel_index);
+            if (maxIdx === null || idx > maxIdx)
+                maxIdx = idx;
+        }
+        return maxIdx !== null ? maxIdx + 1 : 1;
     }
     saveHtlcSharedSecret(key, secret) {
         this.db
             .prepare('INSERT OR REPLACE INTO htlc_shared_secrets (key, secret) VALUES (?, ?)')
-            .run(key, secret.toString('hex'));
+            .run(key, this._enc(secret.toString('hex')));
     }
     deleteHtlcSharedSecret(key) {
         this.db.prepare('DELETE FROM htlc_shared_secrets WHERE key = ?').run(key);
@@ -558,7 +676,7 @@ class SqliteStorage {
             try {
                 results.push({
                     key: row.key,
-                    secret: Buffer.from(row.secret, 'hex')
+                    secret: Buffer.from(this._dec(row.secret), 'hex')
                 });
             }
             catch (err) {
@@ -621,6 +739,18 @@ class SqliteStorage {
                 }
             },
             () => {
+            },
+            () => {
+            },
+            () => {
+            },
+            () => {
+            },
+            () => {
+            },
+            () => {
+            },
+            () => {
             }
         ];
         for (let v = currentVersion; v < targetVersion; v++) {
@@ -646,6 +776,198 @@ class SqliteStorage {
             .get(key);
         return row ? row.value : null;
     }
+    saveWalletData(key, value) {
+        this.db
+            .prepare('INSERT OR REPLACE INTO wallet_data (key, value) VALUES (?, ?)')
+            .run(key, this._enc(value));
+    }
+    loadWalletData(key) {
+        const row = this.db
+            .prepare('SELECT value FROM wallet_data WHERE key = ?')
+            .get(key);
+        return row ? this._dec(row.value) : null;
+    }
+    saveChannelPolicy(channelId, policy) {
+        this.db
+            .prepare('INSERT OR REPLACE INTO channel_policies (channel_id, policy_json) VALUES (?, ?)')
+            .run(channelId, JSON.stringify(policy));
+    }
+    loadAllChannelPolicies() {
+        const rows = this.db
+            .prepare('SELECT channel_id, policy_json FROM channel_policies')
+            .all();
+        const results = [];
+        for (const row of rows) {
+            try {
+                results.push({
+                    channelId: row.channel_id,
+                    policy: JSON.parse(row.policy_json)
+                });
+            }
+            catch (err) {
+                this.reportCorruptRow(err);
+            }
+        }
+        return results;
+    }
+    deleteChannelPolicy(channelId) {
+        this.db
+            .prepare('DELETE FROM channel_policies WHERE channel_id = ?')
+            .run(channelId);
+    }
+    savePeerStorageBlob(peerPubkey, blob, receivedAt) {
+        this.db
+            .prepare('INSERT OR REPLACE INTO peer_storage_blobs (peer_pubkey, blob, received_at) VALUES (?, ?, ?)')
+            .run(peerPubkey, this._enc(blob.toString('base64')), receivedAt);
+    }
+    loadPeerStorageBlob(peerPubkey) {
+        const row = this.db
+            .prepare('SELECT blob, received_at FROM peer_storage_blobs WHERE peer_pubkey = ?')
+            .get(peerPubkey);
+        if (!row)
+            return null;
+        return {
+            blob: Buffer.from(this._dec(row.blob), 'base64'),
+            receivedAt: row.received_at
+        };
+    }
+    deletePeerStorageBlob(peerPubkey) {
+        this.db
+            .prepare('DELETE FROM peer_storage_blobs WHERE peer_pubkey = ?')
+            .run(peerPubkey);
+    }
+    saveWatchtowerSession(session, sessionKey) {
+        this.db
+            .prepare(`INSERT OR REPLACE INTO watchtower_sessions
+					(session_id, tower_uri, tower_pubkey, session_key, blob_type,
+					 max_updates, sweep_fee_rate, seq_num, last_applied, created_at)
+				 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(session.sessionId, session.towerUri, session.towerPubkey, this._enc(sessionKey.toString('base64')), session.blobType, session.maxUpdates, session.sweepFeeRate, session.seqNum, session.lastApplied, session.createdAt);
+    }
+    loadWatchtowerSessions() {
+        const rows = this.db
+            .prepare('SELECT * FROM watchtower_sessions')
+            .all();
+        return rows.map((r) => ({
+            sessionId: r.session_id,
+            towerUri: r.tower_uri,
+            towerPubkey: r.tower_pubkey,
+            sessionKey: Buffer.from(this._dec(r.session_key), 'base64'),
+            blobType: r.blob_type,
+            maxUpdates: r.max_updates,
+            sweepFeeRate: r.sweep_fee_rate,
+            seqNum: r.seq_num,
+            lastApplied: r.last_applied,
+            createdAt: r.created_at
+        }));
+    }
+    setWatchtowerSessionProgress(sessionId, seqNum, lastApplied) {
+        this.db
+            .prepare('UPDATE watchtower_sessions SET seq_num = ?, last_applied = ? WHERE session_id = ?')
+            .run(seqNum, lastApplied, sessionId);
+    }
+    deleteWatchtowerTower(towerUri) {
+        this.db.transaction(() => {
+            this.db
+                .prepare('DELETE FROM watchtower_sessions WHERE tower_uri = ?')
+                .run(towerUri);
+            this.db
+                .prepare('DELETE FROM watchtower_updates WHERE tower_uri = ?')
+                .run(towerUri);
+        })();
+    }
+    addWatchtowerUpdate(update) {
+        const info = this.db
+            .prepare(`INSERT INTO watchtower_updates
+					(tower_uri, channel_id, hint, encrypted_blob, seq_num, acked, created_at)
+				 VALUES (?, ?, ?, ?, ?, ?, ?)`)
+            .run(update.towerUri, update.channelId, update.hint, this._enc(update.encryptedBlob), update.seqNum, update.acked ? 1 : 0, update.createdAt);
+        return Number(info.lastInsertRowid);
+    }
+    loadPendingWatchtowerUpdates() {
+        const rows = this.db
+            .prepare('SELECT * FROM watchtower_updates WHERE acked = 0 ORDER BY id ASC')
+            .all();
+        return rows.map((r) => ({
+            id: r.id,
+            towerUri: r.tower_uri,
+            channelId: r.channel_id,
+            hint: r.hint,
+            encryptedBlob: this._dec(r.encrypted_blob),
+            seqNum: r.seq_num,
+            acked: r.acked === 1,
+            createdAt: r.created_at
+        }));
+    }
+    markWatchtowerUpdateAcked(id, seqNum) {
+        this.db
+            .prepare('UPDATE watchtower_updates SET acked = 1, seq_num = ? WHERE id = ?')
+            .run(seqNum, id);
+    }
+    saveForwardingEvent(event) {
+        this.db
+            .prepare(`INSERT INTO forwarding_events
+					(settled_at, in_channel_id, out_channel_id, in_scid, out_scid,
+					 amount_in_msat, amount_out_msat, fee_msat)
+				 VALUES (?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(event.settledAt, event.inChannelId, event.outChannelId, event.inScid ?? null, event.outScid ?? null, event.amountInMsat.toString(), event.amountOutMsat.toString(), event.feeMsat.toString());
+        this.db
+            .prepare('DELETE FROM forwarding_events WHERE id NOT IN (SELECT id FROM forwarding_events ORDER BY id DESC LIMIT ?)')
+            .run(this.forwardingEventsMaxRows);
+    }
+    listForwardingEvents(filter) {
+        let sql = 'SELECT id, settled_at, in_channel_id, out_channel_id, in_scid, out_scid, amount_in_msat, amount_out_msat, fee_msat FROM forwarding_events WHERE 1=1';
+        const params = [];
+        if (filter?.since !== undefined) {
+            sql += ' AND settled_at >= ?';
+            params.push(filter.since);
+        }
+        if (filter?.until !== undefined) {
+            sql += ' AND settled_at <= ?';
+            params.push(filter.until);
+        }
+        if (filter?.channelId !== undefined) {
+            sql += ' AND (in_channel_id = ? OR out_channel_id = ?)';
+            params.push(filter.channelId, filter.channelId);
+        }
+        sql += ' ORDER BY settled_at DESC, id DESC';
+        sql += ' LIMIT ?';
+        params.push(filter?.limit !== undefined && filter.limit > 0 ? filter.limit : 1000);
+        if (filter?.offset !== undefined && filter.offset > 0) {
+            sql += ' OFFSET ?';
+            params.push(filter.offset);
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map((row) => ({
+            id: row.id,
+            settledAt: row.settled_at,
+            inChannelId: row.in_channel_id,
+            outChannelId: row.out_channel_id,
+            inScid: row.in_scid ?? undefined,
+            outScid: row.out_scid ?? undefined,
+            amountInMsat: BigInt(row.amount_in_msat),
+            amountOutMsat: BigInt(row.amount_out_msat),
+            feeMsat: BigInt(row.fee_msat)
+        }));
+    }
+    getForwardingSummary(options) {
+        let sql = 'SELECT amount_out_msat, fee_msat FROM forwarding_events WHERE 1=1';
+        const params = [];
+        if (options?.since !== undefined) {
+            sql += ' AND settled_at >= ?';
+            params.push(options.since);
+        }
+        let count = 0;
+        let volumeOutMsat = 0n;
+        let feesEarnedMsat = 0n;
+        for (const row of this.db.prepare(sql).iterate(...params)) {
+            const r = row;
+            count++;
+            volumeOutMsat += BigInt(r.amount_out_msat);
+            feesEarnedMsat += BigInt(r.fee_msat);
+        }
+        return { count, volumeOutMsat, feesEarnedMsat };
+    }
     transaction(fn) {
         return this.db.transaction(fn)();
     }
@@ -713,5 +1035,37 @@ class SqliteStorage {
     }
 }
 exports.SqliteStorage = SqliteStorage;
-SqliteStorage.CURRENT_SCHEMA_VERSION = 2;
+SqliteStorage.CURRENT_SCHEMA_VERSION = 8;
+SqliteStorage.ENCRYPTED_COLUMNS = [
+    { table: 'channels', pk: 'channel_id', columns: ['state_json'] },
+    { table: 'payments', pk: 'payment_hash', columns: ['payment_json'] },
+    { table: 'preimages', pk: 'payment_hash', columns: ['preimage'] },
+    {
+        table: 'htlc_payment_map',
+        pk: 'htlc_key',
+        columns: ['payment_hash_hex']
+    },
+    {
+        table: 'forwarded_htlcs',
+        pk: 'out_key',
+        columns: ['in_channel_id', 'in_htlc_id']
+    },
+    { table: 'chain_monitors', pk: 'channel_id', columns: ['state_json'] },
+    { table: 'payment_secrets', pk: 'payment_hash_hex', columns: ['secret'] },
+    { table: 'htlc_shared_secrets', pk: 'key', columns: ['secret'] },
+    { table: 'invoices', pk: 'payment_hash_hex', columns: ['invoice_json'] },
+    {
+        table: 'channel_key_indices',
+        pk: 'channel_id',
+        columns: ['channel_index']
+    },
+    { table: 'peer_storage_blobs', pk: 'peer_pubkey', columns: ['blob'] },
+    {
+        table: 'watchtower_sessions',
+        pk: 'session_id',
+        columns: ['session_key']
+    },
+    { table: 'watchtower_updates', pk: 'id', columns: ['encrypted_blob'] },
+    { table: 'wallet_data', pk: 'key', columns: ['value'] }
+];
 //# sourceMappingURL=sqlite-storage.js.map