lnlink-server 1.0.7 → 1.0.8

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "buildTime": "2026-02-04T01:47:26.492Z",
+  "buildTime": "2026-02-04T10:13:35.044Z",
   "mode": "development",
   "bundle": "single",
   "external": "all",
@@ -25,6 +25,7 @@
     "form-data",
     "http-errors",
     "jest",
+    "lnlink-server",
     "long",
     "module-alias",
     "morgan",

package/dist/index.js

@@ -7054,7 +7054,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "lnlink-server",
-      version: "1.0.7",
+      version: "1.0.8",
       private: false,
       main: "dist/index.js",
       files: [
@@ -7105,6 +7105,7 @@ var require_package = __commonJS({
         "form-data": "^4.0.2",
         "http-errors": "~1.6.3",
         jest: "^29.6.2",
+        "lnlink-server": "1.0.7",
         long: "^5.2.3",
         "module-alias": "^2.2.3",
         morgan: "~1.9.1",
@@ -13450,54 +13451,101 @@ var require_eventProcessor = __commonJS({
             msg: RESPONSE_MESSAGES.INVALID_JSON
           });
         }
-        if (!obj.method) {
+        const executeCall = /* @__PURE__ */ __name(async (method, params = {}, node_type = "lnd") => {
+          if (!method) {
+            return {
+              code: ERROR_CODES.MISSING_METHOD,
+              data: null,
+              msg: RESPONSE_MESSAGES.MISSING_METHOD
+            };
+          }
+          const toLineMethod = toLine(method);
+          logger2.info(`parseAndExecute method: ${method}  node_type: ${node_type},from: ${nip19.npubEncode(subFrom)}`);
+          const { authValid, lnlinkUser } = await preCallAuth(toLineMethod, "", subFrom, "");
+          if (!authValid) {
+            return {
+              code: ERROR_CODES.FORBIDDEN,
+              data: null,
+              msg: RESPONSE_MESSAGES.READONLY_FORBIDDEN
+            };
+          }
+          const callParams = {
+            ...params,
+            event_id: eventId,
+            lnlinkUser
+          };
+          let proxy = null;
+          if (node_type === "lnd") {
+            if (!lndProxies[toLineMethod]) {
+              return {
+                code: ERROR_CODES.METHOD_NOT_SUPPORTED,
+                data: null,
+                msg: `Method '${toLineMethod}' not supported`
+              };
+            }
+            proxy = await lndProxies[toLineMethod]();
+          } else if (node_type === "rgb") {
+            if (!rgbProxies[toLineMethod]) {
+              return {
+                code: ERROR_CODES.METHOD_NOT_SUPPORTED,
+                data: null,
+                msg: `Method '${toLineMethod}' not supported`
+              };
+            }
+            proxy = await rgbProxies[toLineMethod]();
+          } else {
+            return {
+              code: ERROR_CODES.METHOD_NOT_SUPPORTED,
+              data: null,
+              msg: `Node type '${node_type}' not supported`
+            };
+          }
+          logger2.info(`Executing ${node_type}.${toLineMethod}...`);
+          const ret = await proxy.method(callParams);
+          logger2.info(`Executed ${node_type}.${toLineMethod} successfully`);
+          return {
+            code: 0,
+            data: ret,
+            msg: RESPONSE_MESSAGES.SUCCESS
+          };
+        }, "executeCall");
+        if (obj.method) {
+          const {
+            method,
+            params,
+            node_type = "lnd"
+          } = obj;
+          const result = await executeCall(method, params, node_type);
+          return JSON.stringify(result);
+        }
+        if (!Array.isArray(obj.method_list)) {
           return JSON.stringify({
             code: ERROR_CODES.MISSING_METHOD,
             data: null,
             msg: RESPONSE_MESSAGES.MISSING_METHOD
           });
         }
-        const {
-          method,
-          params,
-          node_type = "lnd"
-        } = obj;
-        const toLineMethod = toLine(method);
-        logger2.info(`parseAndExecute method: ${method}  node_type: ${node_type},from: ${nip19.npubEncode(subFrom)}`);
-        const { authValid, lnlinkUser } = await preCallAuth(toLineMethod, "", subFrom, "");
-        if (!authValid) {
-          return JSON.stringify({
-            code: ERROR_CODES.FORBIDDEN,
-            data: null,
-            msg: RESPONSE_MESSAGES.READONLY_FORBIDDEN
-          });
-        }
-        const callParams = {
-          ...params,
-          event_id: eventId,
-          lnlinkUser
-        };
-        let proxy = null;
-        if (node_type === "lnd") {
-          if (!lndProxies[toLineMethod]) {
-            return JSON.stringify({
-              code: ERROR_CODES.METHOD_NOT_SUPPORTED,
-              data: null,
-              msg: `Method '${toLineMethod}' not supported`
-            });
+        const results = await Promise.allSettled(
+          obj.method_list.map((item) => executeCall(item?.method, item?.params, item?.node_type))
+        );
+        const responseList = results.map((result, index) => {
+          const method = obj.method_list[index]?.method;
+          if (result.status === "fulfilled") {
+            return {
+              method,
+              ...result.value
+            };
           }
-          proxy = await lndProxies[toLineMethod]();
-        } else if (node_type === "rgb") {
-          proxy = await rgbProxies[toLineMethod]();
-        }
-        logger2.info(`Executing ${node_type}.${toLineMethod}...`);
-        const ret = await proxy.method(callParams);
-        logger2.info(`Executed ${node_type}.${toLineMethod} successfully`);
-        return JSON.stringify({
-          code: 0,
-          data: ret,
-          msg: RESPONSE_MESSAGES.SUCCESS
+          const error = result.reason || {};
+          const errorMessage = error instanceof Error ? error.message : String(error || RESPONSE_MESSAGES.INTERNAL_ERROR);
+          return {
+            method,
+            code: error.code || ERROR_CODES.INTERNAL_ERROR,
+            data: null,
+            msg: errorMessage
+          };
         });
+        return JSON.stringify(responseList);
       } catch (e) {
         const code = e.code || ERROR_CODES.INTERNAL_ERROR;
         return JSON.stringify({