beignet 0.2.0 → 0.4.0

package/dist/cli/daemon.js

@@ -23,16 +23,20 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.startDaemon = exports.parseBody = void 0;
+exports.startDaemon = exports.getRelayedEvents = exports.AUTH_EXEMPT_ROUTES = exports.parseBody = void 0;
 const http = __importStar(require("http"));
 const https = __importStar(require("https"));
 const fs = __importStar(require("fs"));
+const console_1 = require("console");
 const beignet_node_1 = require("./beignet-node");
+const logger_1 = require("../logger");
 const errors_1 = require("./errors");
 const openapi_1 = require("./openapi");
 const webhooks_1 = require("./webhooks");
 const payment_queue_1 = require("./payment-queue");
 const http_rate_limiter_1 = require("./http-rate-limiter");
+const transaction_1 = require("../utils/transaction");
+const auth_1 = require("./auth");
 const MAX_BODY_BYTES = 1048576;
 const IDEMPOTENCY_TTL_MS = 24 * 60 * 60 * 1000;
 const IDEMPOTENCY_CLEANUP_INTERVAL_MS = 10 * 60 * 1000;
@@ -42,7 +46,9 @@ const IDEMPOTENT_ROUTES = new Set([
     'POST /invoice/pay-async',
     'POST /invoice/pay-retry',
     'POST /keysend',
-    'POST /keysend/safe'
+    'POST /keysend/safe',
+    'POST /rebalance',
+    'POST /advisor/execute-rebalances'
 ]);
 function success(result) {
     return { ok: true, result };
@@ -50,6 +56,11 @@ function success(result) {
 function failure(code, message) {
     return { ok: false, error: { code, message } };
 }
+function insufficientScopeMessage(auth, routeKey) {
+    const accepted = [...(0, auth_1.getRouteScopes)(routeKey), 'admin'].join(', ');
+    const who = auth.keyName === null ? 'API key' : `API key "${auth.keyName}"`;
+    return `${who} lacks the required scope (accepted: ${accepted})`;
+}
 async function parseBody(req) {
     return new Promise((resolve, reject) => {
         const chunks = [];
@@ -81,28 +92,48 @@ async function parseBody(req) {
     });
 }
 exports.parseBody = parseBody;
-function checkAuth(req, apiToken) {
-    const header = req.headers['authorization'];
-    if (!header)
-        return false;
-    const match = header.match(/^bearer\s+(.+)$/i);
-    if (!match)
-        return false;
-    return match[1] === apiToken;
-}
-const AUTH_EXEMPT_ROUTES = new Set([
+exports.AUTH_EXEMPT_ROUTES = new Set([
     'GET /health',
     'GET /ready',
     'GET /openapi.json',
     'GET /metrics'
 ]);
+function getRelayedEvents(htlcEvents) {
+    const events = [
+        'payment:received',
+        'payment:sent',
+        'payment:failed',
+        'invoice:settled',
+        'channel:opening',
+        'channel:ready',
+        'channel:pending-close',
+        'channel:force-closing',
+        'channel:closed',
+        'peer:connect',
+        'peer:disconnect',
+        'node:ready'
+    ];
+    if (htlcEvents === true) {
+        events.push('htlc:forwarded', 'htlc:fulfilled', 'htlc:failed');
+    }
+    return events;
+}
+exports.getRelayedEvents = getRelayedEvents;
 async function startDaemon(opts) {
     const port = opts.daemonPort !== undefined && opts.daemonPort !== null
         ? opts.daemonPort
         : 2112;
     const host = opts.daemonHost || '127.0.0.1';
-    const apiToken = opts.apiToken;
-    const node = await beignet_node_1.BeignetNode.create(opts);
+    const authenticator = new auth_1.ApiKeyAuthenticator(opts.apiToken, opts.apiKeys);
+    let logger = opts.logger;
+    if (!logger && opts.logLevel && opts.logLevel !== 'silent') {
+        const stderrConsole = new console_1.Console({
+            stdout: process.stderr,
+            stderr: process.stderr
+        });
+        logger = (0, logger_1.createConsoleLogger)(opts.logLevel, stderrConsole);
+    }
+    const node = await beignet_node_1.BeignetNode.create(logger ? { ...opts, logger } : opts);
     const storage = node.getStorage();
     const webhookManager = new webhooks_1.WebhookManager(storage);
     const paymentQueue = new payment_queue_1.PaymentQueue((bolt11, timeout, maxFee, amount, meta) => node.payInvoiceSafe(bolt11, timeout, maxFee, amount, meta), (amount) => node.canSend(amount), undefined, storage);
@@ -122,8 +153,8 @@ async function startDaemon(opts) {
     const routes = {
         'GET /info': () => success(node.getInfo()),
         'GET /mnemonic': () => {
-            if (!apiToken) {
-                return failure('MNEMONIC_REQUIRES_AUTH', 'Configure apiToken to enable mnemonic access');
+            if (!authenticator.enabled) {
+                return failure('MNEMONIC_REQUIRES_AUTH', 'Configure apiToken or apiKeys to enable mnemonic access');
             }
             return success({ mnemonic: node.getMnemonic() });
         },
@@ -148,6 +179,24 @@ async function startDaemon(opts) {
                 filter.metadataValue = query.get('metadataValue');
             return success(node.listPayments(Object.keys(filter).length > 0 ? filter : undefined));
         },
+        'GET /forwards': (_body, query) => {
+            const filter = {};
+            if (query.get('since'))
+                filter.since = Number(query.get('since'));
+            if (query.get('until'))
+                filter.until = Number(query.get('until'));
+            if (query.get('limit'))
+                filter.limit = Number(query.get('limit'));
+            if (query.get('offset'))
+                filter.offset = Number(query.get('offset'));
+            if (query.get('channelId'))
+                filter.channelId = query.get('channelId');
+            return success(node.listForwards(Object.keys(filter).length > 0 ? filter : undefined));
+        },
+        'GET /forwards/summary': (_body, query) => {
+            const since = query.get('since') ? Number(query.get('since')) : undefined;
+            return success(node.getForwardingSummary(since));
+        },
         'GET /invoices': () => success(node.listInvoices()),
         'GET /invoice': (_body, query) => {
             const paymentHash = query.get('paymentHash');
@@ -170,6 +219,41 @@ async function startDaemon(opts) {
         },
         'GET /spend-limit': () => success(node.getDailySpendInfo()),
         'GET /liquidity': () => success(node.getLiquiditySnapshot()),
+        'GET /watchtowers': () => success({ towers: node.listWatchtowers() }),
+        'POST /watchtower/add': (body) => {
+            const { uri } = body;
+            if (!uri)
+                return failure('INVALID_PARAMS', 'uri required');
+            try {
+                node.addWatchtower(uri);
+            }
+            catch (err) {
+                return failure('INVALID_PARAMS', err instanceof Error ? err.message : String(err));
+            }
+            return success({ added: uri });
+        },
+        'DELETE /watchtower/remove': (body) => {
+            const { uri } = body;
+            if (!uri)
+                return failure('INVALID_PARAMS', 'uri required');
+            node.removeWatchtower(uri);
+            return success({ removed: uri });
+        },
+        'GET /advisor/recommendations': () => success(node.getAdvisorRecommendations()),
+        'POST /advisor/execute-rebalances': async (body) => {
+            const { budgetSatsPerDay } = body;
+            return success(await node.executeRebalances(budgetSatsPerDay));
+        },
+        'POST /rebalance': async (body) => {
+            const { fromChannelId, toChannelId, amountSats, maxFeeSats } = body;
+            if (!fromChannelId ||
+                !toChannelId ||
+                amountSats === undefined ||
+                maxFeeSats === undefined) {
+                return failure('INVALID_PARAMS', 'fromChannelId, toChannelId, amountSats, and maxFeeSats required');
+            }
+            return success(await node.rebalanceChannel(fromChannelId, toChannelId, amountSats, maxFeeSats));
+        },
         'GET /fees': () => {
             const snapshot = node.getFeeSnapshot();
             if (!snapshot)
@@ -189,6 +273,26 @@ async function startDaemon(opts) {
             return success(txs);
         },
         'GET /utxos': () => success(node.listUtxos()),
+        'POST /utxo/freeze': async (body) => {
+            const { txid, index } = body;
+            if (!txid || index === undefined)
+                return failure('INVALID_PARAMS', 'txid and index required');
+            return success(await node.freezeUtxo(txid, index));
+        },
+        'POST /utxo/unfreeze': async (body) => {
+            const { txid, index } = body;
+            if (!txid || index === undefined)
+                return failure('INVALID_PARAMS', 'txid and index required');
+            return success(await node.unfreezeUtxo(txid, index));
+        },
+        'POST /address/label': async (body) => {
+            const { address, label } = body;
+            if (!address || label === undefined)
+                return failure('INVALID_PARAMS', 'address and label required (empty label clears)');
+            return success(await node.setAddressLabel(address, label));
+        },
+        'GET /address/labels': () => success(node.listAddressLabels()),
+        'GET /wallet/descriptors': () => success(node.exportDescriptors()),
         'GET /channel/suggestions': (_body, query) => {
             const count = query.get('count') ? Number(query.get('count')) : undefined;
             return success(node.getChannelSuggestions(count));
@@ -203,7 +307,16 @@ async function startDaemon(opts) {
                 options.limit = Number(query.get('limit'));
             return success(node.getActionLog(Object.keys(options).length > 0 ? options : undefined));
         },
-        'POST /address/new': async () => success({ address: await node.getNewAddress() }),
+        'POST /address/new': async (body) => {
+            const { bip21: wantBip21, amountSats, label, message } = (body ?? {});
+            const address = await node.getNewAddress();
+            if (!wantBip21)
+                return success({ address });
+            const uri = (0, transaction_1.encodeBip21)({ address, amountSats, label, message });
+            if (uri.isErr())
+                return failure('INVALID_PARAMS', uri.error.message);
+            return success({ address, bip21: uri.value });
+        },
         'POST /wallet/refresh': async () => {
             await node.refreshWallet();
             return success({ refreshed: true });
@@ -214,10 +327,53 @@ async function startDaemon(opts) {
                 return failure('INVALID_PARAMS', 'address and amountSats required');
             return success(await node.sendOnchain(address, amountSats, satsPerVbyte));
         },
+        'POST /send-max': async (body) => {
+            const { address, satsPerVbyte } = body;
+            if (!address)
+                return failure('INVALID_PARAMS', 'address required');
+            return success(await node.sendMaxOnchain(address, satsPerVbyte));
+        },
+        'POST /tx/bump-fee': async (body) => {
+            const { txid, satsPerVbyte } = body;
+            if (!txid || satsPerVbyte === undefined)
+                return failure('INVALID_PARAMS', 'txid and satsPerVbyte required');
+            return success(await node.bumpFeeOnchain(txid, satsPerVbyte));
+        },
+        'POST /tx/boost': async (body) => {
+            const { txid, satsPerVbyte } = body;
+            if (!txid)
+                return failure('INVALID_PARAMS', 'txid required');
+            return success(await node.boostOnchain(txid, satsPerVbyte));
+        },
+        'GET /transactions/boostable': () => success(node.listBoostableTransactions()),
+        'POST /consolidate': async (body) => {
+            const { satsPerVbyte } = body;
+            return success(await node.consolidateUtxos(satsPerVbyte));
+        },
+        'POST /psbt/build': async (body) => {
+            const { outputs, satsPerVbyte } = body;
+            if (!outputs || !Array.isArray(outputs) || outputs.length === 0)
+                return failure('INVALID_PARAMS', 'outputs array of { address, amountSats } required');
+            return success(await node.buildPsbt(outputs, satsPerVbyte));
+        },
+        'POST /psbt/import-signed': (body) => {
+            const { psbtBase64 } = body;
+            if (!psbtBase64)
+                return failure('INVALID_PARAMS', 'psbtBase64 required');
+            return success(node.importSignedPsbt(psbtBase64));
+        },
+        'POST /psbt/combine': (body) => {
+            const { psbts } = body;
+            if (!psbts || !Array.isArray(psbts) || psbts.length < 2)
+                return failure('INVALID_PARAMS', 'psbts array with at least two base64 PSBTs required');
+            return success(node.combinePsbts(psbts));
+        },
         'POST /peer/connect': async (body) => {
             const { pubkey, host: peerHost, port: peerPort } = body;
-            if (!pubkey || !peerHost || !peerPort)
-                return failure('INVALID_PARAMS', 'pubkey, host, and port required');
+            if (!pubkey)
+                return failure('INVALID_PARAMS', 'pubkey required');
+            if ((peerHost === undefined) !== (peerPort === undefined))
+                return failure('INVALID_PARAMS', 'host and port must be provided together (omit both to resolve by node id)');
             return success(await node.connectPeer(pubkey, peerHost, peerPort));
         },
         'POST /peer/disconnect': (body) => {
@@ -254,7 +410,7 @@ async function startDaemon(opts) {
                 commitmentTxid: result.commitmentTxid
             });
         },
-        'POST /channel/update-fee': (body) => {
+        'POST /channel/update-commitment-feerate': (body) => {
             const { channelId, feeratePerKw } = body;
             if (!channelId)
                 return failure('INVALID_PARAMS', 'channelId required');
@@ -262,6 +418,32 @@ async function startDaemon(opts) {
                 return failure('INVALID_PARAMS', 'feeratePerKw required');
             return success(node.updateChannelFee(channelId, feeratePerKw));
         },
+        'POST /channel/update-policy': (body) => {
+            const { channelId, all, feeBaseMsat, feeProportionalMillionths, cltvExpiryDelta, htlcMinimumMsat, htlcMaximumMsat } = body;
+            if (!channelId && all !== true)
+                return failure('INVALID_PARAMS', 'channelId or all:true required');
+            try {
+                return success(node.updateChannelPolicy(all === true ? 'all' : channelId, {
+                    feeBaseMsat,
+                    feeProportionalMillionths,
+                    cltvExpiryDelta,
+                    htlcMinimumMsat,
+                    htlcMaximumMsat
+                }));
+            }
+            catch (err) {
+                return failure('INVALID_PARAMS', err.message);
+            }
+        },
+        'GET /channel/policy': (body, query) => {
+            const channelId = query.get('channelId') || body.channelId;
+            if (!channelId)
+                return failure('INVALID_PARAMS', 'channelId required');
+            const policy = node.getChannelPolicy(channelId);
+            if (!policy)
+                return failure('NOT_FOUND', 'Channel not found');
+            return success(policy);
+        },
         'GET /channel': (body, query) => {
             const channelId = query.get('channelId') || body.channelId;
             if (!channelId)
@@ -306,6 +488,40 @@ async function startDaemon(opts) {
                 : undefined;
             return success(node.createInvoice(amountSats, description, expirySecs, hashBuf));
         },
+        'POST /invoice/create-hold': (body) => {
+            const { paymentHash, amountMsat, amountSats, description, expiry } = body;
+            if (!paymentHash)
+                return failure('INVALID_PARAMS', 'paymentHash required');
+            let amountMsatBig;
+            if (amountMsat !== undefined) {
+                try {
+                    amountMsatBig = BigInt(amountMsat);
+                }
+                catch {
+                    return failure('INVALID_PARAMS', 'amountMsat must be an integer');
+                }
+            }
+            return success(node.createHoldInvoice({
+                paymentHash,
+                amountMsat: amountMsatBig,
+                amountSats,
+                description,
+                expiry
+            }));
+        },
+        'POST /invoice/settle-hold': (body) => {
+            const { preimage } = body;
+            if (!preimage)
+                return failure('INVALID_PARAMS', 'preimage required');
+            return success(node.settleHoldInvoice(preimage));
+        },
+        'POST /invoice/cancel-hold': (body) => {
+            const { paymentHash } = body;
+            if (!paymentHash)
+                return failure('INVALID_PARAMS', 'paymentHash required');
+            return success(node.cancelHoldInvoice(paymentHash));
+        },
+        'GET /invoices/held': () => success(node.listHoldInvoices()),
         'POST /invoice/decode': (body) => {
             const { bolt11 } = body;
             if (!bolt11)
@@ -525,6 +741,101 @@ async function startDaemon(opts) {
                 return failure('INVALID_PARAMS', 'destination and amountSats required');
             return success(node.probeRoute(destination, amountSats));
         },
+        'GET /graph/info': () => success(node.getGraphInfo()),
+        'GET /graph/node': (_body, query) => {
+            const pubkey = query.get('pubkey');
+            if (!pubkey)
+                return failure('INVALID_PARAMS', 'pubkey required');
+            const info = node.getGraphNode(pubkey);
+            if (!info)
+                return failure('NOT_FOUND', 'Node not found in graph');
+            return success(info);
+        },
+        'GET /graph/channel': (_body, query) => {
+            const scid = query.get('scid');
+            if (!scid)
+                return failure('INVALID_PARAMS', 'scid required');
+            const info = node.getGraphChannel(scid);
+            if (!info)
+                return failure('NOT_FOUND', 'Channel not found in graph');
+            return success(info);
+        },
+        'GET /graph/describe': (_body, query) => {
+            const limitParam = query.get('limit');
+            const offsetParam = query.get('offset');
+            let limit;
+            let offset;
+            if (limitParam !== null) {
+                limit = Number(limitParam);
+                if (!Number.isInteger(limit) || limit < 1)
+                    return failure('INVALID_PARAMS', 'limit must be a positive integer');
+            }
+            if (offsetParam !== null) {
+                offset = Number(offsetParam);
+                if (!Number.isInteger(offset) || offset < 0)
+                    return failure('INVALID_PARAMS', 'offset must be a non-negative integer');
+            }
+            return success(node.describeGraph(limit, offset));
+        },
+        'POST /route/query': (body) => {
+            const { destination, amountSats, maxFeeSats } = body;
+            if (!destination || amountSats === undefined)
+                return failure('INVALID_PARAMS', 'destination and amountSats required');
+            return success(node.queryRoute(destination, amountSats, maxFeeSats));
+        },
+        'POST /payment/send-to-route': (body) => {
+            const { paymentHash, route, paymentSecret } = body;
+            if (!paymentHash || !route)
+                return failure('INVALID_PARAMS', 'paymentHash and route required');
+            return success(node.sendToRoute(paymentHash, route, paymentSecret));
+        },
+        'POST /message/sign': (body) => {
+            const { message } = body;
+            if (!message)
+                return failure('INVALID_PARAMS', 'message required');
+            return success(node.signMessage(message));
+        },
+        'POST /message/verify': (body) => {
+            const { message, signature } = body;
+            if (!message || !signature)
+                return failure('INVALID_PARAMS', 'message and signature required');
+            return success(node.verifyMessage(message, signature));
+        },
+        'POST /gossip/sync': (body) => {
+            const { pubkey } = body;
+            return success({ syncedFrom: node.syncGossip(pubkey) });
+        },
+        'POST /gossip/sync-rapid': async () => {
+            const result = await node.syncRapidGossip();
+            if (!result) {
+                return failure('INVALID_PARAMS', 'Rapid gossip sync is only available on mainnet');
+            }
+            return success(result);
+        },
+        'GET /channel/diagnostics': (body, query) => {
+            const channelId = query.get('channelId') || body.channelId;
+            if (!channelId)
+                return failure('INVALID_PARAMS', 'channelId required');
+            const diagnostics = node.getChannelDiagnostics(channelId);
+            if (!diagnostics)
+                return failure('NOT_FOUND', 'Channel not found');
+            return success(diagnostics);
+        },
+        'POST /address/validate': (body) => {
+            const { address } = body;
+            if (!address)
+                return failure('INVALID_PARAMS', 'address required');
+            return success({ address, valid: node.validateAddress(address) });
+        },
+        'POST /recover-fallback-funds': async (body) => {
+            const { feeRatePerVbyte } = body;
+            const result = await node.recoverFallbackFunds(feeRatePerVbyte !== undefined ? { feeRatePerVbyte } : undefined);
+            return success(result ?? { recovered: false });
+        },
+        'POST /backup/trigger': () => {
+            node.triggerBackup();
+            return success({ triggered: true });
+        },
         'POST /backup': async (body) => {
             const { destPath } = body;
             if (!destPath)
@@ -537,6 +848,35 @@ async function startDaemon(opts) {
             await node.backup(destPath);
             return success({ backed_up: true });
         },
+        'GET /backup/scb': () => success(node.exportStaticChannelBackup()),
+        'GET /backup/peer-retrieved': () => {
+            const retrieved = node.getPeerRetrievedBackup();
+            if (!retrieved) {
+                return failure('NOT_FOUND', 'No peer-retrieved backup this session (no capable peer has returned our SCB yet)');
+            }
+            return success(retrieved);
+        },
+        'POST /restore/scb': async (body) => {
+            const { encoded, path: scbPath } = body;
+            if ((encoded ? 1 : 0) + (scbPath ? 1 : 0) !== 1) {
+                return failure('INVALID_PARAMS', 'Provide exactly one of encoded or path');
+            }
+            let blob = encoded;
+            if (scbPath) {
+                if (scbPath.includes('..') ||
+                    scbPath.includes('%2e%2e') ||
+                    scbPath.includes('%2E%2E')) {
+                    return failure('INVALID_PARAMS', 'Path traversal not allowed');
+                }
+                try {
+                    blob = fs.readFileSync(scbPath, 'utf8');
+                }
+                catch (err) {
+                    return failure('INVALID_PARAMS', `Cannot read SCB file: ${err.message}`);
+                }
+            }
+            return success(await node.restoreFromScb(blob));
+        },
         'POST /offer/create': (body) => {
             const { description, amountSats, issuer } = body;
             if (!description)
@@ -586,8 +926,20 @@ async function startDaemon(opts) {
             if (!cancelled)
                 return failure('NOT_FOUND', 'Queued payment not found or already processing');
             return success({ cancelled: true });
+        },
+        'GET /auth/keys': () => success({ keys: authenticator.listKeys() }),
+        'POST /auth/keys/revoke': (body) => {
+            const { name } = body;
+            if (!name)
+                return failure('INVALID_PARAMS', 'name required');
+            const revoked = authenticator.revoke(name);
+            if (!revoked)
+                return failure('NOT_FOUND', `No API key named "${name}" (the legacy apiToken has no name; remove it from the config and restart)`);
+            return success({ revoked: name });
         }
     };
+    routes['POST /channel/update-fee'] =
+        routes['POST /channel/update-commitment-feerate'];
     const sseClients = new Set();
     const corsOrigin = opts.cors === true ? '*' : typeof opts.cors === 'string' ? opts.cors : null;
     if (opts.tlsCert && !opts.tlsKey) {
@@ -616,11 +968,20 @@ async function startDaemon(opts) {
             return;
         }
         if (routeKey === 'GET /events') {
-            if (apiToken && !checkAuth(req, apiToken)) {
-                res.setHeader('Content-Type', 'application/json');
-                res.statusCode = 401;
-                res.end(JSON.stringify(failure('UNAUTHORIZED', 'Invalid or missing Authorization header')));
-                return;
+            if (authenticator.enabled) {
+                const auth = authenticator.authenticate(req.headers['authorization']);
+                if (!auth.ok) {
+                    res.setHeader('Content-Type', 'application/json');
+                    res.statusCode = 401;
+                    res.end(JSON.stringify(failure('UNAUTHORIZED', 'Invalid or missing Authorization header')));
+                    return;
+                }
+                if (!(0, auth_1.scopesAllowRoute)(auth.scopes, routeKey)) {
+                    res.setHeader('Content-Type', 'application/json');
+                    res.statusCode = 403;
+                    res.end(JSON.stringify(failure('FORBIDDEN', insufficientScopeMessage(auth, routeKey))));
+                    return;
+                }
             }
             const sseHeaders = {
                 'Content-Type': 'text/event-stream',
@@ -634,6 +995,7 @@ async function startDaemon(opts) {
                     'Content-Type, Authorization';
             }
             res.writeHead(200, sseHeaders);
+            res.write(': connected\n\n');
             sseClients.add(res);
             const keepalive = setInterval(() => {
                 res.write(': keepalive\n\n');
@@ -650,14 +1012,20 @@ async function startDaemon(opts) {
             return;
         }
         res.setHeader('Content-Type', 'application/json');
-        if (apiToken && !AUTH_EXEMPT_ROUTES.has(routeKey)) {
-            if (!checkAuth(req, apiToken)) {
+        if (authenticator.enabled && !exports.AUTH_EXEMPT_ROUTES.has(routeKey)) {
+            const auth = authenticator.authenticate(req.headers['authorization']);
+            if (!auth.ok) {
                 res.statusCode = 401;
                 res.end(JSON.stringify(failure('UNAUTHORIZED', 'Invalid or missing Authorization header')));
                 return;
             }
+            if (!(0, auth_1.scopesAllowRoute)(auth.scopes, routeKey)) {
+                res.statusCode = 403;
+                res.end(JSON.stringify(failure('FORBIDDEN', insufficientScopeMessage(auth, routeKey))));
+                return;
+            }
         }
-        if (rateLimiter && !AUTH_EXEMPT_ROUTES.has(routeKey)) {
+        if (rateLimiter && !exports.AUTH_EXEMPT_ROUTES.has(routeKey)) {
             const clientKey = req.headers['authorization'] || req.socket.remoteAddress || 'unknown';
             if (!rateLimiter.isAllowed(clientKey)) {
                 res.statusCode = 429;
@@ -747,16 +1115,7 @@ async function startDaemon(opts) {
     else {
         server = http.createServer(requestHandler);
     }
-    const sseEvents = [
-        'payment:received',
-        'payment:sent',
-        'payment:failed',
-        'channel:ready',
-        'channel:closed',
-        'peer:connect',
-        'peer:disconnect',
-        'node:ready'
-    ];
+    const sseEvents = getRelayedEvents(opts.htlcEvents);
     for (const eventName of sseEvents) {
         node.on(eventName, (data) => {
             if (sseClients.size === 0)
@@ -775,6 +1134,7 @@ async function startDaemon(opts) {
     return new Promise((resolve, reject) => {
         server.on('error', reject);
         server.listen(port, host, () => {
+            logger?.info(`Daemon listening on ${host}:${port}`);
             resolve({ server, node });
         });
     });