Node-OPCUA Issue: 'Acknowledge Method Not Found' Error with Alarm Acknowledgment Functions about node-opcua HOT 3 CLOSED

 statusCode: BadNodeIdUnknown (0x80340000) {
      _description: 'The node id refers to a node that does not exist in the server address space.',
      _name: 'BadNodeIdUnknown',
      _value: 2150891520,
}

import express from "express";
import { createServer } from 'node:http'
import { AttributeIds, OPCUAClient, TimestampsToReturn, constructEventFilter, ObjectIds, callConditionRefresh, MethodIds, Variant, DataType } from "node-opcua-client";

const app = express();
const server = createServer(app);

const URL = "opc.tcp://ADRIAN-ASUS:4840";

(async () => {
    try {
        const client = OPCUAClient.create();

        client.on("backoff", (retry, delay) => {
            console.log("Retying to connect to ", URL, " attempt ", retry);
        });

        console.log("connecting to ", URL);
        await client.connect(URL);
        console.log("connected to ", URL);

        const session = await client.createSession();
        console.log("session initialized");

        const subscripcion = await session.createSubscription2({
            requestedPublishingInterval: 50,
            requestedMaxKeepAliveCount: 20,
            publishingEnabled: true,
        });

        const fields = [
            "EventId",
            "AckedState",
            "AckedState.Id",
            "ConfirmedState",
            "ConfirmedState.Id",
            "ConditionId",
        ];

        const eventFilter = constructEventFilter(fields);

        const itemToMonitor = {
            nodeId: ObjectIds.Server,
            attributeId: AttributeIds.EventNotifier,
        };

        const parameters = {
            filter: eventFilter,
            discardOldest: true,
            queueSize: 100,
        };


        const EventMonitor = await subscripcion.monitor(
            itemToMonitor,
            parameters,
            TimestampsToReturn.Both
        )

        const alarmData = {
        }

        callConditionRefresh(subscripcion) // Give us all events!!!

        EventMonitor.on("changed", (events) => {
            for (let i = 0; i < events.length; i++) {
                alarmData[fields[i]] = events[i].value
            }
            console.log(alarmData)
        });

        setTimeout(async () => {
            try {

                /* session.acknowledgeCondition(alarmData.ConditionId, alarmData.EventId, comment, (err) => {
                    console.log({ err })
                }) */

                const methodToCall = {
                    objectId: alarmData.ConditionId,
                    methodId: MethodIds.AcknowledgeableConditionType_Acknowledge, // TODO: Replace to MethodIds
                    inputArguments: [
                        new Variant({ dataType: DataType.ByteString, value: alarmData.EventId }),
                        new Variant({ dataType: DataType.LocalizedText, value: "test comment!" })
                    ]
                }

                session.call(methodToCall, (err, result) => {
                    if (err) return console.log(err); // Currently not important
                    console.log("Method call result: " + JSON.stringify(result, null, 2));
                })
            } catch (error) {
                console.log(error)
            }

        }, 5000)



        let running = true;
        process.on("SIGINT", async () => {
            if (!running) {
                return; // avoid calling shutdown twice
            }
            console.log("shutting down client");
            running = false;
            await subscripcion.terminate();
            await session.close();
            await client.disconnect();
            console.log("Done");
            process.exit(0);
        });
    } catch (error) {
        console.log("ERROR: ", error.message);
        console.log(error);
    }

    server.listen(4000, () => {
        console.log('server running at http://localhost:4000');
    });
})();