beignet 0.2.0 → 0.4.0

package/dist/cli/cli.js

@@ -25,9 +25,14 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const http = __importStar(require("http"));
+const fs = __importStar(require("fs"));
+const nodePath = __importStar(require("path"));
 const helpers_1 = require("../utils/helpers");
 const config_1 = require("./config");
 const daemon_1 = require("./daemon");
+const beignet_node_1 = require("./beignet-node");
+const restore_1 = require("./restore");
+const instance_lock_1 = require("./instance-lock");
 const args = process.argv.slice(2);
 const pretty = args.includes('--pretty');
 const filteredArgs = args.filter((a) => a !== '--pretty');
@@ -44,12 +49,22 @@ function parseFlag(name) {
 function hasFlag(name) {
     return filteredArgs.includes(name);
 }
+function parseRepeatedFlag(name) {
+    const out = [];
+    for (let i = 0; i < filteredArgs.length - 1; i++) {
+        if (filteredArgs[i] === name)
+            out.push(filteredArgs[i + 1]);
+    }
+    return out;
+}
 function getApiToken() {
-    const flagToken = parseFlag('--api-token');
+    const flagToken = parseFlag('--api-token') || parseFlag('--api-key');
     if (flagToken)
         return flagToken;
     if (process.env.BEIGNET_API_TOKEN)
         return process.env.BEIGNET_API_TOKEN;
+    if (process.env.BEIGNET_API_KEY)
+        return process.env.BEIGNET_API_KEY;
     const config = (0, config_1.loadConfig)();
     return config.apiToken;
 }
@@ -118,9 +133,36 @@ async function main() {
                 : '/transactions'));
         case 'utxos':
             return outputResult(await httpRequest('GET', '/utxos'));
+        case 'utxo':
+            return handleUtxo();
         case 'fee-estimates':
             return outputResult(await httpRequest('GET', '/fees/estimates'));
         case 'address':
+            if (filteredArgs[1] === 'validate') {
+                return outputResult(await httpRequest('POST', '/address/validate', {
+                    address: filteredArgs[2]
+                }));
+            }
+            if (filteredArgs[1] === 'label') {
+                return outputResult(await httpRequest('POST', '/address/label', {
+                    address: filteredArgs[2],
+                    label: filteredArgs.slice(3).join(' ')
+                }));
+            }
+            if (filteredArgs[1] === 'labels') {
+                return outputResult(await httpRequest('GET', '/address/labels'));
+            }
+            if (hasFlag('--bip21')) {
+                const amountFlag = parseFlag('--amount');
+                const labelFlag = parseFlag('--label');
+                const messageFlag = parseFlag('--message');
+                return outputResult(await httpRequest('POST', '/address/new', {
+                    bip21: true,
+                    ...(amountFlag ? { amountSats: parseInt(amountFlag, 10) } : {}),
+                    ...(labelFlag ? { label: labelFlag } : {}),
+                    ...(messageFlag ? { message: messageFlag } : {})
+                }));
+            }
             return outputResult(await httpRequest('POST', '/address/new'));
         case 'mnemonic':
             return outputResult(await httpRequest('GET', '/mnemonic'));
@@ -129,6 +171,23 @@ async function main() {
                 address: filteredArgs[1],
                 amountSats: parseInt(filteredArgs[2], 10)
             }));
+        case 'send-max':
+            return outputResult(await httpRequest('POST', '/send-max', {
+                address: filteredArgs[1],
+                satsPerVbyte: filteredArgs[2]
+                    ? parseInt(filteredArgs[2], 10)
+                    : undefined
+            }));
+        case 'tx':
+            return handleTx();
+        case 'psbt':
+            return handlePsbt();
+        case 'consolidate':
+            return outputResult(await httpRequest('POST', '/consolidate', {
+                satsPerVbyte: filteredArgs[1]
+                    ? parseInt(filteredArgs[1], 10)
+                    : undefined
+            }));
         case 'peer':
             return handlePeer();
         case 'channel':
@@ -137,6 +196,30 @@ async function main() {
             return handleInvoice();
         case 'payment':
             return handlePayment();
+        case 'keysend':
+            return handleKeysend();
+        case 'forwards':
+            return handleForwards();
+        case 'graph':
+            return handleGraph();
+        case 'gossip':
+            return handleGossip();
+        case 'message':
+            return handleMessage();
+        case 'recover-fallback-funds':
+            return outputResult(await httpRequest('POST', '/recover-fallback-funds', {
+                feeRatePerVbyte: parseFlag('--fee-rate')
+                    ? parseInt(parseFlag('--fee-rate'), 10)
+                    : undefined
+            }));
+        case 'watchtower':
+            return handleWatchtower();
+        case 'route':
+            return handleRoute();
+        case 'rebalance':
+            return handleRebalance();
+        case 'advisor':
+            return handleAdvisor();
         case 'bootstrap':
             return handleBootstrap();
         case 'trusted-peer':
@@ -145,16 +228,40 @@ async function main() {
             return handleOffer();
         case 'health':
             return outputResult(await httpRequest('GET', '/health'));
+        case 'ready':
+            return outputResult(await httpRequest('GET', '/ready'));
         case 'readiness':
             return outputResult(await httpRequest('GET', '/readiness'));
         case 'metrics':
             return handleMetrics();
         case 'stats':
             return outputResult(await httpRequest('GET', filteredArgs[1] ? `/stats?window=${filteredArgs[1]}` : '/stats'));
+        case 'liquidity':
+            return outputResult(await httpRequest('GET', '/liquidity'));
+        case 'fees':
+            return outputResult(await httpRequest('GET', '/fees'));
+        case 'spend-limit':
+            return outputResult(await httpRequest('GET', '/spend-limit'));
+        case 'logs':
+            return handleLogs();
+        case 'can-send':
+            return outputResult(await httpRequest('GET', `/can-send?amountSats=${encodeURIComponent(filteredArgs[1] || '0')}`));
+        case 'can-receive':
+            return outputResult(await httpRequest('GET', `/can-receive?amountSats=${encodeURIComponent(filteredArgs[1] || '0')}`));
+        case 'wallet':
+            return handleWallet();
+        case 'node':
+            return handleNode();
+        case 'webhooks':
+            return handleWebhooks();
+        case 'queue':
+            return handleQueue();
+        case 'auth':
+            return handleAuth();
         case 'backup':
-            return outputResult(await httpRequest('POST', '/backup', {
-                destPath: filteredArgs[1]
-            }));
+            return handleBackup();
+        case 'restore':
+            return handleRestore();
         default:
             output({
                 ok: false,
@@ -222,6 +329,10 @@ async function handleStart() {
         cliFlags.daemonHost = hostFlag;
     if (hasFlag('--anchors'))
         cliFlags.preferAnchors = true;
+    if (hasFlag('--large-channels'))
+        cliFlags.largeChannels = true;
+    if (hasFlag('--htlc-events'))
+        cliFlags.htlcEvents = true;
     const apiTokenFlag = parseFlag('--api-token');
     if (apiTokenFlag)
         cliFlags.apiToken = apiTokenFlag;
@@ -249,6 +360,16 @@ async function handleStart() {
             .split(',')
             .map((a) => a.trim())
             .filter((a) => a.length > 0);
+    const watchtowerFlags = parseRepeatedFlag('--watchtower');
+    if (watchtowerFlags.length > 0)
+        cliFlags.watchtowers = watchtowerFlags;
+    const feeSourceFlag = parseFlag('--fee-source');
+    if (feeSourceFlag)
+        cliFlags.feeEstimationSource =
+            feeSourceFlag;
+    const logLevelFlag = parseFlag('--log-level');
+    if (logLevelFlag)
+        cliFlags.logLevel = logLevelFlag;
     const config = (0, config_1.resolveConfig)(cliFlags);
     if (!config.mnemonic) {
         output({
@@ -273,18 +394,24 @@ async function handleStart() {
             electrumPort: config.electrumPort,
             electrumTls: config.electrumTls,
             electrumServers: config.electrumServers,
+            feeEstimationSource: config.feeEstimationSource,
             listenPort: config.listenPort,
             daemonPort,
             daemonHost: config.daemonHost,
             preferAnchors: config.preferAnchors,
+            largeChannels: config.largeChannels,
             apiToken: config.apiToken,
+            apiKeys: config.apiKeys,
             backupPath: config.backupPath,
             backupIntervalMs: config.backupIntervalMs,
             dailySpendLimitSats: config.dailySpendLimitSats,
             tlsCert: config.tlsCert,
             tlsKey: config.tlsKey,
             torProxy: config.torProxy,
-            announceAddresses: config.announceAddresses
+            announceAddresses: config.announceAddresses,
+            watchtowers: config.watchtowers,
+            htlcEvents: config.htlcEvents,
+            logLevel: config.logLevel
         });
         (0, config_1.writePidFile)(process.pid, daemonPort);
         output({
@@ -321,15 +448,96 @@ async function handleStop() {
         output({ ok: false, error: { code: 'STOP_FAILED', message: msg } });
     }
 }
+async function handleTx() {
+    const sub = filteredArgs[1];
+    switch (sub) {
+        case 'bump-fee':
+            return outputResult(await httpRequest('POST', '/tx/bump-fee', {
+                txid: filteredArgs[2],
+                satsPerVbyte: filteredArgs[3]
+                    ? parseInt(filteredArgs[3], 10)
+                    : undefined
+            }));
+        case 'boost':
+            return outputResult(await httpRequest('POST', '/tx/boost', {
+                txid: filteredArgs[2],
+                satsPerVbyte: filteredArgs[3]
+                    ? parseInt(filteredArgs[3], 10)
+                    : undefined
+            }));
+        case 'boostable':
+            return outputResult(await httpRequest('GET', '/transactions/boostable'));
+        default:
+            output({
+                ok: false,
+                error: {
+                    code: 'UNKNOWN_COMMAND',
+                    message: 'Usage: beignet tx [bump-fee <txid> <satsPerVbyte>|boost <txid> [satsPerVbyte]|boostable]'
+                }
+            });
+            process.exitCode = 1;
+    }
+}
+function readPsbtArg(arg) {
+    if (!arg)
+        return undefined;
+    try {
+        if (fs.existsSync(arg) && fs.statSync(arg).isFile()) {
+            return fs.readFileSync(arg, 'utf8').trim();
+        }
+    }
+    catch {
+    }
+    return arg;
+}
+async function handlePsbt() {
+    const sub = filteredArgs[1];
+    switch (sub) {
+        case 'build':
+            return outputResult(await httpRequest('POST', '/psbt/build', {
+                outputs: [
+                    {
+                        address: filteredArgs[2],
+                        amountSats: parseInt(filteredArgs[3], 10)
+                    }
+                ],
+                satsPerVbyte: filteredArgs[4]
+                    ? parseInt(filteredArgs[4], 10)
+                    : undefined
+            }));
+        case 'import-signed':
+            return outputResult(await httpRequest('POST', '/psbt/import-signed', {
+                psbtBase64: readPsbtArg(filteredArgs[2])
+            }));
+        case 'combine':
+            return outputResult(await httpRequest('POST', '/psbt/combine', {
+                psbts: filteredArgs
+                    .slice(2)
+                    .map((arg) => readPsbtArg(arg))
+                    .filter((psbt) => !!psbt)
+            }));
+        default:
+            output({
+                ok: false,
+                error: {
+                    code: 'UNKNOWN_COMMAND',
+                    message: 'Usage: beignet psbt [build <address> <sats> [satsPerVbyte]|import-signed <psbtBase64|file>|combine <psbt|file> <psbt|file> ...]'
+                }
+            });
+            process.exitCode = 1;
+    }
+}
 async function handlePeer() {
     const sub = filteredArgs[1];
     switch (sub) {
         case 'connect':
-            return outputResult(await httpRequest('POST', '/peer/connect', {
-                pubkey: filteredArgs[2],
-                host: filteredArgs[3],
-                port: parseInt(filteredArgs[4], 10)
-            }));
+            return outputResult(await httpRequest('POST', '/peer/connect', filteredArgs[3] !== undefined
+                ? {
+                    pubkey: filteredArgs[2],
+                    host: filteredArgs[3],
+                    port: parseInt(filteredArgs[4], 10)
+                }
+                : { pubkey: filteredArgs[2] }));
         case 'disconnect':
             return outputResult(await httpRequest('POST', '/peer/disconnect', {
                 pubkey: filteredArgs[2]
@@ -399,12 +607,90 @@ async function handleChannel() {
                 count: parseInt(filteredArgs[2], 10),
                 satsPerChannel: parseInt(filteredArgs[3], 10)
             }));
+        case 'diagnostics':
+            return outputResult(await httpRequest('GET', `/channel/diagnostics?channelId=${encodeURIComponent(filteredArgs[2] || '')}`));
+        case 'health':
+            return outputResult(await httpRequest('GET', `/channel/health?channelId=${encodeURIComponent(filteredArgs[2] || '')}`));
+        case 'policy':
+            return outputResult(await httpRequest('GET', `/channel/policy?channelId=${encodeURIComponent(filteredArgs[2] || '')}`));
+        case 'suggestions':
+            return outputResult(await httpRequest('GET', filteredArgs[2]
+                ? `/channel/suggestions?count=${encodeURIComponent(filteredArgs[2])}`
+                : '/channel/suggestions'));
+        case 'ready':
+            return outputResult(await httpRequest('GET', '/channels/ready'));
+        case 'connect-and-open':
+            return outputResult(await httpRequest('POST', '/channel/connect-and-open', {
+                pubkey: filteredArgs[2],
+                host: filteredArgs[3],
+                port: filteredArgs[4] ? parseInt(filteredArgs[4], 10) : undefined,
+                amountSats: filteredArgs[5]
+                    ? parseInt(filteredArgs[5], 10)
+                    : undefined,
+                pushSats: filteredArgs[6] ? parseInt(filteredArgs[6], 10) : undefined
+            }));
+        case 'open-and-wait': {
+            const timeout = parseFlag('--timeout');
+            return outputResult(await httpRequest('POST', '/channel/open-and-wait', {
+                pubkey: filteredArgs[2],
+                amountSats: filteredArgs[3]
+                    ? parseInt(filteredArgs[3], 10)
+                    : undefined,
+                pushSats: filteredArgs[4] ? parseInt(filteredArgs[4], 10) : undefined,
+                timeoutMs: timeout !== undefined ? parseInt(timeout, 10) : undefined
+            }));
+        }
+        case 'wait-ready': {
+            const timeout = parseFlag('--timeout');
+            return outputResult(await httpRequest('POST', '/channel/wait-ready', {
+                channelId: filteredArgs[2],
+                timeoutMs: timeout !== undefined ? parseInt(timeout, 10) : undefined
+            }));
+        }
+        case 'update-commitment-feerate':
+            return outputResult(await httpRequest('POST', '/channel/update-commitment-feerate', {
+                channelId: filteredArgs[2],
+                feeratePerKw: filteredArgs[3]
+                    ? parseInt(filteredArgs[3], 10)
+                    : undefined
+            }));
+        case 'update-policy': {
+            const target = filteredArgs[2];
+            if (!target) {
+                output({
+                    ok: false,
+                    error: {
+                        code: 'INVALID_PARAMS',
+                        message: 'Usage: beignet channel update-policy <channelId|all> [--base-fee-msat N] [--ppm N] [--cltv-delta N] [--htlc-min-msat N] [--htlc-max-msat N]'
+                    }
+                });
+                process.exitCode = 1;
+                return;
+            }
+            const body = target === 'all' ? { all: true } : { channelId: target };
+            const baseFee = parseFlag('--base-fee-msat');
+            if (baseFee !== undefined)
+                body.feeBaseMsat = parseInt(baseFee, 10);
+            const ppm = parseFlag('--ppm');
+            if (ppm !== undefined)
+                body.feeProportionalMillionths = parseInt(ppm, 10);
+            const cltvDelta = parseFlag('--cltv-delta');
+            if (cltvDelta !== undefined)
+                body.cltvExpiryDelta = parseInt(cltvDelta, 10);
+            const htlcMin = parseFlag('--htlc-min-msat');
+            if (htlcMin !== undefined)
+                body.htlcMinimumMsat = htlcMin;
+            const htlcMax = parseFlag('--htlc-max-msat');
+            if (htlcMax !== undefined)
+                body.htlcMaximumMsat = htlcMax;
+            return outputResult(await httpRequest('POST', '/channel/update-policy', body));
+        }
         default:
             output({
                 ok: false,
                 error: {
                     code: 'UNKNOWN_COMMAND',
-                    message: 'Usage: beignet channel [open|open-zeroconf|open-v2|close|forceclose|splice-in|splice-out|ensure-minimum|list|get]'
+                    message: 'Usage: beignet channel [open|open-zeroconf|open-v2|open-and-wait|connect-and-open|close|forceclose|splice-in|splice-out|ensure-minimum|update-policy|update-commitment-feerate|policy|diagnostics|health|suggestions|wait-ready|ready|list|get]'
                 }
             });
             process.exitCode = 1;
@@ -418,14 +704,79 @@ async function handleInvoice() {
                 amountSats: parseInt(filteredArgs[2], 10),
                 description: filteredArgs[3] || ''
             }));
+        case 'create-hold': {
+            const paymentHash = filteredArgs[2];
+            if (!paymentHash) {
+                output({
+                    ok: false,
+                    error: {
+                        code: 'INVALID_PARAMS',
+                        message: 'Usage: beignet invoice create-hold <paymentHash> [amountSats] [description] [--expiry secs]'
+                    }
+                });
+                process.exitCode = 1;
+                return;
+            }
+            const expiryFlag = parseFlag('--expiry');
+            return outputResult(await httpRequest('POST', '/invoice/create-hold', {
+                paymentHash,
+                amountSats: filteredArgs[3]
+                    ? parseInt(filteredArgs[3], 10)
+                    : undefined,
+                description: filteredArgs[4] || '',
+                expiry: expiryFlag ? parseInt(expiryFlag, 10) : undefined
+            }));
+        }
+        case 'settle-hold':
+            return outputResult(await httpRequest('POST', '/invoice/settle-hold', {
+                preimage: filteredArgs[2]
+            }));
+        case 'cancel-hold':
+            return outputResult(await httpRequest('POST', '/invoice/cancel-hold', {
+                paymentHash: filteredArgs[2]
+            }));
+        case 'held':
+            return outputResult(await httpRequest('GET', '/invoices/held'));
         case 'decode':
             return outputResult(await httpRequest('POST', '/invoice/decode', {
                 bolt11: filteredArgs[2]
             }));
+        case 'validate':
+            return outputResult(await httpRequest('POST', '/invoice/validate', {
+                bolt11: filteredArgs[2],
+                amountSats: filteredArgs[3]
+                    ? parseInt(filteredArgs[3], 10)
+                    : undefined
+            }));
+        case 'get':
+            return outputResult(await httpRequest('GET', `/invoice?paymentHash=${encodeURIComponent(filteredArgs[2] || '')}`));
         case 'pay':
             return outputResult(await httpRequest('POST', '/invoice/pay', {
                 bolt11: filteredArgs[2]
             }));
+        case 'pay-safe':
+            return outputResult(await httpRequest('POST', '/invoice/pay-safe', {
+                bolt11: filteredArgs[2],
+                maxFeeSats: parseFlag('--max-fee')
+                    ? parseInt(parseFlag('--max-fee'), 10)
+                    : undefined,
+                amountSats: parseFlag('--amount')
+                    ? parseInt(parseFlag('--amount'), 10)
+                    : undefined,
+                timeoutMs: parseFlag('--timeout')
+                    ? parseInt(parseFlag('--timeout'), 10)
+                    : undefined
+            }));
+        case 'pay-async':
+            return outputResult(await httpRequest('POST', '/invoice/pay-async', {
+                bolt11: filteredArgs[2],
+                maxFeeSats: parseFlag('--max-fee')
+                    ? parseInt(parseFlag('--max-fee'), 10)
+                    : undefined,
+                amountSats: parseFlag('--amount')
+                    ? parseInt(parseFlag('--amount'), 10)
+                    : undefined
+            }));
         case 'pay-retry':
             return outputResult(await httpRequest('POST', '/invoice/pay-retry', {
                 bolt11: filteredArgs[2],
@@ -446,7 +797,7 @@ async function handleInvoice() {
                 ok: false,
                 error: {
                     code: 'UNKNOWN_COMMAND',
-                    message: 'Usage: beignet invoice [create|decode|pay|pay-retry|list]'
+                    message: 'Usage: beignet invoice [create|create-hold|settle-hold|cancel-hold|held|decode|validate|get|pay|pay-safe|pay-async|pay-retry|list]'
                 }
             });
             process.exitCode = 1;
@@ -459,12 +810,551 @@ async function handlePayment() {
             return outputResult(await httpRequest('GET', '/payments'));
         case 'get':
             return outputResult(await httpRequest('GET', `/payment?paymentHash=${encodeURIComponent(filteredArgs[2] || '')}`));
+        case 'send-to-route': {
+            const paymentHash = filteredArgs[2];
+            const routeArg = filteredArgs[3];
+            if (!paymentHash || !routeArg) {
+                output({
+                    ok: false,
+                    error: {
+                        code: 'INVALID_PARAMS',
+                        message: 'Usage: beignet payment send-to-route <paymentHash> <routeJson|routeFile> [--payment-secret <hex>]'
+                    }
+                });
+                process.exitCode = 1;
+                return;
+            }
+            let routeStr = routeArg;
+            if (!routeArg.trimStart().startsWith('{')) {
+                try {
+                    routeStr = fs.readFileSync(routeArg, 'utf8');
+                }
+                catch (err) {
+                    output({
+                        ok: false,
+                        error: {
+                            code: 'INVALID_PARAMS',
+                            message: `Cannot read route file: ${err.message}`
+                        }
+                    });
+                    process.exitCode = 1;
+                    return;
+                }
+            }
+            let route;
+            try {
+                route = JSON.parse(routeStr);
+            }
+            catch {
+                output({
+                    ok: false,
+                    error: {
+                        code: 'INVALID_PARAMS',
+                        message: 'Route is not valid JSON'
+                    }
+                });
+                process.exitCode = 1;
+                return;
+            }
+            const result = route && typeof route === 'object' && 'result' in route
+                ? route.result
+                : route;
+            return outputResult(await httpRequest('POST', '/payment/send-to-route', {
+                paymentHash,
+                route: { hops: result.hops },
+                paymentSecret: parseFlag('--payment-secret')
+            }));
+        }
+        case 'cancel':
+            return outputResult(await httpRequest('POST', '/payment/cancel', {
+                paymentHash: filteredArgs[2]
+            }));
+        case 'wait': {
+            const timeout = parseFlag('--timeout');
+            return outputResult(await httpRequest('POST', '/payment/wait', {
+                paymentHash: filteredArgs[2],
+                timeoutMs: timeout !== undefined ? parseInt(timeout, 10) : undefined
+            }));
+        }
+        case 'proof':
+            return outputResult(await httpRequest('GET', `/payment/proof?paymentHash=${encodeURIComponent(filteredArgs[2] || '')}`));
+        case 'verify-proof':
+            return outputResult(await httpRequest('GET', `/payment/verify-proof?paymentHash=${encodeURIComponent(filteredArgs[2] || '')}`));
+        case 'estimate':
+            return outputResult(await httpRequest('POST', '/payment/estimate', {
+                bolt11: filteredArgs[2],
+                amountSats: filteredArgs[3]
+                    ? parseInt(filteredArgs[3], 10)
+                    : undefined
+            }));
+        case 'metadata': {
+            const paymentHash = filteredArgs[2];
+            const metadataArg = filteredArgs[3];
+            if (!paymentHash || !metadataArg) {
+                output({
+                    ok: false,
+                    error: {
+                        code: 'INVALID_PARAMS',
+                        message: 'Usage: beignet payment metadata <paymentHash> \'{"key":"value"}\''
+                    }
+                });
+                process.exitCode = 1;
+                return;
+            }
+            let metadata;
+            try {
+                metadata = JSON.parse(metadataArg);
+            }
+            catch {
+                output({
+                    ok: false,
+                    error: {
+                        code: 'INVALID_PARAMS',
+                        message: 'Metadata is not valid JSON'
+                    }
+                });
+                process.exitCode = 1;
+                return;
+            }
+            return outputResult(await httpRequest('POST', '/payment/metadata', {
+                paymentHash,
+                metadata
+            }));
+        }
+        default:
+            output({
+                ok: false,
+                error: {
+                    code: 'UNKNOWN_COMMAND',
+                    message: 'Usage: beignet payment [list|get|cancel|wait|proof|verify-proof|estimate|metadata|send-to-route]'
+                }
+            });
+            process.exitCode = 1;
+    }
+}
+async function handleKeysend() {
+    const safe = filteredArgs[1] === 'safe';
+    const base = safe ? 2 : 1;
+    const pubkey = filteredArgs[base];
+    const sats = filteredArgs[base + 1];
+    if (!pubkey || !sats) {
+        output({
+            ok: false,
+            error: {
+                code: 'INVALID_PARAMS',
+                message: 'Usage: beignet keysend [safe] <pubkey> <sats> [--max-fee <sats>] [--timeout <ms>]'
+            }
+        });
+        process.exitCode = 1;
+        return;
+    }
+    const maxFee = parseFlag('--max-fee');
+    const timeout = parseFlag('--timeout');
+    return outputResult(await httpRequest('POST', safe ? '/keysend/safe' : '/keysend', {
+        pubkey,
+        amountSats: parseInt(sats, 10),
+        maxFeeSats: maxFee !== undefined ? parseInt(maxFee, 10) : undefined,
+        timeoutMs: timeout !== undefined ? parseInt(timeout, 10) : undefined
+    }));
+}
+async function handleLogs() {
+    const params = new URLSearchParams();
+    const category = parseFlag('--category');
+    if (category !== undefined)
+        params.set('category', category);
+    const since = parseFlag('--since');
+    if (since !== undefined)
+        params.set('since', since);
+    const limit = parseFlag('--limit');
+    if (limit !== undefined)
+        params.set('limit', limit);
+    const qs = params.toString();
+    return outputResult(await httpRequest('GET', qs ? `/logs?${qs}` : '/logs'));
+}
+async function handleWallet() {
+    const sub = filteredArgs[1];
+    switch (sub) {
+        case 'refresh':
+            return outputResult(await httpRequest('POST', '/wallet/refresh'));
+        case 'descriptors':
+            return outputResult(await httpRequest('GET', '/wallet/descriptors'));
+        default:
+            output({
+                ok: false,
+                error: {
+                    code: 'UNKNOWN_COMMAND',
+                    message: 'Usage: beignet wallet [refresh|descriptors]'
+                }
+            });
+            process.exitCode = 1;
+    }
+}
+async function handleUtxo() {
+    const sub = filteredArgs[1];
+    const outpoint = () => ({
+        txid: filteredArgs[2],
+        index: parseInt(filteredArgs[3], 10)
+    });
+    switch (sub) {
+        case 'freeze':
+            return outputResult(await httpRequest('POST', '/utxo/freeze', outpoint()));
+        case 'unfreeze':
+            return outputResult(await httpRequest('POST', '/utxo/unfreeze', outpoint()));
+        case 'frozen': {
+            const res = await httpRequest('GET', '/utxos');
+            if (res.ok && Array.isArray(res.result)) {
+                return output({
+                    ok: true,
+                    result: res.result.filter((u) => u.frozen)
+                });
+            }
+            return outputResult(res);
+        }
+        default:
+            output({
+                ok: false,
+                error: {
+                    code: 'UNKNOWN_COMMAND',
+                    message: 'Usage: beignet utxo [freeze <txid> <index>|unfreeze <txid> <index>|frozen]'
+                }
+            });
+            process.exitCode = 1;
+    }
+}
+async function handleNode() {
+    const sub = filteredArgs[1];
+    switch (sub) {
+        case 'uri': {
+            const host = parseFlag('--host');
+            return outputResult(await httpRequest('GET', host !== undefined
+                ? `/node/uri?host=${encodeURIComponent(host)}`
+                : '/node/uri'));
+        }
+        case 'wait-ready': {
+            const timeout = parseFlag('--timeout');
+            return outputResult(await httpRequest('POST', '/node/wait-ready', {
+                timeoutMs: timeout !== undefined ? parseInt(timeout, 10) : undefined
+            }));
+        }
         default:
             output({
                 ok: false,
                 error: {
                     code: 'UNKNOWN_COMMAND',
-                    message: 'Usage: beignet payment [list|get]'
+                    message: 'Usage: beignet node [uri [--host <addr>]|wait-ready [--timeout <ms>]]'
+                }
+            });
+            process.exitCode = 1;
+    }
+}
+async function handleWebhooks() {
+    const sub = filteredArgs[1];
+    switch (sub) {
+        case 'register': {
+            const url = filteredArgs[2];
+            const events = filteredArgs[3];
+            if (!url || !events) {
+                output({
+                    ok: false,
+                    error: {
+                        code: 'INVALID_PARAMS',
+                        message: 'Usage: beignet webhooks register <url> <event,event,...|*> [--secret <secret>]'
+                    }
+                });
+                process.exitCode = 1;
+                return;
+            }
+            return outputResult(await httpRequest('POST', '/webhooks/register', {
+                url,
+                events: events
+                    .split(',')
+                    .map((e) => e.trim())
+                    .filter((e) => e.length > 0),
+                secret: parseFlag('--secret')
+            }));
+        }
+        case 'unregister':
+            return outputResult(await httpRequest('DELETE', '/webhooks/unregister', {
+                id: filteredArgs[2]
+            }));
+        case 'list':
+            return outputResult(await httpRequest('GET', '/webhooks'));
+        default:
+            output({
+                ok: false,
+                error: {
+                    code: 'UNKNOWN_COMMAND',
+                    message: 'Usage: beignet webhooks [register <url> <events>|unregister <id>|list]'
+                }
+            });
+            process.exitCode = 1;
+    }
+}
+async function handleAuth() {
+    const sub = filteredArgs[1];
+    switch (sub) {
+        case 'keys':
+            return outputResult(await httpRequest('GET', '/auth/keys'));
+        case 'revoke': {
+            const name = filteredArgs[2];
+            if (!name) {
+                output({
+                    ok: false,
+                    error: {
+                        code: 'INVALID_PARAMS',
+                        message: 'Usage: beignet auth revoke <name>'
+                    }
+                });
+                process.exitCode = 1;
+                return;
+            }
+            return outputResult(await httpRequest('POST', '/auth/keys/revoke', { name }));
+        }
+        default:
+            output({
+                ok: false,
+                error: {
+                    code: 'UNKNOWN_COMMAND',
+                    message: 'Usage: beignet auth [keys|revoke <name>]'
+                }
+            });
+            process.exitCode = 1;
+    }
+}
+async function handleQueue() {
+    const sub = filteredArgs[1];
+    switch (sub) {
+        case 'add': {
+            const bolt11 = filteredArgs[2];
+            if (!bolt11) {
+                output({
+                    ok: false,
+                    error: {
+                        code: 'INVALID_PARAMS',
+                        message: 'Usage: beignet queue add <bolt11> [--priority <1-10>] [--amount <sats>] [--max-fee <sats>]'
+                    }
+                });
+                process.exitCode = 1;
+                return;
+            }
+            const priority = parseFlag('--priority');
+            const amount = parseFlag('--amount');
+            const maxFee = parseFlag('--max-fee');
+            return outputResult(await httpRequest('POST', '/queue/add', {
+                bolt11,
+                priority: priority !== undefined ? parseInt(priority, 10) : undefined,
+                amountSats: amount !== undefined ? parseInt(amount, 10) : undefined,
+                maxFeeSats: maxFee !== undefined ? parseInt(maxFee, 10) : undefined
+            }));
+        }
+        case 'cancel':
+            return outputResult(await httpRequest('POST', '/queue/cancel', { id: filteredArgs[2] }));
+        case 'list':
+            return outputResult(await httpRequest('GET', '/queue'));
+        default:
+            output({
+                ok: false,
+                error: {
+                    code: 'UNKNOWN_COMMAND',
+                    message: 'Usage: beignet queue [add <bolt11>|cancel <id>|list]'
+                }
+            });
+            process.exitCode = 1;
+    }
+}
+async function handleGraph() {
+    const sub = filteredArgs[1];
+    switch (sub) {
+        case 'info':
+            return outputResult(await httpRequest('GET', '/graph/info'));
+        case 'node':
+            return outputResult(await httpRequest('GET', `/graph/node?pubkey=${encodeURIComponent(filteredArgs[2] || '')}`));
+        case 'channel':
+            return outputResult(await httpRequest('GET', `/graph/channel?scid=${encodeURIComponent(filteredArgs[2] || '')}`));
+        case 'describe': {
+            const params = new URLSearchParams();
+            const limit = parseFlag('--limit');
+            if (limit !== undefined)
+                params.set('limit', limit);
+            const offset = parseFlag('--offset');
+            if (offset !== undefined)
+                params.set('offset', offset);
+            const qs = params.toString();
+            return outputResult(await httpRequest('GET', qs ? `/graph/describe?${qs}` : '/graph/describe'));
+        }
+        default:
+            output({
+                ok: false,
+                error: {
+                    code: 'UNKNOWN_COMMAND',
+                    message: 'Usage: beignet graph [info|node <pubkey>|channel <scid>|describe [--limit N] [--offset N]]'
+                }
+            });
+            process.exitCode = 1;
+    }
+}
+async function handleWatchtower() {
+    const sub = filteredArgs[1];
+    switch (sub) {
+        case 'list':
+            return outputResult(await httpRequest('GET', '/watchtowers'));
+        case 'add': {
+            const uri = filteredArgs[2];
+            if (!uri) {
+                output({
+                    ok: false,
+                    error: {
+                        code: 'INVALID_PARAMS',
+                        message: 'Usage: beignet watchtower add <pubkey@host:port>'
+                    }
+                });
+                process.exitCode = 1;
+                return;
+            }
+            return outputResult(await httpRequest('POST', '/watchtower/add', { uri }));
+        }
+        case 'remove': {
+            const uri = filteredArgs[2];
+            if (!uri) {
+                output({
+                    ok: false,
+                    error: {
+                        code: 'INVALID_PARAMS',
+                        message: 'Usage: beignet watchtower remove <pubkey@host:port>'
+                    }
+                });
+                process.exitCode = 1;
+                return;
+            }
+            return outputResult(await httpRequest('DELETE', '/watchtower/remove', { uri }));
+        }
+        default:
+            output({
+                ok: false,
+                error: {
+                    code: 'UNKNOWN_COMMAND',
+                    message: 'Usage: beignet watchtower [list|add <uri>|remove <uri>]'
+                }
+            });
+            process.exitCode = 1;
+    }
+}
+async function handleRoute() {
+    const sub = filteredArgs[1];
+    switch (sub) {
+        case 'query': {
+            const destination = filteredArgs[2];
+            const sats = filteredArgs[3];
+            if (!destination || !sats) {
+                output({
+                    ok: false,
+                    error: {
+                        code: 'INVALID_PARAMS',
+                        message: 'Usage: beignet route query <destination> <sats> [--max-fee <sats>]'
+                    }
+                });
+                process.exitCode = 1;
+                return;
+            }
+            const maxFee = parseFlag('--max-fee');
+            return outputResult(await httpRequest('POST', '/route/query', {
+                destination,
+                amountSats: parseInt(sats, 10),
+                maxFeeSats: maxFee !== undefined ? parseInt(maxFee, 10) : undefined
+            }));
+        }
+        case 'estimate':
+            return outputResult(await httpRequest('POST', '/route/estimate', {
+                bolt11: filteredArgs[2],
+                amountSats: filteredArgs[3]
+                    ? parseInt(filteredArgs[3], 10)
+                    : undefined
+            }));
+        case 'probe': {
+            const destination = filteredArgs[2];
+            const sats = filteredArgs[3];
+            if (!destination || !sats) {
+                output({
+                    ok: false,
+                    error: {
+                        code: 'INVALID_PARAMS',
+                        message: 'Usage: beignet route probe <destination> <sats>'
+                    }
+                });
+                process.exitCode = 1;
+                return;
+            }
+            return outputResult(await httpRequest('POST', '/route/probe', {
+                destination,
+                amountSats: parseInt(sats, 10)
+            }));
+        }
+        default:
+            output({
+                ok: false,
+                error: {
+                    code: 'UNKNOWN_COMMAND',
+                    message: 'Usage: beignet route [query <destination> <sats>|estimate <bolt11> [sats]|probe <destination> <sats>]'
+                }
+            });
+            process.exitCode = 1;
+    }
+}
+async function handleForwards() {
+    const params = new URLSearchParams();
+    const since = parseFlag('--since');
+    if (since !== undefined)
+        params.set('since', since);
+    if (filteredArgs[1] === 'summary') {
+        const qs = params.toString();
+        return outputResult(await httpRequest('GET', `/forwards/summary${qs ? `?${qs}` : ''}`));
+    }
+    const limit = parseFlag('--limit');
+    if (limit !== undefined)
+        params.set('limit', limit);
+    const qs = params.toString();
+    return outputResult(await httpRequest('GET', `/forwards${qs ? `?${qs}` : ''}`));
+}
+async function handleRebalance() {
+    const fromChannelId = filteredArgs[1];
+    const toChannelId = filteredArgs[2];
+    const amountSats = filteredArgs[3];
+    const maxFee = parseFlag('--max-fee');
+    if (!fromChannelId || !toChannelId || !amountSats || maxFee === undefined) {
+        output({
+            ok: false,
+            error: {
+                code: 'INVALID_PARAMS',
+                message: 'Usage: beignet rebalance <fromChannelId> <toChannelId> <amountSats> --max-fee <sats>'
+            }
+        });
+        process.exitCode = 1;
+        return;
+    }
+    return outputResult(await httpRequest('POST', '/rebalance', {
+        fromChannelId,
+        toChannelId,
+        amountSats: parseInt(amountSats, 10),
+        maxFeeSats: parseInt(maxFee, 10)
+    }));
+}
+async function handleAdvisor() {
+    const sub = filteredArgs[1];
+    switch (sub) {
+        case 'recommendations':
+            return outputResult(await httpRequest('GET', '/advisor/recommendations'));
+        case 'execute-rebalances': {
+            const budget = parseFlag('--budget');
+            return outputResult(await httpRequest('POST', '/advisor/execute-rebalances', {
+                budgetSatsPerDay: budget !== undefined ? parseInt(budget, 10) : undefined
+            }));
+        }
+        default:
+            output({
+                ok: false,
+                error: {
+                    code: 'UNKNOWN_COMMAND',
+                    message: 'Usage: beignet advisor [recommendations|execute-rebalances [--budget <sats>]]'
                 }
             });
             process.exitCode = 1;
@@ -526,6 +1416,10 @@ async function handleOffer() {
             }));
         case 'list':
             return outputResult(await httpRequest('GET', '/offers'));
+        case 'decode':
+            return outputResult(await httpRequest('POST', '/offer/decode', {
+                offer: filteredArgs[2]
+            }));
         case 'pay':
             return outputResult(await httpRequest('POST', '/offer/pay', {
                 offer: filteredArgs[2],
@@ -538,12 +1432,198 @@ async function handleOffer() {
                 ok: false,
                 error: {
                     code: 'UNKNOWN_COMMAND',
-                    message: 'Usage: beignet offer [create|list|pay]'
+                    message: 'Usage: beignet offer [create|list|decode|pay]'
                 }
             });
             process.exitCode = 1;
     }
 }
+async function handleGossip() {
+    const sub = filteredArgs[1];
+    switch (sub) {
+        case 'sync':
+            return outputResult(await httpRequest('POST', '/gossip/sync', {
+                pubkey: filteredArgs[2] || undefined
+            }));
+        case 'sync-rapid':
+            return outputResult(await httpRequest('POST', '/gossip/sync-rapid'));
+        default:
+            output({
+                ok: false,
+                error: {
+                    code: 'UNKNOWN_COMMAND',
+                    message: 'Usage: beignet gossip [sync [pubkey]|sync-rapid]'
+                }
+            });
+            process.exitCode = 1;
+    }
+}
+async function handleMessage() {
+    const sub = filteredArgs[1];
+    switch (sub) {
+        case 'sign':
+            return outputResult(await httpRequest('POST', '/message/sign', {
+                message: filteredArgs[2]
+            }));
+        case 'verify':
+            return outputResult(await httpRequest('POST', '/message/verify', {
+                message: filteredArgs[2],
+                signature: filteredArgs[3]
+            }));
+        default:
+            output({
+                ok: false,
+                error: {
+                    code: 'UNKNOWN_COMMAND',
+                    message: 'Usage: beignet message [sign <message>|verify <message> <signature>]'
+                }
+            });
+            process.exitCode = 1;
+    }
+}
+async function handleBackup() {
+    const sub = filteredArgs[1];
+    if (sub === 'trigger') {
+        return outputResult(await httpRequest('POST', '/backup/trigger'));
+    }
+    if (sub === 'peer-retrieved') {
+        return outputResult(await httpRequest('GET', '/backup/peer-retrieved'));
+    }
+    if (sub === 'scb') {
+        const result = await httpRequest('GET', '/backup/scb');
+        const destPath = filteredArgs[2];
+        if (!result.ok || !destPath)
+            return outputResult(result);
+        const { encoded, channelCount } = result.result;
+        fs.writeFileSync(destPath, encoded);
+        return output({
+            ok: true,
+            result: { written: true, path: destPath, channelCount }
+        });
+    }
+    if (!sub) {
+        output({
+            ok: false,
+            error: {
+                code: 'INVALID_PARAMS',
+                message: 'Usage: beignet backup <destPath> | beignet backup scb [destPath] | beignet backup trigger'
+            }
+        });
+        process.exitCode = 1;
+        return;
+    }
+    return outputResult(await httpRequest('POST', '/backup', { destPath: sub }));
+}
+async function handleRestore() {
+    const sub = filteredArgs[1];
+    const file = filteredArgs[2];
+    if (sub === 'scb') {
+        if (!file) {
+            output({
+                ok: false,
+                error: {
+                    code: 'INVALID_PARAMS',
+                    message: 'Usage: beignet restore scb <file>'
+                }
+            });
+            process.exitCode = 1;
+            return;
+        }
+        let encoded;
+        try {
+            encoded = fs.readFileSync(file, 'utf8').trim();
+        }
+        catch (err) {
+            output({
+                ok: false,
+                error: {
+                    code: 'INVALID_PARAMS',
+                    message: `Cannot read SCB file: ${err.message}`
+                }
+            });
+            process.exitCode = 1;
+            return;
+        }
+        return outputResult(await httpRequest('POST', '/restore/scb', { encoded }));
+    }
+    if (sub === 'db') {
+        if (!file) {
+            output({
+                ok: false,
+                error: {
+                    code: 'INVALID_PARAMS',
+                    message: 'Usage: beignet restore db <backupFile>'
+                }
+            });
+            process.exitCode = 1;
+            return;
+        }
+        const config = (0, config_1.resolveConfig)({});
+        if (!config.mnemonic) {
+            output({
+                ok: false,
+                error: {
+                    code: 'NO_MNEMONIC',
+                    message: 'No mnemonic found. Run "beignet init" first or set BEIGNET_MNEMONIC (the restored DB is seed-encrypted and needs the same mnemonic).'
+                }
+            });
+            process.exitCode = 1;
+            return;
+        }
+        const pidInfo = (0, config_1.readPidFile)();
+        if (pidInfo) {
+            try {
+                process.kill(pidInfo.pid, 0);
+                output({
+                    ok: false,
+                    error: {
+                        code: 'DAEMON_RUNNING',
+                        message: `Daemon is running (PID ${pidInfo.pid}). Stop it with 'beignet stop' before restoring the database.`
+                    }
+                });
+                process.exitCode = 1;
+                return;
+            }
+            catch {
+            }
+        }
+        const network = config.network || 'mainnet';
+        const dataDir = config.dataDir || (0, beignet_node_1.defaultDataDirForMnemonic)(config.mnemonic);
+        const dbPath = nodePath.join(dataDir, `${network}.db`);
+        const lockPath = nodePath.join(dataDir, `${network}.lock`);
+        try {
+            fs.mkdirSync(dataDir, { recursive: true });
+            const result = (0, restore_1.performDbRestore)(file, dbPath, lockPath);
+            output({
+                ok: true,
+                result: {
+                    restored: true,
+                    dbPath: result.dbPath,
+                    preRestorePath: result.preRestorePath,
+                    network,
+                    note: 'DB is encrypted under the wallet seed; start the node with the same mnemonic.'
+                }
+            });
+        }
+        catch (err) {
+            const code = err instanceof instance_lock_1.InstanceLockError ? 'DAEMON_RUNNING' : 'RESTORE_FAILED';
+            output({
+                ok: false,
+                error: { code, message: err.message }
+            });
+            process.exitCode = 1;
+        }
+        return;
+    }
+    output({
+        ok: false,
+        error: {
+            code: 'UNKNOWN_COMMAND',
+            message: 'Usage: beignet restore scb <file> | beignet restore db <backupFile>'
+        }
+    });
+    process.exitCode = 1;
+}
 async function handleMetrics() {
     const port = (0, config_1.getDaemonPort)();
     const token = getApiToken();
@@ -584,18 +1664,68 @@ Info:
   info                                   Node info
   balance                                On-chain + Lightning balance
   address                                New receive address
+  address --bip21 [--amount <sats>] [--label L] [--message M]
+                                         New address as a BIP21 URI
+  address validate <address>             Validate a Bitcoin address
+  address label <address> [label]        Set a user label for an address
+                                         (omit the label to clear it)
+  address labels                         List all user address labels
   mnemonic                               Show mnemonic
   health                                 Node health status
+  ready                                  Whether the node is operational
   readiness                              Mainnet readiness checklist
   metrics                                Prometheus-format metrics (text/plain)
   stats [windowMs]                       Node statistics (optional time window)
+  liquidity                              Liquidity snapshot + recommendations
+  fees                                   On-chain fee trend analysis
+  spend-limit                            Combined LN + on-chain daily spend
+                                         limit status (with breakdown)
+  logs [--category C] [--since ts] [--limit n]
+                                         Query the persistent action log
+  can-send [sats]                        Check Lightning send capacity
+  can-receive [sats]                     Check Lightning receive capacity
+  node uri [--host <addr>]               Node connection URI (pubkey@host:port)
+  node wait-ready [--timeout ms]         Block until the node is operational
 
 On-chain:
   send <address> <sats>                  Send on-chain
+  send-max <address> [satsPerVbyte]      Sweep the whole on-chain balance
+  tx bump-fee <txid> <satsPerVbyte>      RBF an unconfirmed tx at a higher fee
+  tx boost <txid> [satsPerVbyte]         Fee-bump a tx (RBF when possible,
+                                         else CPFP)
+  tx boostable                           List unconfirmed txs eligible for
+                                         RBF/CPFP
+  consolidate [satsPerVbyte]             Merge all UTXOs into one output at a
+                                         fresh wallet address
+  psbt build <address> <sats> [satsPerVbyte]
+                                         Build an UNSIGNED PSBT for an external
+                                         signer (hardware wallet)
+  psbt import-signed <psbtBase64|file>   Validate + finalize a signed PSBT;
+                                         returns txid/txHex WITHOUT broadcast
+  psbt combine <psbt|file> <psbt|file>   Combine partially signed PSBT copies
   transactions [limit]                   List on-chain transactions (newest first)
-  utxos                                  List wallet UTXOs
+  utxos                                  List wallet UTXOs (includes frozen flag)
+  utxo freeze <txid> <index>             Freeze a UTXO (excluded from coin
+                                         selection until unfrozen)
+  utxo unfreeze <txid> <index>           Unfreeze a UTXO
+  utxo frozen                            List frozen UTXOs
   fee-estimates                          Current fee estimates (sats/vbyte)
+  wallet refresh                         Re-sync the on-chain wallet
+  wallet descriptors                     Export BIP 380 output descriptors
+                                         (public keys only, never private)
+  recover-fallback-funds [--fee-rate N]  Sweep funding-key fallback UTXOs into
+                                         the wallet
   backup <destPath>                      Create database backup
+  backup trigger                         Run the configured scheduled backup now
+  backup scb [destPath]                  Export encrypted static channel backup
+  backup peer-retrieved                  Show newest SCB returned by a peer
+                                         (BOLT 1 peer storage)
+  restore scb <file>                     Restore channels from an SCB (on-chain
+                                         recovery only: peers force-close and
+                                         funds are swept to the wallet)
+  restore db <backupFile>                Restore a database backup (full state;
+                                         OFFLINE - stop the daemon first; needs
+                                         the same mnemonic, DB is seed-encrypted)
 
 Peers:
   peer connect <pubkey> <host> <port>    Connect to peer
@@ -615,37 +1745,143 @@ Channels:
   channel open <pubkey> <sats> [push]    Open channel (auto-funded)
   channel open-zeroconf <pk> <sats> [push]  Open zero-conf channel
   channel open-v2 <pubkey> <sats> [feerate]  Open dual-funded v2 channel
+  channel open-and-wait <pubkey> <sats> [push] [--timeout ms]
+                                         Open channel + block until NORMAL
+  channel connect-and-open <pubkey> <host> <port> <sats> [push]
+                                         Connect to peer + open in one call
   channel close <id>                     Cooperative close
   channel forceclose <id>                Force close
   channel splice-in <id> <sats> <feerate>   Add funds to channel
   channel splice-out <id> <sats> <feerate>  Withdraw funds from channel
   channel ensure-minimum <count> <sats>  Auto-open channels to minimum count
+  channel update-policy <id|all> [--base-fee-msat N] [--ppm N] [--cltv-delta N]
+                        [--htlc-min-msat N] [--htlc-max-msat N]
+                                         Set routing fee policy (channel_update)
+  channel update-commitment-feerate <id> <feeratePerKw>
+                                         Set COMMITMENT feerate (BOLT 2
+                                         update_fee), not the routing policy
+  channel policy <id>                    Effective routing policy for a channel
   channel list                           List channels
-  channel get <id>                       Channel details
+  channel ready                          List channels in NORMAL state
+  channel get <id>                       Channel details (includes routing policy)
+  channel health <id>                    Channel health + liquidity warnings
+  channel diagnostics <id>               Routing-readiness diagnostics for a channel
+  channel suggestions [count]            Graph-based channel open suggestions
+  channel wait-ready <id> [--timeout ms] Block until a channel reaches NORMAL
 
 Invoices & Payments:
   invoice create <sats> [description]    Create BOLT 11 invoice
+  invoice create-hold <hash> [sats] [description] [--expiry secs]
+                                         Create hold invoice for a payment hash
+                                         you supply (keep the preimage; HTLCs
+                                         park until settle-hold/cancel-hold)
+  invoice settle-hold <preimage>         Settle a parked hold invoice
+  invoice cancel-hold <hash>             Cancel a hold invoice (fails HTLCs back)
+  invoice held                           List hold invoices + their state
   invoice decode <bolt11>                Decode invoice
+  invoice validate <bolt11> [sats]       Pre-flight checks: should this be paid?
+  invoice get <hash>                     Details of an invoice we created
   invoice pay <bolt11>                   Pay invoice (blocks until settled)
+  invoice pay-safe <bolt11> [--max-fee N] [--amount N] [--timeout ms]
+                                         Pay; resolves with status FAILED
+                                         instead of erroring
+  invoice pay-async <bolt11> [--max-fee N] [--amount N]
+                                         Fire-and-forget pay; poll 'payment get'
   invoice pay-retry <bolt11> [flags]     Pay with exponential backoff retry
   invoice list                           List created invoices
+  keysend [safe] <pubkey> <sats> [--max-fee N] [--timeout ms]
+                                         Spontaneous payment, no invoice needed
+                                         ('safe' resolves FAILED, never errors)
   payment list                           List payments
   payment get <hash>                     Payment details
+  payment cancel <hash>                  Cancel a pending outbound payment
+  payment wait <hash> [--timeout ms]     Block until a payment settles
+  payment proof <hash>                   Cryptographic payment proof
+  payment verify-proof <hash>            Verify a stored payment proof
+  payment estimate <bolt11> [sats]       Success probability + fee estimate
+  payment metadata <hash> <json>         Attach key-value metadata to a payment
+  payment send-to-route <hash> <route>   Pay along an explicit route (inline
+                                         JSON or a file with 'route query'
+                                         output) [--payment-secret <hex>]
+  queue add <bolt11> [--priority N] [--amount N] [--max-fee N]
+                                         Enqueue a payment for ordered dispatch
+  queue cancel <id>                      Cancel a queued payment
+  queue list                             List the payment queue
+
+Graph Queries:
+  graph info                             Graph summary (node/channel counts)
+  graph node <pubkey>                    Node announcement info + its channels
+  graph channel <scid>                   Channel endpoints + both fee policies
+                                         (scid: <block>x<tx>x<out> or hex)
+  graph describe [--limit N] [--offset N]  Paged channel dump (default 500)
+  gossip sync [pubkey]                   Sync gossip from peers (or one peer)
+  gossip sync-rapid                      Rapid Gossip Sync snapshot (mainnet)
+  route query <destination> <sats>       Compute a route without paying
+                                         [--max-fee <sats>]
+  route estimate <bolt11> [sats]         Estimate route fee for an invoice
+  route probe <destination> <sats>       Probe route viability (no payment)
+
+Routing:
+  forwards [--since ts] [--limit n]      List settled forwards (fees earned)
+  forwards summary [--since ts]          Forwarding totals (count, volume, fees)
+  rebalance <fromId> <toId> <sats> --max-fee <sats>
+                                         Circular rebalance between two of our
+                                         channels (aborts if fee exceeds cap)
+  advisor recommendations                Liquidity analysis + rebalance plan
+  advisor execute-rebalances [--budget <sats>]
+                                         Run the advisor's rebalance plan under
+                                         a per-day fee budget
+
+Messages:
+  message sign <message>                 Sign with the node key (LND-compatible)
+  message verify <message> <signature>   Recover + check the signer pubkey
+Watchtowers:
+  watchtower list                        Per-tower session + backlog health
+  watchtower add <pubkey@host:port>      Add an LND altruist watchtower
+  watchtower remove <pubkey@host:port>   Remove a watchtower
 
 BOLT 12 Offers:
   offer create <description> [amountSats]  Create reusable offer
   offer list                             List local offers
+  offer decode <offer>                   Decode a BOLT 12 offer string
   offer pay <offer> [amountSats]         Pay a BOLT 12 offer
 
+Webhooks (event push; see also GET /events SSE):
+  webhooks register <url> <events> [--secret S]
+                                         Register a callback URL; <events> is
+                                         comma-separated (or '*' for all)
+  webhooks unregister <id>               Remove a webhook
+  webhooks list                          List registered webhooks
+
+API auth (scoped keys; see apiKeys config):
+  auth keys                              List named API keys (names + scopes,
+                                         never secrets)
+  auth revoke <name>                     Disable a named key until restart
+                                         (remove it from config for good)
+
 Start flags:
+  --network <name>                       mainnet | testnet | signet | regtest
+  --fee-source <src>                     Fee estimate source: electrum | http |
+                                         auto (default: auto = Electrum first,
+                                         HTTP fallback)
   --port <N>                             HTTP daemon port (default: 2112)
+  --log-level <level>                    Daemon stderr log level: debug | info |
+                                         warn | error | silent (default: silent;
+                                         env BEIGNET_LOG_LEVEL, config logLevel)
   --host <addr>                          HTTP daemon bind address (default: 127.0.0.1)
   --daemon                               Run in background
   --anchors                              Prefer anchor channels (zero-fee HTLC)
-  --api-token <token>                    API authentication token
+  --api-token <token>                    API authentication token (legacy single
+                                         token, implicit admin scope; named
+                                         scoped keys go in the apiKeys config
+                                         or BEIGNET_API_KEYS env JSON)
+  --api-key <key>                        Alias of --api-token for sending a
+                                         named key's secret with any command
   --backup-path <path>                   Enable automated backups to path
   --backup-interval <ms>                 Backup interval (default: 21600000 = 6h)
-  --daily-spend-limit <sats>             Daily spending limit in satoshis
+  --daily-spend-limit <sats>             Combined daily spending limit in sats
+                                         (Lightning payments AND external
+                                         on-chain sends share one budget)
   --tls-cert <path>                      TLS certificate file (enables HTTPS)
   --tls-key <path>                       TLS private key file (requires --tls-cert)
   --tor-proxy <host:port>                SOCKS5 proxy for outbound Lightning peer
@@ -653,6 +1889,9 @@ Start flags:
   --announce-addr <addr[,addr...]>       Addresses to advertise in node_announcement
                                          (IPv4, [ipv6]:port, .onion v3, or hostname;
                                          port defaults to 9735)
+  --htlc-events                          Relay per-HTLC events (htlc:forwarded/
+                                         fulfilled/failed) over SSE + webhooks
+                                         (off by default: high volume on routers)
 
 Pay-retry flags:
   --max-retries <N>                      Max retry attempts (default: 3)