@espressif/rainmaker-neo-base-sdk 1.0.0

package/dist/esm/proto/esp_rmaker_claim.js

@@ -0,0 +1,356 @@
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Enum representing the status of a claiming operation.
+ */
+var RMakerClaimStatus;
+(function (RMakerClaimStatus) {
+    RMakerClaimStatus[RMakerClaimStatus["Success"] = 0] = "Success";
+    RMakerClaimStatus[RMakerClaimStatus["Fail"] = 1] = "Fail";
+    RMakerClaimStatus[RMakerClaimStatus["InvalidParam"] = 2] = "InvalidParam";
+    RMakerClaimStatus[RMakerClaimStatus["InvalidState"] = 3] = "InvalidState";
+    RMakerClaimStatus[RMakerClaimStatus["NoMemory"] = 4] = "NoMemory";
+})(RMakerClaimStatus || (RMakerClaimStatus = {}));
+/**
+ * Enum representing the message types for claiming operations.
+ */
+var RMakerClaimMsgType;
+(function (RMakerClaimMsgType) {
+    RMakerClaimMsgType[RMakerClaimMsgType["TypeCmdClaimStart"] = 0] = "TypeCmdClaimStart";
+    RMakerClaimMsgType[RMakerClaimMsgType["TypeRespClaimStart"] = 1] = "TypeRespClaimStart";
+    RMakerClaimMsgType[RMakerClaimMsgType["TypeCmdClaimInit"] = 2] = "TypeCmdClaimInit";
+    RMakerClaimMsgType[RMakerClaimMsgType["TypeRespClaimInit"] = 3] = "TypeRespClaimInit";
+    RMakerClaimMsgType[RMakerClaimMsgType["TypeCmdClaimVerify"] = 4] = "TypeCmdClaimVerify";
+    RMakerClaimMsgType[RMakerClaimMsgType["TypeRespClaimVerify"] = 5] = "TypeRespClaimVerify";
+    RMakerClaimMsgType[RMakerClaimMsgType["TypeCmdClaimAbort"] = 6] = "TypeCmdClaimAbort";
+    RMakerClaimMsgType[RMakerClaimMsgType["TypeRespClaimAbort"] = 7] = "TypeRespClaimAbort";
+})(RMakerClaimMsgType || (RMakerClaimMsgType = {}));
+/**
+ * Helper class for encoding/decoding claiming protobuf messages.
+ * This is a simplified implementation that creates/parses the proto format.
+ */
+class ClaimingProtoHelper {
+    /**
+     * Creates a ClaimStart command payload.
+     * Android sends: msg=TypeCmdClaimStart + empty cmdPayload
+     * @returns Uint8Array payload
+     */
+    static createClaimStartRequest() {
+        // Need to include empty cmdPayload to match Android behavior
+        const emptyPayloadBuf = this.encodePayloadBuf(0, new Uint8Array(0), 0);
+        return this.encodeClaimPayload(RMakerClaimMsgType.TypeCmdClaimStart, emptyPayloadBuf);
+    }
+    /**
+     * Creates a ClaimInit command payload with data from cloud.
+     * @param data - The data string to send (from cloud initiate response)
+     * @returns Uint8Array payload
+     */
+    static createClaimInitRequest(data) {
+        const dataBytes = new TextEncoder().encode(data);
+        const totalLen = dataBytes.length;
+        // Build the payload
+        // Field 1 (msg) = TypeCmdClaimInit (2)
+        // Field 10 (cmdPayload) = PayloadBuf
+        //   Field 1 (offset) = 0
+        //   Field 2 (payload) = dataBytes
+        //   Field 3 (totalLen) = totalLen
+        const payloadBuf = this.encodePayloadBuf(0, dataBytes, totalLen);
+        return this.encodeClaimPayload(RMakerClaimMsgType.TypeCmdClaimInit, payloadBuf);
+    }
+    /**
+     * Creates a ClaimInit request to get more CSR data (continuation request).
+     * @returns Uint8Array payload
+     */
+    static createClaimInitContinueRequest() {
+        // Send with empty cmdPayload to request more data
+        const emptyPayloadBuf = this.encodePayloadBuf(0, new Uint8Array(0), 0);
+        return this.encodeClaimPayload(RMakerClaimMsgType.TypeCmdClaimInit, emptyPayloadBuf);
+    }
+    /**
+     * Creates a ClaimVerify command payload with certificate data.
+     * @param certificateData - The certificate string to send
+     * @param offset - Current offset for chunked transfer
+     * @param chunkSize - Size of each chunk
+     * @returns Uint8Array payload
+     */
+    static createClaimVerifyRequest(certificateData, offset, chunkSize) {
+        const totalLen = certificateData.length;
+        const endIndex = Math.min(offset + chunkSize, totalLen);
+        const chunk = certificateData.substring(offset, endIndex);
+        const dataBytes = new TextEncoder().encode(chunk);
+        const payloadBuf = this.encodePayloadBuf(offset, dataBytes, totalLen);
+        return this.encodeClaimPayload(RMakerClaimMsgType.TypeCmdClaimVerify, payloadBuf);
+    }
+    /**
+     * Creates a ClaimAbort command payload.
+     * @returns Uint8Array payload
+     */
+    static createClaimAbortRequest() {
+        // Include empty cmdPayload to match Android behavior
+        const emptyPayloadBuf = this.encodePayloadBuf(0, new Uint8Array(0), 0);
+        return this.encodeClaimPayload(RMakerClaimMsgType.TypeCmdClaimAbort, emptyPayloadBuf);
+    }
+    /**
+     * Parses a claiming response from the device.
+     * @param data - The response data as Uint8Array
+     * @returns Parsed RMakerClaimPayload
+     */
+    static parseClaimResponse(data) {
+        const result = {
+            msg: RMakerClaimMsgType.TypeRespClaimStart,
+        };
+        let index = 0;
+        while (index < data.length) {
+            const tag = data[index++];
+            const fieldNumber = tag >> 3;
+            const wireType = tag & 0x07;
+            switch (fieldNumber) {
+                case 1: // msg field
+                    if (wireType === 0) {
+                        const { value, newIndex } = this.readVarint(data, index);
+                        result.msg = value;
+                        index = newIndex;
+                    }
+                    break;
+                case 11: // respPayload field (wire type 2 = length-delimited)
+                    if (wireType === 2) {
+                        const { value: length, newIndex: lenIndex } = this.readVarint(data, index);
+                        const respData = data.slice(lenIndex, lenIndex + length);
+                        result.respPayload = this.parseRespPayload(respData);
+                        index = lenIndex + length;
+                    }
+                    break;
+                default:
+                    // Skip unknown fields
+                    if (wireType === 0) {
+                        const { newIndex } = this.readVarint(data, index);
+                        index = newIndex;
+                    }
+                    else if (wireType === 2) {
+                        const { value: length, newIndex: lenIndex } = this.readVarint(data, index);
+                        index = lenIndex + length;
+                    }
+                    else {
+                        index++;
+                    }
+                    break;
+            }
+        }
+        return result;
+    }
+    /**
+     * Extracts the payload string from a response.
+     * @param response - The parsed response
+     * @returns The payload as a string, or empty string if not available
+     */
+    static extractPayloadString(response) {
+        if (response.respPayload?.buf?.payload) {
+            return new TextDecoder().decode(response.respPayload.buf.payload);
+        }
+        return "";
+    }
+    /**
+     * Gets the offset from a response.
+     * @param response - The parsed response
+     * @returns The offset value
+     */
+    static getOffset(response) {
+        return response.respPayload?.buf?.offset ?? 0;
+    }
+    /**
+     * Gets the total length from a response.
+     * @param response - The parsed response
+     * @returns The total length value
+     */
+    static getTotalLen(response) {
+        return response.respPayload?.buf?.totalLen ?? 0;
+    }
+    /**
+     * Checks if the response indicates success.
+     * @param response - The parsed response
+     * @returns true if status is Success
+     */
+    static isSuccess(response) {
+        return response.respPayload?.status === RMakerClaimStatus.Success;
+    }
+    /**
+     * Returns the device's status as its enum name, for diagnostics. The device
+     * distinguishes causes here: `InvalidParam` for a payload it rejected,
+     * `InvalidState` for a request out of order, `NoMemory` for an oversized
+     * fragment.
+     *
+     * @param response - The parsed response
+     * @returns The status name, or "Unknown" when absent
+     */
+    static getStatus(response) {
+        const status = response.respPayload?.status;
+        return status === undefined
+            ? "Unknown"
+            : (RMakerClaimStatus[status] ?? `Unknown(${status})`);
+    }
+    // Private helper methods
+    static encodeVarint(value) {
+        const bytes = [];
+        while (value > 127) {
+            bytes.push((value & 0x7f) | 0x80);
+            value >>>= 7;
+        }
+        bytes.push(value & 0x7f);
+        return new Uint8Array(bytes);
+    }
+    static readVarint(data, index) {
+        let value = 0;
+        let shift = 0;
+        let byte;
+        do {
+            byte = data[index++];
+            value |= (byte & 0x7f) << shift;
+            shift += 7;
+        } while (byte & 0x80);
+        return { value, newIndex: index };
+    }
+    static encodePayloadBuf(offset, payload, totalLen) {
+        const parts = [];
+        // Field 1: offset (varint)
+        parts.push(new Uint8Array([8])); // field 1, wire type 0
+        parts.push(this.encodeVarint(offset));
+        // Field 2: payload (bytes)
+        parts.push(new Uint8Array([18])); // field 2, wire type 2
+        parts.push(this.encodeVarint(payload.length));
+        parts.push(payload);
+        // Field 3: totalLen (varint)
+        parts.push(new Uint8Array([24])); // field 3, wire type 0
+        parts.push(this.encodeVarint(totalLen));
+        // Combine all parts
+        const totalLength = parts.reduce((sum, part) => sum + part.length, 0);
+        const result = new Uint8Array(totalLength);
+        let pos = 0;
+        for (const part of parts) {
+            result.set(part, pos);
+            pos += part.length;
+        }
+        return result;
+    }
+    static encodeClaimPayload(msgType, cmdPayload) {
+        const parts = [];
+        // Field 1: msg (varint)
+        parts.push(new Uint8Array([8])); // field 1, wire type 0
+        parts.push(this.encodeVarint(msgType));
+        // Field 10: cmdPayload (bytes) - if provided
+        if (cmdPayload) {
+            parts.push(new Uint8Array([82])); // field 10, wire type 2 (10 << 3 | 2 = 82)
+            parts.push(this.encodeVarint(cmdPayload.length));
+            parts.push(cmdPayload);
+        }
+        // Combine all parts
+        const totalLength = parts.reduce((sum, part) => sum + part.length, 0);
+        const result = new Uint8Array(totalLength);
+        let pos = 0;
+        for (const part of parts) {
+            result.set(part, pos);
+            pos += part.length;
+        }
+        return result;
+    }
+    static parseRespPayload(data) {
+        // In proto3, absent fields default to 0, which is Success for RMakerClaimStatus
+        const result = {
+            status: RMakerClaimStatus.Success,
+        };
+        let index = 0;
+        while (index < data.length) {
+            const tag = data[index++];
+            const fieldNumber = tag >> 3;
+            const wireType = tag & 0x07;
+            switch (fieldNumber) {
+                case 1: // status field
+                    if (wireType === 0) {
+                        const { value, newIndex } = this.readVarint(data, index);
+                        result.status = value;
+                        index = newIndex;
+                    }
+                    break;
+                case 2: // buf field
+                    if (wireType === 2) {
+                        const { value: length, newIndex: lenIndex } = this.readVarint(data, index);
+                        const bufData = data.slice(lenIndex, lenIndex + length);
+                        result.buf = this.parsePayloadBuf(bufData);
+                        index = lenIndex + length;
+                    }
+                    break;
+                default:
+                    // Skip unknown fields
+                    if (wireType === 0) {
+                        const { newIndex } = this.readVarint(data, index);
+                        index = newIndex;
+                    }
+                    else if (wireType === 2) {
+                        const { value: length, newIndex: lenIndex } = this.readVarint(data, index);
+                        index = lenIndex + length;
+                    }
+                    else {
+                        index++;
+                    }
+                    break;
+            }
+        }
+        return result;
+    }
+    static parsePayloadBuf(data) {
+        const result = {
+            offset: 0,
+            payload: new Uint8Array(0),
+            totalLen: 0,
+        };
+        let index = 0;
+        while (index < data.length) {
+            const tag = data[index++];
+            const fieldNumber = tag >> 3;
+            const wireType = tag & 0x07;
+            switch (fieldNumber) {
+                case 1: // offset
+                    if (wireType === 0) {
+                        const { value, newIndex } = this.readVarint(data, index);
+                        result.offset = value;
+                        index = newIndex;
+                    }
+                    break;
+                case 2: // payload
+                    if (wireType === 2) {
+                        const { value: length, newIndex: lenIndex } = this.readVarint(data, index);
+                        result.payload = data.slice(lenIndex, lenIndex + length);
+                        index = lenIndex + length;
+                    }
+                    break;
+                case 3: // totalLen
+                    if (wireType === 0) {
+                        const { value, newIndex } = this.readVarint(data, index);
+                        result.totalLen = value;
+                        index = newIndex;
+                    }
+                    break;
+                default:
+                    // Skip unknown fields
+                    if (wireType === 0) {
+                        const { newIndex } = this.readVarint(data, index);
+                        index = newIndex;
+                    }
+                    else if (wireType === 2) {
+                        const { value: length, newIndex: lenIndex } = this.readVarint(data, index);
+                        index = lenIndex + length;
+                    }
+                    else {
+                        index++;
+                    }
+                    break;
+            }
+        }
+        return result;
+    }
+}
+
+export { ClaimingProtoHelper, RMakerClaimMsgType, RMakerClaimStatus };
+//# sourceMappingURL=esp_rmaker_claim.js.map

package/dist/esm/proto/esp_rmaker_claim.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"esp_rmaker_claim.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/services/ESPRMNeoAPIManager.js

@@ -0,0 +1,204 @@
+import { Logger } from '../utils/logger.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = new Logger("ESPRMNeoAPIManager");
+const JSON_CONTENT_TYPE = "application/json";
+// ═════════════════════════════════════════════════════════════════════
+// Module-scoped state
+// ═════════════════════════════════════════════════════════════════════
+/**
+ * Module-scoped singleton. Cannot be constructed by external code because the
+ * class constructor is protected (only subclasses reach it via `super()`);
+ * the only construction path is {@link initializeAPIManager}, which lives in
+ * this module and is not re-exported through the public SDK barrel.
+ */
+let instance = null;
+/**
+ * User API base URL, resolved once at init and reused by every request.
+ * Read by {@link ESPRMNeoAPIManager} instance methods via
+ * {@link requireUserApiBase} to avoid re-computing it per request.
+ */
+let userApiBase = null;
+function requireUserApiBase() {
+    if (userApiBase == null) {
+        throw new Error("ESPRMNeoAPIManager not initialized. Ensure ESPRMNeoBase.configure() ran first.");
+    }
+    return userApiBase;
+}
+/**
+ * Base API manager: plain HTTP calls with no signing.
+ * Use for unauthenticated endpoints (e.g. token/refresh) and endpoints that
+ * carry a Cognito bearer token in the `Authorization` header.
+ * ESPSigV4APIManager extends this and adds SigV4 for authenticated calls.
+ */
+class ESPRMNeoAPIManager {
+    // ═════════════════════════════════════════════════════════════════════
+    // Lifecycle
+    // ═════════════════════════════════════════════════════════════════════
+    /**
+     * `protected` (not `private`) so `ESPSigV4APIManager` can `extends` this
+     * class and call `super()`. External construction is blocked by the class
+     * itself not being publicly exported from `services/export.ts`.
+     */
+    constructor() { }
+    /**
+     * Friend-access hook used only by {@link initializeAPIManager} in this
+     * module.
+     *
+     * @internal
+     */
+    static _construct() {
+        return new ESPRMNeoAPIManager();
+    }
+    /**
+     * Returns the singleton constructed by SDK bootstrap.
+     *
+     * @throws {Error} If the SDK has not been configured.
+     */
+    static getInstance() {
+        if (!instance) {
+            throw new Error("ESPRMNeoAPIManager not initialized. Ensure ESPRMNeoBase.configure() ran first.");
+        }
+        return instance;
+    }
+    // ═════════════════════════════════════════════════════════════════════
+    // Public User API entry points
+    // ═════════════════════════════════════════════════════════════════════
+    /**
+     * POST to the User API base with no authentication (e.g. token/refresh).
+     * Overridden by subclasses that need signing.
+     */
+    async postUserApi(path, data) {
+        return this.request("POST", path, this.jsonHeaders({}), data);
+    }
+    /**
+     * POST to the User API base with a Cognito Bearer token
+     * (`CognitoAuthorizer` / `cognito_user_pools`).
+     */
+    async postUserApiWithBearer(path, data, bearerToken) {
+        return this.request("POST", path, this.jsonHeaders({ bearerToken }), data);
+    }
+    /**
+     * PUT to the User API base with a Cognito Bearer token.
+     */
+    async putUserApiWithBearer(path, data, bearerToken) {
+        return this.request("PUT", path, this.jsonHeaders({ bearerToken }), data);
+    }
+    /**
+     * GET from the User API base with a Cognito Bearer token.
+     */
+    async getUserApiWithBearer(path, bearerToken) {
+        return this.request("GET", path, this.jsonHeaders({ bearerToken }));
+    }
+    // ═════════════════════════════════════════════════════════════════════
+    // Request pipeline
+    // ═════════════════════════════════════════════════════════════════════
+    /** Orchestrates fetch + parse for User API calls. */
+    async request(method, path, headers, data) {
+        const url = this.buildApiUrl(path);
+        try {
+            const response = await this.sendRequest(url, method, headers, data);
+            return await this.parseJsonResponse(response, url);
+        }
+        catch (err) {
+            return this.handleRequestError(err);
+        }
+    }
+    /** DRY: JSON headers with optional Bearer token. */
+    jsonHeaders({ bearerToken }) {
+        const headers = {
+            "Content-Type": JSON_CONTENT_TYPE,
+        };
+        if (bearerToken) {
+            headers.Authorization = `Bearer ${bearerToken}`;
+        }
+        return headers;
+    }
+    /** SRP: Builds full User API URL from path. */
+    buildApiUrl(path) {
+        const base = requireUserApiBase();
+        const pathWithSlash = path.startsWith("/") ? path : `/${path}`;
+        return `${base}${pathWithSlash}`;
+    }
+    /** SRP: Pure fetch only — returns raw Response. */
+    sendRequest(url, method, headers, data) {
+        return fetch(url, {
+            method,
+            headers,
+            body: data != null ? JSON.stringify(data) : undefined,
+        });
+    }
+    /** SRP: Parses Response to JSON and throws on HTTP error. */
+    async parseJsonResponse(response, url) {
+        logger.debug("User API response", {
+            status: response.status,
+            statusText: response.statusText,
+        });
+        const text = await response.text();
+        const responseData = (() => {
+            try {
+                return text ? JSON.parse(text) : null;
+            }
+            catch (parseErr) {
+                logger.debug("User API: Failed to parse response as JSON", parseErr);
+                throw new Error("Failed to parse response as JSON", parseErr instanceof Error ? { cause: parseErr } : undefined);
+            }
+        })();
+        if (!response.ok) {
+            const rd = responseData;
+            const message = rd?.message ||
+                rd?.error ||
+                `HTTP error! status: ${response.status}`;
+            logger.error("User API request failed:", { url, status: response.status, message });
+            const err = new Error(message);
+            err.status = response.status;
+            err.responseData = responseData;
+            throw err;
+        }
+        return responseData;
+    }
+    /** SRP: Handles network errors (rethrows API errors with status). */
+    handleRequestError(err) {
+        const e = err;
+        if (e?.status != null) {
+            throw err;
+        }
+        logger.error("User API request failed:", e?.message ?? err);
+        throw err instanceof Error ? err : new Error(String(err));
+    }
+}
+// ═════════════════════════════════════════════════════════════════════
+// SDK bootstrap hooks (not re-exported publicly)
+// ═════════════════════════════════════════════════════════════════════
+/**
+ * SDK bootstrap hook. Called by {@link ESPRMNeoBase.configure}. Caches the
+ * User API base and constructs the singleton. Not re-exported through the
+ * public SDK barrel.
+ *
+ * @internal
+ * @throws {Error} If already initialized.
+ */
+function initializeAPIManager(init) {
+    if (instance) {
+        throw new Error("ESPRMNeoAPIManager already initialized. Re-configuring the SDK is not supported.");
+    }
+    userApiBase = init.userApiBase.replace(/\/$/, "");
+    instance = ESPRMNeoAPIManager._construct();
+}
+/**
+ * Test-only hook to reset the singleton and cached base URL between test
+ * cases. Not re-exported.
+ *
+ * @internal
+ */
+function _resetAPIManagerForTests() {
+    instance = null;
+    userApiBase = null;
+}
+
+export { ESPRMNeoAPIManager, _resetAPIManagerForTests, initializeAPIManager };
+//# sourceMappingURL=ESPRMNeoAPIManager.js.map

package/dist/esm/services/ESPRMNeoAPIManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ESPRMNeoAPIManager.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/services/ESPRMNeoHelpers/ChallengeResponseHelper.js

@@ -0,0 +1,104 @@
+import { rmaker_misc } from '../../proto/esp_rmaker_chal_resp.js';
+import { Endpoint } from '../../utils/constants.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Challenge-response helper for ESP RainMaker provisioning flow.
+ * Handles protobuf creation, device communication, and response parsing.
+ */
+class ChallengeResponseHelper {
+    /**
+     * Creates a challenge request payload using the esp_rmaker_chal_resp proto.
+     */
+    static createChallengeRequest(challenge) {
+        const challengeBytes = new TextEncoder().encode(challenge);
+        // Use the correct constructor pattern from generated proto
+        const cmdPayload = new rmaker_misc.CmdCRPayload({
+            payload: challengeBytes,
+        });
+        const miscPayload = new rmaker_misc.RMakerMiscPayload({
+            msg: rmaker_misc.RMakerMiscMsgType.TypeCmdChallengeResponse,
+            status: rmaker_misc.RMakerMiscStatus.Success,
+            cmdChallengeResponsePayload: cmdPayload,
+        });
+        // Use the serialize method from the generated class
+        return miscPayload.serialize();
+    }
+    /**
+     * Parses the device response from challenge-response protocol.
+     */
+    static parseDeviceResponse(responseData) {
+        try {
+            const response = rmaker_misc.RMakerMiscPayload.deserialize(responseData);
+            if (response.status !== rmaker_misc.RMakerMiscStatus.Success) {
+                return {
+                    success: false,
+                    error: "Device returned unsuccessful status",
+                };
+            }
+            const resp = response.respChallengeResponsePayload;
+            if (!resp) {
+                return {
+                    success: false,
+                    error: "Missing challenge response payload",
+                };
+            }
+            if (!resp.payload || !resp.node_id) {
+                return {
+                    success: false,
+                    error: "Invalid response payload: missing payload or nodeId",
+                };
+            }
+            const signedChallenge = Array.from(resp.payload)
+                .map((b) => b.toString(16).padStart(2, "0"))
+                .join("");
+            return {
+                success: true,
+                nodeId: resp.node_id,
+                signedChallenge,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : "Failed to parse device response",
+            };
+        }
+    }
+    /**
+     * Validates challenge response format (success, nodeId, signedChallenge as hex).
+     */
+    static validateChallengeResponse(response) {
+        if (!response.success || !response.nodeId || !response.signedChallenge) {
+            return false;
+        }
+        const hexRegex = /^[0-9a-fA-F]+$/;
+        return hexRegex.test(response.signedChallenge);
+    }
+    /**
+     * Returns true when device version info advertises challenge-response (`ch_resp`).
+     */
+    static checkChallengeResponseCapability(versionInfo) {
+        try {
+            const rmakerExtra = versionInfo?.rmaker_extra;
+            if (!rmakerExtra || typeof rmakerExtra !== "object") {
+                return false;
+            }
+            const extraCapabilities = rmakerExtra.cap;
+            if (!Array.isArray(extraCapabilities)) {
+                return false;
+            }
+            return extraCapabilities.includes(Endpoint.CHALLENGE_RESPONSE);
+        }
+        catch {
+            return false;
+        }
+    }
+}
+
+export { ChallengeResponseHelper };
+//# sourceMappingURL=ChallengeResponseHelper.js.map

package/dist/esm/services/ESPRMNeoHelpers/ChallengeResponseHelper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChallengeResponseHelper.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}