lnlink-server 1.0.1 → 1.0.2

package/{index.js → dist/index.js}

@@ -908,6 +908,7 @@ var require_constants = __commonJS({
       "backup_node",
       "restore_node",
       "update_node_name",
+      "toggle_tor",
       ...READ_ONLY_PERMISSIONS
     ];
     var SOCILA_TYPE = {
@@ -1098,7 +1099,7 @@ var require_nostrEventRepository = __commonJS({
       }
       /**
        * Update event status and related fields
-       * @param {number} id - Event ID
+       * @param {number|string} id - Event ID (int) or event_id (string)
        * @param {object} updateData - Update data
        * @returns {Promise<object>} Updated event
        */
@@ -1118,6 +1119,13 @@ var require_nostrEventRepository = __commonJS({
         if (reply_err) {
           data.reply_err = reply_err;
         }
+        const isStringId = typeof id === "string" && id.length > 10;
+        if (isStringId) {
+          return this.prisma.lnlinkNostrEvent.updateMany({
+            where: { event_id: id },
+            data
+          });
+        }
         return this.prisma.lnlinkNostrEvent.update({
           where: { id },
           data
@@ -1218,8 +1226,11 @@ var require_events = __commonJS({
       }, "insertEvent"),
       updateEvent: /* @__PURE__ */ __name(async (id, updateData) => {
         try {
-          await getNostrEventRepo().updateEvent(id, updateData);
-          return 1;
+          const result = await getNostrEventRepo().updateEvent(id, updateData);
+          if (result && typeof result.count === "number") {
+            return result.count;
+          }
+          return result ? 1 : 0;
         } catch (error) {
           console.error("Error updating event:", error);
           return 0;
@@ -2709,7 +2720,8 @@ var require_getConfig = __commonJS({
         "LINK_DATABASE_URL",
         "LINK_REPORT_BASE_URL",
         "LINK_REPORT_ADDRESS",
-        "LINK_RGB_HOST"
+        "LINK_RGB_HOST",
+        "LINK_EXTERNAL_NODES"
       ];
       const processConfig = {};
       ENV_KEYS.forEach((key) => {
@@ -5326,6 +5338,7 @@ var require_reportService = __commonJS({
 // business/service/nodeManage/config.js
 var require_config2 = __commonJS({
   "business/service/nodeManage/config.js"(exports2, module2) {
+    var path2 = require("node:path");
     var { getConfig: getConfig2 } = require_getConfig();
     function getBinaryName(baseName) {
       const isWindows = process.platform === "win32";
@@ -5484,18 +5497,18 @@ var require_config2 = __commonJS({
       const { LINK_BINARY_PATH } = config;
       return {
         litd: {
-          command: `${LINK_BINARY_PATH}/${getBinaryName("litd")}`,
+          command: path2.join(LINK_BINARY_PATH || "", getBinaryName("litd")),
           args: null,
           // Generated dynamically
           process: null
         },
         tor: {
-          command: `${LINK_BINARY_PATH}/${getBinaryName("tor")}`,
+          command: path2.join(LINK_BINARY_PATH || "", getBinaryName("tor")),
           args: buildTorArgs(),
           process: null
         },
         rgb: {
-          command: `${LINK_BINARY_PATH}/${getBinaryName("rgb-lightning-node")}`,
+          command: path2.join(LINK_BINARY_PATH || "", getBinaryName("rgb-lightning-node")),
           args: null,
           // Generated dynamically
           process: null
@@ -5518,10 +5531,16 @@ var require_processManager = __commonJS({
   "business/service/nodeManage/processManager.js"(exports2, module2) {
     var { spawn, exec } = require("node:child_process");
     var { getLightningService } = require_common();
+    var { getConfig: getConfig2 } = require_getConfig();
     var Logger = require_linkLogger();
     var { sleep } = require_timeUtils();
     var { getServiceConfig } = require_config2();
     var isWindows = process.platform === "win32";
+    function isExternalNodesMode() {
+      const config = getConfig2();
+      return config.LINK_EXTERNAL_NODES === "true" || config.LINK_EXTERNAL_NODES === true;
+    }
+    __name(isExternalNodesMode, "isExternalNodesMode");
     function findProcesses(processName) {
       return new Promise((resolve) => {
         let command;
@@ -5601,6 +5620,10 @@ var require_processManager = __commonJS({
     __name(setServiceProcess, "setServiceProcess");
     function startLitdService(args) {
       const logger2 = new Logger("processManager");
+      if (isExternalNodesMode()) {
+        logger2.info("External nodes mode: skipping litd local spawn (managed externally)");
+        return Promise.resolve(true);
+      }
       return new Promise((resolve, reject) => {
         const service = getService("litd");
         if (!service) {
@@ -5652,6 +5675,10 @@ var require_processManager = __commonJS({
     __name(startLitdService, "startLitdService");
     function startTorService(args) {
       const logger2 = new Logger("processManager");
+      if (isExternalNodesMode()) {
+        logger2.info("External nodes mode: skipping Tor local spawn (managed externally)");
+        return Promise.resolve(true);
+      }
       return new Promise((resolve, reject) => {
         const service = getService("tor");
         if (!service) {
@@ -5711,6 +5738,10 @@ var require_processManager = __commonJS({
     __name(startTorService, "startTorService");
     function startRgbService(args) {
       const logger2 = new Logger("processManager");
+      if (isExternalNodesMode()) {
+        logger2.info("External nodes mode: skipping RGB local spawn (managed externally)");
+        return Promise.resolve(true);
+      }
       return new Promise((resolve, reject) => {
         const service = getService("rgb");
         if (!service) {
@@ -5832,8 +5863,12 @@ var require_processManager = __commonJS({
     }
     __name(findAndKillProcess, "findAndKillProcess");
     async function stopLitdService() {
-      const initialService = getService("litd");
       const logger2 = new Logger("processManager");
+      if (isExternalNodesMode()) {
+        logger2.info("External nodes mode: skipping litd stop (managed externally)");
+        return true;
+      }
+      const initialService = getService("litd");
       if (!initialService) {
         throw new Error("litd service not found");
       }
@@ -5865,6 +5900,11 @@ var require_processManager = __commonJS({
     }
     __name(stopLitdService, "stopLitdService");
     async function stopTorService() {
+      const logger2 = new Logger("processManager");
+      if (isExternalNodesMode()) {
+        logger2.info("External nodes mode: skipping Tor stop (managed externally)");
+        return true;
+      }
       const service = getService("tor");
       if (!service) {
         throw new Error("tor service not found");
@@ -5878,6 +5918,10 @@ var require_processManager = __commonJS({
     __name(stopTorService, "stopTorService");
     async function stopRgbService() {
       const logger2 = new Logger("processManager");
+      if (isExternalNodesMode()) {
+        logger2.info("External nodes mode: skipping RGB stop (managed externally)");
+        return true;
+      }
       const service = getService("rgb");
       if (!service) {
         throw new Error("rgb service not found");
@@ -5885,15 +5929,27 @@ var require_processManager = __commonJS({
       try {
         logger2.info("Attempting graceful shutdown of RGB via SIGTERM...");
         const gracefulShutdown = new Promise((resolve) => {
-          exec(`pkill -SIGTERM -f 'rgb-lightning-node'`, (err, stdout) => {
-            if (!err) {
-              logger2.info(`RGB stopped gracefully: ${stdout}`);
-              resolve(true);
-            } else {
-              logger2.warn(`Graceful shutdown of RGB failed: ${err?.message}`);
-              resolve(false);
-            }
-          });
+          if (isWindows) {
+            exec(`taskkill /F /IM rgb-lightning-node.exe`, (err, stdout) => {
+              if (!err) {
+                logger2.info(`RGB stopped gracefully: ${stdout}`);
+                resolve(true);
+              } else {
+                logger2.warn(`Graceful shutdown of RGB failed: ${err?.message}`);
+                resolve(false);
+              }
+            });
+          } else {
+            exec(`pkill -SIGTERM -f 'rgb-lightning-node'`, (err, stdout) => {
+              if (!err) {
+                logger2.info(`RGB stopped gracefully: ${stdout}`);
+                resolve(true);
+              } else {
+                logger2.warn(`Graceful shutdown of RGB failed: ${err?.message}`);
+                resolve(false);
+              }
+            });
+          }
         });
         const gracefulResult = await gracefulShutdown;
         if (gracefulResult) {
@@ -6148,11 +6204,17 @@ var require_statusChecker = __commonJS({
   "business/service/nodeManage/statusChecker.js"(exports2, module2) {
     var findProcess = require("find-process").default;
     var { getWalletState } = require_common();
+    var { getConfig: getConfig2 } = require_getConfig();
     var { WALLET_STATE_CODE } = require_constants();
     var Logger = require_linkLogger();
     var { getNodeState } = require_node();
     var { getServiceConfig } = require_config2();
     var { getServicesState } = require_processManager();
+    function isExternalNodesMode() {
+      const config = getConfig2();
+      return config.LINK_EXTERNAL_NODES === "true" || config.LINK_EXTERNAL_NODES === true;
+    }
+    __name(isExternalNodesMode, "isExternalNodesMode");
     var ServiceStatus = {
       RUNNING: "Running",
       STOPPED: "Stopped"
@@ -6172,6 +6234,19 @@ var require_statusChecker = __commonJS({
     async function checkLitdProcess() {
       const logger2 = new Logger("statusChecker");
       try {
+        if (isExternalNodesMode()) {
+          logger2.info("External nodes mode: checking litd via RPC...");
+          try {
+            const walletState = await getWalletState();
+            if (walletState !== void 0 && walletState !== null) {
+              logger2.info(`Litd is running (wallet state: ${walletState})`);
+              return ServiceStatus.RUNNING;
+            }
+          } catch (rpcError) {
+            logger2.warn(`RPC check failed: ${rpcError.message}`);
+          }
+          return ServiceStatus.STOPPED;
+        }
         const processList = await findProcess("name", "litd");
         if (processList.length > 0) {
           logger2.info(`Found litd process(es): ${processList.map((p) => p.pid).join(", ")}`);
@@ -6187,6 +6262,19 @@ var require_statusChecker = __commonJS({
     async function checkRgbProcess() {
       const logger2 = new Logger("statusChecker");
       try {
+        if (isExternalNodesMode()) {
+          logger2.info("External nodes mode: checking RGB via SDK...");
+          try {
+            const nodeState = await getNodeState();
+            if (nodeState !== void 0 && nodeState !== null) {
+              logger2.info(`RGB is running (node state received)`);
+              return ServiceStatus.RUNNING;
+            }
+          } catch (sdkError) {
+            logger2.warn(`RGB SDK check failed: ${sdkError.message}`);
+          }
+          return ServiceStatus.STOPPED;
+        }
         const processList = await findProcess("name", "rgb-lightning-node");
         if (processList.length > 0) {
           logger2.info(`Found rgb-lightning-node process(es): ${processList.map((p) => p.pid).join(", ")}`);
@@ -7157,11 +7245,11 @@ var require_accountService = __commonJS({
         const lnLinkConfig = await getMainLnlinkConfig();
         const {
           node_npub,
-          settings,
-          npub: owner_npub
+          settings
         } = lnLinkConfig;
         const relay = settings?.nostrRelays ? settings?.nostrRelays?.[0] : null;
-        const sk = stringToFixedBytes(`${owner_npub}`).toString(
+        const READONLY_SALT = "lnlink_readonly_v1";
+        const sk = stringToFixedBytes(`${node_npub}:${READONLY_SALT}`).toString(
           "hex"
         );
         const pk = getPublicKey(sk);
@@ -7288,7 +7376,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "lnlink-server",
-      version: "1.0.1",
+      version: "1.0.2",
       private: false,
       main: "dist/index.js",
       files: [
@@ -7297,13 +7385,13 @@ var require_package = __commonJS({
       ],
       scripts: {
         build: "node build.js && node build.js --mode development --external all --entry electron",
-        "start:bin": 'dotenv -e .env.bin -- sh -c "prisma generate && (prisma migrate dev --name auto_update || prisma db push) && node ./scripts/binSetup.js && node ./app.js"',
+        "start:bin": "dotenv -e .env.bin -- node scripts/start-bin.js",
         "start:docker:dev": "dotenv -e .env.dev -- docker compose -f ./docker-compose.dev.yml up --build",
         "start:dev": 'dotenv -e .env.dev -- sh -c "prisma generate && (prisma migrate dev --name auto_update || prisma db push) && clinic heapprof -- node ./app.js"',
         "start:regtest": "docker compose --env-file ./.env.regtest -f ./docker-compose-lnlink.yml up --build",
         "start:testnet": "docker compose --env-file ./.env.testnet -f ./docker-compose-lnlink.yml up --build",
         "start:mainnet": "docker compose --env-file ./.env.mainnet -f ./docker-compose-lnlink.yml up --build",
-        "start:bin:dist": 'dotenv -e .env.bin -- sh -c "prisma generate && prisma migrate deploy && node ./scripts/binSetup.js && node ./dist/index.js"',
+        "start:bin:dist": "dotenv -e .env.bin -- node scripts/start-bin.js --dist",
         lint: "eslint .",
         "lint:fix": "eslint . --fix",
         "lint:staged": "lint-staged",
@@ -7325,6 +7413,7 @@ var require_package = __commonJS({
         axios: "^1.7.2",
         "bitcoin-core": "^4.2.0",
         "body-parser": "^1.20.2",
+        bolt11: "^1.4.1",
         "cookie-parser": "~1.4.4",
         "crypto-js": "^4.2.0",
         dayjs: "^1.11.10",
@@ -8381,8 +8470,49 @@ var require_lndService = __commonJS({
       return ret;
     }
     __name(startLink, "startLink");
+    async function toggleTor(args) {
+      const logger2 = new Logger("lnd");
+      const { enable, lnlinkUser } = args;
+      if (enable === void 0 || enable === null) {
+        throw new Error("enable parameter is required (true or false)");
+      }
+      const enableTor = enable === true || enable === "true";
+      logger2.info(`Toggling Tor mode to: ${enableTor}, requested by: ${lnlinkUser?.npub || "unknown"}`);
+      try {
+        const { updateMainLnlinkConfig: updateConfig } = require_dbService();
+        const updateRet = await updateConfig({ enable_tor: enableTor });
+        if (updateRet !== 1) {
+          logger2.warn(`Database update returned: ${updateRet}, proceeding anyway`);
+        }
+        const { reloadConfig } = require_getConfig();
+        await reloadConfig();
+        const { restartTerminal, stopService: stopTor, isServiceRunning: isTorRunning } = require_nodeManage();
+        if (!enableTor) {
+          const torRunning = await isTorRunning("tor");
+          if (torRunning) {
+            logger2.info("Stopping Tor service...");
+            await stopTor("tor");
+          }
+        }
+        logger2.info("Restarting litd with new Tor configuration...");
+        const terminalStatus = await restartTerminal({ lnlinkUser });
+        const nodeInfo = await getNodeInfo();
+        logger2.info(`Tor mode toggled successfully. Tor enabled: ${enableTor}`);
+        return {
+          enable_tor: enableTor,
+          status: "ok",
+          terminal_status: terminalStatus,
+          node_info: nodeInfo
+        };
+      } catch (error) {
+        logger2.error(`Failed to toggle Tor: ${error.message}`);
+        throw error;
+      }
+    }
+    __name(toggleTor, "toggleTor");
     module2.exports = {
       startLink,
+      toggleTor,
       getWalletState,
       sendPaymentSync,
       createLnInvoice,
@@ -8457,6 +8587,7 @@ var require_tapdService = __commonJS({
     } = require_dbService();
     var { reportTaskCompletion } = require_reportService();
     var TaprootAssetsInstance = require_instance2();
+    var { decode } = require("bolt11");
     var syncUniverse = withChecks(async (args) => {
       const { LINK_UNIVERSE_HOST } = getConfig2();
       const {
@@ -8941,6 +9072,14 @@ var require_tapdService = __commonJS({
       if (outgoing_chan_id) {
         paymentRequest.outgoing_chan_id = `${outgoing_chan_id}`;
       }
+      const decodedInvoice = decode(payment_request);
+      const routingInfo = decodedInvoice.tags.find((tag) => tag.tagName === "routing_info");
+      if (routingInfo && routingInfo.data && routingInfo.data.length > 0) {
+        const lastHop = routingInfo.data[routingInfo.data.length - 1];
+        if (lastHop.pubkey) {
+          paymentRequest.last_hop_pubkey = Buffer2.from(lastHop.pubkey, "hex");
+        }
+      }
       const sendParams = {
         asset_amount,
         asset_id: Buffer2.from(asset_id, "hex"),
@@ -9227,30 +9366,40 @@ var require_constants2 = __commonJS({
   "nostr/config/constants.js"(exports2, module2) {
     var EVENT_PROCESSING_CONSTANTS = {
       // Error handling
-      MAX_CONSECUTIVE_ERRORS: 5,
-      ERROR_BACKOFF_TIME: 5e3,
+      MAX_CONSECUTIVE_ERRORS: 10,
+      ERROR_BACKOFF_TIME: 2e3,
       MAX_FATAL_ERRORS: 10,
-      MAX_BACKOFF_TIME: 6e4,
-      // 60 seconds max backoff
-      // Timeout settings
+      MAX_BACKOFF_TIME: 3e4,
+      // 30 seconds max backoff (reduced from 60s)
+      // Timeout settings - increased for litd/rgb unlock operations (30-50s)
       EVENT_PROCESSING_TIMEOUT: 60 * 1e3,
-      // 60 seconds
-      // Concurrent processing settings
-      MAX_CONCURRENT_EVENTS: 3,
-      // Maximum concurrent event processing
-      CONCURRENT_BATCH_SIZE: 5,
-      // How many events to fetch at once
+      // 60 seconds (to support litd/rgb unlock)
+      // Concurrent processing settings - INCREASED for better throughput
+      MAX_CONCURRENT_EVENTS: 10,
+      // Increased from 3 to 10
+      CONCURRENT_BATCH_SIZE: 15,
+      // Increased from 5 to 15
       // Batch processing settings
-      BATCH_SIZE: 2,
-      // Sleep intervals
-      NORMAL_SLEEP: 300,
-      // Normal processing interval
-      IDLE_SLEEP: 500,
-      // Idle sleep time
-      ERROR_SLEEP: 1e3,
-      // Sleep time after error
-      FATAL_ERROR_SLEEP: 3e3
-      // Sleep time after fatal error
+      BATCH_SIZE: 10,
+      // Increased from 2 to 10
+      // Sleep intervals - REDUCED for lower latency
+      NORMAL_SLEEP: 50,
+      // Reduced from 300ms to 50ms
+      IDLE_SLEEP: 200,
+      // Reduced from 500ms to 200ms
+      ERROR_SLEEP: 500,
+      // Reduced from 1000ms
+      FATAL_ERROR_SLEEP: 2e3,
+      // Reduced from 3000ms
+      // Rate limiting - INCREASED throughput
+      RATE_LIMIT_REQUESTS: 10,
+      // Increased from 2 to 10 requests
+      RATE_LIMIT_WINDOW: 1e3,
+      // Per second
+      // Memory queue settings
+      MEMORY_QUEUE_MAX_SIZE: 1e3,
+      DB_RECOVERY_INTERVAL: 5e3
+      // Check DB for missed events every 5s
     };
     var CONNECTION_CONSTANTS = {
       MAX_RECONNECT_ATTEMPTS: 100,
@@ -11318,42 +11467,42 @@ var require_info = __commonJS({
       let stateValue = null;
       if (serviceRunning) {
         const rgbClient = getRgbClient();
-        const [
-          nodeInfoResult,
-          stateResult,
-          balanceResult,
-          peersResult
-        ] = await Promise.allSettled([
-          rgbClient.node.getNodeInfo(),
-          getNodeState(),
-          rgbClient.onchain.getBtcBalance({
-            skip_sync: false
-          }),
-          rgbClient.lightning.listPeers({})
-        ]);
-        if (stateResult.status === "fulfilled") {
-          stateValue = stateResult.value?.state ?? null;
-        } else {
-          logger2.warn(`getCombinedNodeInfo - getNodeState failed: ${stateResult.reason?.message || stateResult.reason}`);
-        }
-        if (nodeInfoResult.status === "fulfilled") {
-          nodeInfo = nodeInfoResult.value;
-        } else {
-          logger2.warn(`getCombinedNodeInfo - getNodeInfo failed: ${nodeInfoResult.reason?.message || nodeInfoResult.reason}`);
-        }
-        if (balanceResult.status === "fulfilled") {
-          balance = balanceResult.value;
-        } else {
-          logger2.warn(`getCombinedNodeInfo - getBtcBalance failed: ${balanceResult.reason?.message || balanceResult.reason}`);
-        }
-        if (peersResult.status === "fulfilled") {
-          peers = peersResult.value?.peers ?? [];
-        } else {
-          logger2.warn(`getCombinedNodeInfo - listPeers failed: ${peersResult.reason?.message || peersResult.reason}`);
+        const stateResult = await getNodeState().catch((error) => {
+          logger2.warn(`getCombinedNodeInfo - getNodeState failed: ${error.message}`);
+          return { state: 0 };
+        });
+        stateValue = stateResult?.state ?? null;
+        if (stateValue === 4) {
+          const [
+            nodeInfoResult,
+            balanceResult,
+            peersResult
+          ] = await Promise.allSettled([
+            rgbClient.node.getNodeInfo(),
+            rgbClient.onchain.getBtcBalance({
+              skip_sync: false
+            }),
+            rgbClient.lightning.listPeers({})
+          ]);
+          if (nodeInfoResult.status === "fulfilled") {
+            nodeInfo = nodeInfoResult.value;
+          } else {
+            logger2.warn(`getCombinedNodeInfo - getNodeInfo failed: ${nodeInfoResult.reason?.message || nodeInfoResult.reason}`);
+          }
+          if (balanceResult.status === "fulfilled") {
+            balance = balanceResult.value;
+          } else {
+            logger2.warn(`getCombinedNodeInfo - getBtcBalance failed: ${balanceResult.reason?.message || balanceResult.reason}`);
+          }
+          if (peersResult.status === "fulfilled") {
+            peers = peersResult.value?.peers ?? [];
+          } else {
+            logger2.warn(`getCombinedNodeInfo - listPeers failed: ${peersResult.reason?.message || peersResult.reason}`);
+          }
+          rgbClient.rgb.refreshTransfers({ skip_sync: false }).catch((error) => {
+            logger2.warn(`getCombinedNodeInfo - refreshTransfers failed: ${error.message}`);
+          });
         }
-        rgbClient.rgb.refreshTransfers({ skip_sync: false }).catch((error) => {
-          logger2.warn(`getCombinedNodeInfo - refreshTransfers failed: ${error.message}`);
-        });
       }
       const readOnlyAccount = await getLnlinkUser({
         account_type: ACCOUNT_TYPE.READ_ONLY
@@ -13013,7 +13162,7 @@ var require_eventProcessor = __commonJS({
     __name(parseAndExecute, "parseAndExecute");
     async function parseEvent(event, sk) {
       const content = event.content;
-      const subFrom = event.from;
+      const subFrom = event.from || event.pubkey;
       const decryptContent = await nip04.decrypt(sk, subFrom, content);
       if (event.kind === NWC_CONSTANTS.REQUEST_KIND) {
         await handleNWCRequest(event, sk, subFrom, decryptContent);
@@ -13062,21 +13211,25 @@ var require_eventProcessor = __commonJS({
         replyEventId: event.event_id,
         kind: NWC_CONSTANTS.RESPONSE_KIND
       });
-      const updateSuccess = await safeUpdateEvent(event.id, {
-        status: EVENT_HANDLE_STATUS.SUCCESS,
-        reply_event_id: replyEvent.id
-      });
-      if (!updateSuccess) {
-        throw new Error("Failed to update event status to success");
+      if (typeof event.id === "number") {
+        const updateId = event.event_id || event.id;
+        const updateSuccess = await safeUpdateEvent(updateId, {
+          status: EVENT_HANDLE_STATUS.SUCCESS,
+          reply_event_id: replyEvent.id
+        });
+        if (!updateSuccess) {
+          const logger2 = new Logger("nostr-events");
+          logger2.warn(`Failed to update event ${updateId} status, possibly not in DB yet`);
+        }
       }
     }
     __name(handleNWCRequest, "handleNWCRequest");
     async function handleDirectMessage(event, sk, subFrom, decryptContent) {
-      const tags = JSON.parse(event.tags);
+      const tags = typeof event.tags === "string" ? JSON.parse(event.tags) : event.tags;
       const replyProxyAddr = tags?.find((item) => item?.[0] === "a")?.[1];
       const replyTo = replyProxyAddr || subFrom;
       const content = decryptContent;
-      const retMsg = await parseAndExecute(content, subFrom, event.event_id);
+      const retMsg = await parseAndExecute(content, subFrom, event.event_id || event.id);
       if (retMsg) {
         const replyEvent = await execSendMessage({
           message: retMsg,
@@ -13084,12 +13237,16 @@ var require_eventProcessor = __commonJS({
           robotPrivatekey: sk,
           replyEventId: event.event_id
         });
-        const updateSuccess = await safeUpdateEvent(event.id, {
-          status: EVENT_HANDLE_STATUS.SUCCESS,
-          reply_event_id: replyEvent.id
-        });
-        if (!updateSuccess) {
-          throw new Error("Failed to update event status to success");
+        if (typeof event.id === "number") {
+          const updateId = event.event_id || event.id;
+          const updateSuccess = await safeUpdateEvent(updateId, {
+            status: EVENT_HANDLE_STATUS.SUCCESS,
+            reply_event_id: replyEvent.id
+          });
+          if (!updateSuccess) {
+            const logger2 = new Logger("nostr-events");
+            logger2.warn(`Failed to update event ${updateId} status, possibly not in DB yet`);
+          }
         }
       }
     }
@@ -13129,28 +13286,33 @@ var require_eventProcessor = __commonJS({
     }
     __name(safeUpdateEvent, "safeUpdateEvent");
     async function processSingleEvent(event, sk) {
-      const eventId = event.id;
+      const eventId = event.event_id || event.id;
       const logger2 = new Logger("nostr-events");
+      const isFromMemoryQueue = !event.isRecovery && typeof event.id === "number";
       try {
-        const claimed = await safeUpdateEvent(eventId, {
-          status: EVENT_HANDLE_STATUS.REPLYING
-        });
-        if (!claimed) {
-          logger2.debug(`Event ${eventId} could not be claimed, possibly already processing`);
-          return false;
+        if (!isFromMemoryQueue && typeof event.id === "number") {
+          const claimed = await safeUpdateEvent(eventId, {
+            status: EVENT_HANDLE_STATUS.REPLYING
+          });
+          if (!claimed) {
+            logger2.debug(`Event ${eventId} could not be claimed, possibly already processing`);
+            return false;
+          }
+          logger2.debug(`Successfully claimed event ${eventId} for processing`);
         }
-        logger2.debug(`Successfully claimed event ${eventId} for processing`);
         await parseEvent(event, sk);
         return true;
       } catch (e) {
         logger2.error(`Error processing event ${eventId}: ${e.message}`);
-        try {
-          await safeUpdateEvent(eventId, {
-            status: EVENT_HANDLE_STATUS.ERROR,
-            reply_err: e.message
-          });
-        } catch (updateError) {
-          logger2.error(`Failed to update event ${eventId} status to error: ${updateError.message}`);
+        if (!isFromMemoryQueue && typeof event.id === "number") {
+          try {
+            await safeUpdateEvent(eventId, {
+              status: EVENT_HANDLE_STATUS.ERROR,
+              reply_err: e.message
+            });
+          } catch (updateError) {
+            logger2.error(`Failed to update event ${eventId} status to error: ${updateError.message}`);
+          }
         }
         return false;
       }
@@ -13244,7 +13406,7 @@ var require_eventLoop = __commonJS({
           this.recordError();
           if (error.message.includes("timeout")) {
             try {
-              await updateEvent(event.id, {
+              await updateEvent(event.event_id || event.id, {
                 status: EVENT_HANDLE_STATUS.ERROR,
                 reply_err: error.message
               });
@@ -13347,7 +13509,10 @@ var require_eventLoop = __commonJS({
       }
     };
     async function intervalParseEvent(stopSignal = { stop: false }) {
-      const rateLimiter = new RateLimiter(2, 1e3);
+      const rateLimiter = new RateLimiter(
+        EVENT_PROCESSING_CONSTANTS.RATE_LIMIT_REQUESTS || 10,
+        EVENT_PROCESSING_CONSTANTS.RATE_LIMIT_WINDOW || 1e3
+      );
       const processor = new ConcurrentEventProcessor(
         EVENT_PROCESSING_CONSTANTS.MAX_CONCURRENT_EVENTS,
         rateLimiter
@@ -13436,6 +13601,396 @@ var require_eventLoop = __commonJS({
   }
 });
 
+// nostr/events/eventQueue.js
+var require_eventQueue = __commonJS({
+  "nostr/events/eventQueue.js"(exports2, module2) {
+    var { EventEmitter: EventEmitter2 } = require("node:events");
+    var Logger = require_linkLogger();
+    var PRIORITY = {
+      HIGH: 1,
+      // NWC requests (23194) - user payments
+      NORMAL: 2,
+      // Direct messages (4) - user commands
+      LOW: 3
+      // Other events
+    };
+    function getPriorityForKind(kind) {
+      switch (kind) {
+        case 23194:
+          return PRIORITY.HIGH;
+        case 4:
+          return PRIORITY.NORMAL;
+        default:
+          return PRIORITY.LOW;
+      }
+    }
+    __name(getPriorityForKind, "getPriorityForKind");
+    var EventQueue = class extends EventEmitter2 {
+      static {
+        __name(this, "EventQueue");
+      }
+      constructor(options = {}) {
+        super();
+        this.maxSize = options.maxSize || 1e3;
+        this.highPriorityQueue = [];
+        this.normalPriorityQueue = [];
+        this.lowPriorityQueue = [];
+        this.processingSet = /* @__PURE__ */ new Set();
+        this.logger = new Logger("event-queue");
+        this.stats = {
+          enqueued: 0,
+          processed: 0,
+          dropped: 0,
+          duplicates: 0
+        };
+      }
+      /**
+       * Get total queue size
+       */
+      get size() {
+        return this.highPriorityQueue.length + this.normalPriorityQueue.length + this.lowPriorityQueue.length;
+      }
+      /**
+       * Check if event is already in queue or being processed
+       * @param {string} eventId - Event ID
+       */
+      has(eventId) {
+        if (this.processingSet.has(eventId)) {
+          return true;
+        }
+        return this.highPriorityQueue.some((e) => e.id === eventId) || this.normalPriorityQueue.some((e) => e.id === eventId) || this.lowPriorityQueue.some((e) => e.id === eventId);
+      }
+      /**
+       * Add event to queue
+       * @param {object} event - Event object with id, kind, content, etc.
+       * @param {object} options - Additional options
+       * @returns {boolean} Whether event was added
+       */
+      enqueue(event, options = {}) {
+        const eventId = event.id || event.event_id;
+        if (this.has(eventId)) {
+          this.stats.duplicates++;
+          return false;
+        }
+        if (this.size >= this.maxSize) {
+          if (this.lowPriorityQueue.length > 0) {
+            const dropped = this.lowPriorityQueue.shift();
+            this.logger.warn(`Queue full, dropping low priority event: ${dropped.id}`);
+            this.stats.dropped++;
+          } else if (this.normalPriorityQueue.length > 0) {
+            const dropped = this.normalPriorityQueue.shift();
+            this.logger.warn(`Queue full, dropping normal priority event: ${dropped.id}`);
+            this.stats.dropped++;
+          } else {
+            this.logger.error(`Queue full with only high priority events, dropping new event: ${eventId}`);
+            this.stats.dropped++;
+            return false;
+          }
+        }
+        const priority = options.priority || getPriorityForKind(event.kind);
+        const queueItem = {
+          ...event,
+          id: eventId,
+          enqueuedAt: Date.now(),
+          priority,
+          ...options
+        };
+        switch (priority) {
+          case PRIORITY.HIGH:
+            this.highPriorityQueue.push(queueItem);
+            break;
+          case PRIORITY.NORMAL:
+            this.normalPriorityQueue.push(queueItem);
+            break;
+          default:
+            this.lowPriorityQueue.push(queueItem);
+        }
+        this.stats.enqueued++;
+        this.emit("enqueue", queueItem);
+        return true;
+      }
+      /**
+       * Get next event to process (respects priority)
+       * @returns {object|null} Next event or null if empty
+       */
+      dequeue() {
+        let event = null;
+        if (this.highPriorityQueue.length > 0) {
+          event = this.highPriorityQueue.shift();
+        } else if (this.normalPriorityQueue.length > 0) {
+          event = this.normalPriorityQueue.shift();
+        } else if (this.lowPriorityQueue.length > 0) {
+          event = this.lowPriorityQueue.shift();
+        }
+        if (event) {
+          this.processingSet.add(event.id);
+        }
+        return event;
+      }
+      /**
+       * Mark event as done processing
+       * @param {string} eventId - Event ID
+       */
+      markDone(eventId) {
+        this.processingSet.delete(eventId);
+        this.stats.processed++;
+      }
+      /**
+       * Get multiple events at once
+       * @param {number} count - Number of events to get
+       * @returns {Array} Array of events
+       */
+      dequeueBatch(count) {
+        const events = [];
+        for (let i = 0; i < count; i++) {
+          const event = this.dequeue();
+          if (!event)
+            break;
+          events.push(event);
+        }
+        return events;
+      }
+      /**
+       * Get queue statistics
+       * @returns {object} Queue statistics object
+       */
+      getStats() {
+        return {
+          ...this.stats,
+          currentSize: this.size,
+          highPriority: this.highPriorityQueue.length,
+          normalPriority: this.normalPriorityQueue.length,
+          lowPriority: this.lowPriorityQueue.length,
+          processing: this.processingSet.size
+        };
+      }
+      /**
+       * Clear all queues
+       */
+      clear() {
+        this.highPriorityQueue = [];
+        this.normalPriorityQueue = [];
+        this.lowPriorityQueue = [];
+        this.processingSet.clear();
+      }
+    };
+    var queueInstance = null;
+    function getEventQueue() {
+      if (!queueInstance) {
+        queueInstance = new EventQueue({ maxSize: 1e3 });
+      }
+      return queueInstance;
+    }
+    __name(getEventQueue, "getEventQueue");
+    module2.exports = {
+      EventQueue,
+      getEventQueue,
+      PRIORITY,
+      getPriorityForKind
+    };
+  }
+});
+
+// nostr/events/immediateProcessor.js
+var require_immediateProcessor = __commonJS({
+  "nostr/events/immediateProcessor.js"(exports2, module2) {
+    var { EventEmitter: EventEmitter2 } = require("node:events");
+    var {
+      updateEvent,
+      getUnReplyEvents
+    } = require_dbService();
+    var { sleep } = require_utils2();
+    var Logger = require_linkLogger();
+    var { EVENT_HANDLE_STATUS } = require_constants();
+    var { EVENT_PROCESSING_CONSTANTS } = require_constants2();
+    var { processSingleEvent } = require_eventProcessor();
+    var { getEventQueue, PRIORITY } = require_eventQueue();
+    var ImmediateProcessor = class extends EventEmitter2 {
+      static {
+        __name(this, "ImmediateProcessor");
+      }
+      constructor(options = {}) {
+        super();
+        this.maxWorkers = options.maxWorkers || EVENT_PROCESSING_CONSTANTS.MAX_CONCURRENT_EVENTS;
+        this.activeWorkers = 0;
+        this.isRunning = false;
+        this.queue = getEventQueue();
+        this.logger = new Logger("immediate-processor");
+        this.sk = null;
+        this.stats = {
+          processed: 0,
+          succeeded: 0,
+          failed: 0,
+          timeouts: 0
+        };
+        this.processingMap = /* @__PURE__ */ new Map();
+      }
+      /**
+       * Start the processor
+       * @param {string} sk - Private key for signing responses
+       */
+      start(sk) {
+        if (this.isRunning) {
+          this.logger.warn("Processor already running");
+          return;
+        }
+        this.sk = sk;
+        this.isRunning = true;
+        this.logger.info(`ImmediateProcessor started with ${this.maxWorkers} workers`);
+        this.queue.on("enqueue", () => this.tryProcessNext());
+        this.startDBRecoveryLoop();
+      }
+      /**
+       * Stop the processor
+       */
+      async stop() {
+        this.isRunning = false;
+        this.queue.removeAllListeners("enqueue");
+        const timeout = 3e4;
+        const startTime = Date.now();
+        while (this.activeWorkers > 0 && Date.now() - startTime < timeout) {
+          this.logger.info(`Waiting for ${this.activeWorkers} workers to complete...`);
+          await sleep(1e3);
+        }
+        if (this.activeWorkers > 0) {
+          this.logger.warn(`Timeout waiting for ${this.activeWorkers} workers`);
+        }
+        this.logger.info("ImmediateProcessor stopped");
+      }
+      /**
+       * Try to start processing next event if workers available
+       */
+      tryProcessNext() {
+        if (!this.isRunning) {
+          return;
+        }
+        while (this.activeWorkers < this.maxWorkers && this.queue.size > 0) {
+          const event = this.queue.dequeue();
+          if (event) {
+            this.processEvent(event);
+          } else {
+            break;
+          }
+        }
+      }
+      /**
+       * Process a single event
+       * @param {object} event - Event to process
+       */
+      async processEvent(event) {
+        this.activeWorkers++;
+        const eventId = event.id || event.event_id;
+        const startTime = Date.now();
+        this.processingMap.set(eventId, startTime);
+        this.logger.debug(`Processing event ${eventId} (workers: ${this.activeWorkers}/${this.maxWorkers})`);
+        try {
+          let timeoutId;
+          const timeoutPromise = new Promise((_, reject) => {
+            timeoutId = setTimeout(
+              () => reject(new Error("Event processing timeout")),
+              EVENT_PROCESSING_CONSTANTS.EVENT_PROCESSING_TIMEOUT
+            );
+          });
+          try {
+            await Promise.race([
+              processSingleEvent(event, this.sk),
+              timeoutPromise
+            ]);
+            this.stats.succeeded++;
+            this.logger.debug(`Event ${eventId} processed in ${Date.now() - startTime}ms`);
+          } finally {
+            clearTimeout(timeoutId);
+          }
+        } catch (error) {
+          this.stats.failed++;
+          this.logger.error(`Failed to process event ${eventId}: ${error.message}`);
+          if (error.message.includes("timeout")) {
+            this.stats.timeouts++;
+            try {
+              await updateEvent(event.id, {
+                status: EVENT_HANDLE_STATUS.ERROR,
+                reply_err: error.message
+              });
+            } catch (updateError) {
+              this.logger.error(`Failed to update event status: ${updateError.message}`);
+            }
+          }
+        } finally {
+          this.stats.processed++;
+          this.processingMap.delete(eventId);
+          this.queue.markDone(eventId);
+          this.activeWorkers--;
+          this.tryProcessNext();
+        }
+      }
+      /**
+       * Add event directly (called from connection manager)
+       * @param {object} event - Raw nostr event
+       * @param {object} options - Additional options
+       * @returns {boolean} Whether event was added
+       */
+      addEvent(event, options = {}) {
+        return this.queue.enqueue(event, options);
+      }
+      /**
+       * Start DB recovery loop to catch missed events
+       */
+      startDBRecoveryLoop() {
+        const recoveryLoop = /* @__PURE__ */ __name(async () => {
+          while (this.isRunning) {
+            try {
+              if (this.queue.size < EVENT_PROCESSING_CONSTANTS.MEMORY_QUEUE_MAX_SIZE / 2) {
+                const missedEvents = await getUnReplyEvents(
+                  EVENT_PROCESSING_CONSTANTS.BATCH_SIZE
+                );
+                for (const event of missedEvents) {
+                  this.queue.enqueue(event, { priority: PRIORITY.LOW, isRecovery: true });
+                }
+                if (missedEvents.length > 0) {
+                  this.logger.debug(`Recovered ${missedEvents.length} events from DB`);
+                  this.tryProcessNext();
+                }
+              }
+            } catch (error) {
+              this.logger.error(`DB recovery error: ${error.message}`);
+            }
+            await sleep(EVENT_PROCESSING_CONSTANTS.DB_RECOVERY_INTERVAL);
+          }
+        }, "recoveryLoop");
+        recoveryLoop();
+      }
+      /**
+       * Get processor statistics
+       * @returns {object} Statistics object
+       */
+      getStats() {
+        return {
+          ...this.stats,
+          activeWorkers: this.activeWorkers,
+          maxWorkers: this.maxWorkers,
+          queueStats: this.queue.getStats(),
+          processing: Array.from(this.processingMap.entries()).map(([id, time]) => ({
+            id,
+            duration: Date.now() - time
+          }))
+        };
+      }
+    };
+    var processorInstance = null;
+    function getImmediateProcessor() {
+      if (!processorInstance) {
+        processorInstance = new ImmediateProcessor();
+      }
+      return processorInstance;
+    }
+    __name(getImmediateProcessor, "getImmediateProcessor");
+    module2.exports = {
+      ImmediateProcessor,
+      getImmediateProcessor
+    };
+  }
+});
+
 // nostr/connection/connectionManager.js
 var require_connectionManager = __commonJS({
   "nostr/connection/connectionManager.js"(exports2, module2) {
@@ -13457,6 +14012,8 @@ var require_connectionManager = __commonJS({
       CONNECTION_CONSTANTS
     } = require_constants2();
     var { intervalParseEvent } = require_eventLoop();
+    var { getEventQueue, PRIORITY } = require_eventQueue();
+    var { getImmediateProcessor } = require_immediateProcessor();
     var {
       getRelays,
       execSendMessage,
@@ -13729,6 +14286,7 @@ var require_connectionManager = __commonJS({
     };
     function createEventHandler(lndConfig, manager) {
       const logger2 = new Logger("nostr");
+      const eventQueue = getEventQueue();
       return async (event) => {
         try {
           manager.lastEventReceived = Date.now();
@@ -13743,18 +14301,25 @@ var require_connectionManager = __commonJS({
               pubkey: event.pubkey
             });
             if (user) {
-              const ret = await insertEvent(event).catch((e) => {
-                logger2.error(`Nostr eventHandler ${event.id} error: ${e.message}`);
-                return 0;
+              const priority = event.kind === 23194 ? PRIORITY.HIGH : PRIORITY.NORMAL;
+              const enqueued = eventQueue.enqueue(event, { priority });
+              insertEvent(event).then((ret) => {
+                if (ret > 0) {
+                  logger2.debug(`Event ${event.id} persisted to DB`);
+                }
+              }).catch((e) => {
+                logger2.error(`Nostr eventHandler ${event.id} DB error: ${e.message}`);
               });
-              logger2.info(
-                `Nostr event:${event.id} stored ${ret > 0 ? "success" : "failed"}`
-              );
+              if (enqueued) {
+                logger2.info(`Event ${event.id} queued for immediate processing (priority: ${priority})`);
+              } else {
+                logger2.warn(`Event ${event.id} duplicate or queue full`);
+              }
             } else {
               const tags = event.tags;
               const replyProxyAddr = tags?.find((item) => item?.[0] === "a")?.[1];
               const replyTo = replyProxyAddr || event.pubkey;
-              await execSendMessage({
+              execSendMessage({
                 message: JSON.stringify({
                   code: ERROR_CODES.FORBIDDEN,
                   data: null,
@@ -13865,11 +14430,14 @@ var require_connectionManager = __commonJS({
           }
         }, 45e3);
         const stopSignal = { stop: false };
+        const immediateProcessor = getImmediateProcessor();
+        immediateProcessor.start(lndConfig.node_sk);
         intervalParseEvent(stopSignal);
         manager.addService({
-          stop: /* @__PURE__ */ __name(() => {
+          stop: /* @__PURE__ */ __name(async () => {
             stopSignal.stop = true;
             clearInterval(monitorInterval);
+            await immediateProcessor.stop();
           }, "stop")
         });
         return {
@@ -18579,7 +19147,8 @@ var require_setting_regtest = __commonJS({
       bitcoindZmqRawTx: "tcp://regtest.lnfi.network:28335",
       network: "regtest",
       nostrRelays: [
-        "wss://relay01.lnfi.network"
+        "wss://relay01.lnfi.network",
+        "wss://relay02.lnfi.network"
       ],
       officialLndPeer: "03b24a4bf911ffd26ac1d5e5f2440a3c2f6974e4cc85d2ef54e17ee6d3717433d3",
       officialLndPeerHost: "34.84.66.29:7739",
@@ -18761,7 +19330,7 @@ var LnLink = class extends EventEmitter {
    */
   _ensureEnvironmentAndPrisma() {
     if (!process.env.LINK_DATABASE_URL) {
-      const dbPath = path.join(this.options.dataPath, "link", "lnlink.db");
+      const dbPath = path.join(this.options.dataPath, ".link", "lnlink.db");
       process.env.LINK_DATABASE_URL = `file:${dbPath}`;
       console.log(`\u{1F5C4}\uFE0F Setting database URL: ${dbPath}`);
     }