@hamradio/meshcore 1.2.2 → 1.3.2

package/dist/identity.types.d.ts

@@ -1,17 +0,0 @@
-import { IPublicKey, ISharedSecret } from "./crypto.types";
-export type NodeHash = number;
-export interface IIdentity {
-    hash(): NodeHash;
-    toString(): string;
-    verify(signature: Uint8Array, message: Uint8Array): boolean;
-    matches(other: IIdentity | IPublicKey | Uint8Array | string): boolean;
-}
-export interface ILocalIdentity extends IIdentity {
-    sign(message: Uint8Array): Uint8Array;
-    calculateSharedSecret(other: IIdentity | IPublicKey): ISharedSecret;
-}
-export interface IContact {
-    name: string;
-    identity: IIdentity;
-    calculateSharedSecret(me: ILocalIdentity): ISharedSecret;
-}

package/dist/identity.types.js

@@ -1 +0,0 @@
-export {};

package/dist/packet.d.ts

@@ -1,32 +0,0 @@
-import { Payload, PayloadType, RouteType, type IPacket } from "./packet.types";
-export declare class Packet implements IPacket {
-    header: number;
-    pathLength: number;
-    path: Uint8Array;
-    payload: Uint8Array;
-    transport?: [number, number];
-    routeType: RouteType;
-    payloadVersion: number;
-    payloadType: PayloadType;
-    pathHashCount: number;
-    pathHashSize: number;
-    pathHashBytes: number;
-    pathHashes: string[];
-    constructor(header: number, transport: [number, number] | undefined, pathLength: number, path: Uint8Array, payload: Uint8Array);
-    static fromBytes(bytes: Uint8Array | string): Packet;
-    static hasTransportCodes(routeType: RouteType): boolean;
-    hash(): string;
-    decode(): Payload;
-    private decodeEncryptedPayload;
-    private decodeRequest;
-    private decodeResponse;
-    private decodeText;
-    private decodeAck;
-    private decodeAdvert;
-    private decodeGroupText;
-    private decodeGroupData;
-    private decodeAnonReq;
-    private decodePath;
-    private decodeTrace;
-    private decodeRawCustom;
-}

package/dist/packet.js

@@ -1,242 +0,0 @@
-import { sha256 } from "@noble/hashes/sha2.js";
-import { PayloadType, RouteType, } from "./packet.types";
-import { base64ToBytes, BufferReader, bytesToHex } from "./parser";
-export class Packet {
-    constructor(header, transport, pathLength, path, payload) {
-        this.header = header;
-        this.transport = transport;
-        this.pathLength = pathLength;
-        this.path = path;
-        this.payload = payload;
-        this.routeType = (header) & 0x03;
-        this.payloadVersion = (header >> 6) & 0x03;
-        this.payloadType = (header >> 2) & 0x0f;
-        this.pathHashSize = (pathLength >> 6) + 1;
-        this.pathHashCount = pathLength & 0x3f;
-        this.pathHashBytes = this.pathHashCount * this.pathHashSize;
-        this.pathHashes = [];
-        for (let i = 0; i < this.pathHashBytes; i += this.pathHashSize) {
-            const hashBytes = this.path.slice(i, i + this.pathHashSize);
-            const hashHex = bytesToHex(hashBytes);
-            this.pathHashes.push(hashHex);
-        }
-    }
-    static fromBytes(bytes) {
-        if (typeof bytes === "string") {
-            bytes = base64ToBytes(bytes);
-        }
-        let offset = 0;
-        const header = bytes[offset++];
-        const routeType = header & 0x03;
-        let transport;
-        if (Packet.hasTransportCodes(routeType)) {
-            const uitn16View = new DataView(bytes.buffer, bytes.byteOffset + offset, 4);
-            transport = [uitn16View.getUint16(0, false), uitn16View.getUint16(2, false)];
-            offset += 4;
-        }
-        const pathLength = bytes[offset++];
-        const path = bytes.slice(offset, offset + pathLength);
-        offset += pathLength;
-        const payload = bytes.slice(offset);
-        return new Packet(header, transport, pathLength, path, payload);
-    }
-    static hasTransportCodes(routeType) {
-        return routeType === RouteType.TRANSPORT_FLOOD || routeType === RouteType.TRANSPORT_DIRECT;
-    }
-    hash() {
-        const hash = sha256.create();
-        hash.update(new Uint8Array([this.payloadType]));
-        if (this.payloadType === PayloadType.TRACE) {
-            hash.update(new Uint8Array([this.pathLength]));
-        }
-        hash.update(this.payload);
-        const digest = hash.digest();
-        return bytesToHex(digest.slice(0, 8));
-    }
-    decode() {
-        switch (this.payloadType) {
-            case PayloadType.REQUEST:
-                return this.decodeRequest();
-            case PayloadType.RESPONSE:
-                return this.decodeResponse();
-            case PayloadType.TEXT:
-                return this.decodeText();
-            case PayloadType.ACK:
-                return this.decodeAck();
-            case PayloadType.ADVERT:
-                return this.decodeAdvert();
-            case PayloadType.GROUP_TEXT:
-                return this.decodeGroupText();
-            case PayloadType.GROUP_DATA:
-                return this.decodeGroupData();
-            case PayloadType.ANON_REQ:
-                return this.decodeAnonReq();
-            case PayloadType.PATH:
-                return this.decodePath();
-            case PayloadType.TRACE:
-                return this.decodeTrace();
-            case PayloadType.RAW_CUSTOM:
-                return this.decodeRawCustom();
-            default:
-                throw new Error(`Unsupported payload type: ${this.payloadType}`);
-        }
-    }
-    decodeEncryptedPayload(reader) {
-        const cipherMAC = reader.readBytes(2);
-        const cipherText = reader.readBytes(reader.remainingBytes());
-        return { cipherMAC, cipherText };
-    }
-    decodeRequest() {
-        if (this.payload.length < 4) {
-            throw new Error("Invalid request payload: too short");
-        }
-        const reader = new BufferReader(this.payload);
-        return {
-            type: PayloadType.REQUEST,
-            dst: reader.readByte(),
-            src: reader.readByte(),
-            encrypted: this.decodeEncryptedPayload(reader),
-        };
-    }
-    decodeResponse() {
-        if (this.payload.length < 4) {
-            throw new Error("Invalid response payload: too short");
-        }
-        const reader = new BufferReader(this.payload);
-        return {
-            type: PayloadType.RESPONSE,
-            dst: reader.readByte(),
-            src: reader.readByte(),
-            encrypted: this.decodeEncryptedPayload(reader),
-        };
-    }
-    decodeText() {
-        if (this.payload.length < 4) {
-            throw new Error("Invalid text payload: too short");
-        }
-        const reader = new BufferReader(this.payload);
-        return {
-            type: PayloadType.TEXT,
-            dst: reader.readByte(),
-            src: reader.readByte(),
-            encrypted: this.decodeEncryptedPayload(reader),
-        };
-    }
-    decodeAck() {
-        if (this.payload.length < 4) {
-            throw new Error("Invalid ack payload: too short");
-        }
-        const reader = new BufferReader(this.payload);
-        return {
-            type: PayloadType.ACK,
-            checksum: reader.readBytes(4),
-        };
-    }
-    decodeAdvert() {
-        if (this.payload.length < 4) {
-            throw new Error("Invalid advert payload: too short");
-        }
-        const reader = new BufferReader(this.payload);
-        const payload = {
-            type: PayloadType.ADVERT,
-            publicKey: reader.readBytes(32),
-            timestamp: reader.readTimestamp(),
-            signature: reader.readBytes(64),
-        };
-        const flags = reader.readByte();
-        const appdata = {
-            nodeType: flags & 0x0f,
-            hasLocation: (flags & 0x10) !== 0,
-            hasFeature1: (flags & 0x20) !== 0,
-            hasFeature2: (flags & 0x40) !== 0,
-            hasName: (flags & 0x80) !== 0,
-        };
-        if (appdata.hasLocation) {
-            const lat = reader.readInt32LE() / 100000;
-            const lon = reader.readInt32LE() / 100000;
-            appdata.location = [lat, lon];
-        }
-        if (appdata.hasFeature1) {
-            appdata.feature1 = reader.readUint16LE();
-        }
-        if (appdata.hasFeature2) {
-            appdata.feature2 = reader.readUint16LE();
-        }
-        if (appdata.hasName) {
-            const nameBytes = reader.readBytes();
-            let nullPos = nameBytes.indexOf(0);
-            if (nullPos === -1) {
-                nullPos = nameBytes.length;
-            }
-            appdata.name = new TextDecoder('utf-8').decode(nameBytes.subarray(0, nullPos));
-        }
-        return {
-            ...payload,
-            appdata
-        };
-    }
-    decodeGroupText() {
-        if (this.payload.length < 3) {
-            throw new Error("Invalid group text payload: too short");
-        }
-        const reader = new BufferReader(this.payload);
-        return {
-            type: PayloadType.GROUP_TEXT,
-            channelHash: reader.readByte(),
-            encrypted: this.decodeEncryptedPayload(reader),
-        };
-    }
-    decodeGroupData() {
-        if (this.payload.length < 3) {
-            throw new Error("Invalid group data payload: too short");
-        }
-        const reader = new BufferReader(this.payload);
-        return {
-            type: PayloadType.GROUP_DATA,
-            channelHash: reader.readByte(),
-            encrypted: this.decodeEncryptedPayload(reader),
-        };
-    }
-    decodeAnonReq() {
-        if (this.payload.length < 1 + 32 + 2) {
-            throw new Error("Invalid anon req payload: too short");
-        }
-        const reader = new BufferReader(this.payload);
-        return {
-            type: PayloadType.ANON_REQ,
-            dst: reader.readByte(),
-            publicKey: reader.readBytes(32),
-            encrypted: this.decodeEncryptedPayload(reader),
-        };
-    }
-    decodePath() {
-        if (this.payload.length < 2) {
-            throw new Error("Invalid path payload: too short");
-        }
-        const reader = new BufferReader(this.payload);
-        return {
-            type: PayloadType.PATH,
-            dst: reader.readByte(),
-            src: reader.readByte(),
-        };
-    }
-    decodeTrace() {
-        if (this.payload.length < 9) {
-            throw new Error("Invalid trace payload: too short");
-        }
-        const reader = new BufferReader(this.payload);
-        return {
-            type: PayloadType.TRACE,
-            tag: reader.readUint32LE() >>> 0,
-            authCode: reader.readUint32LE() >>> 0,
-            flags: reader.readByte() & 0x03,
-            nodes: reader.readBytes()
-        };
-    }
-    decodeRawCustom() {
-        return {
-            type: PayloadType.RAW_CUSTOM,
-            data: this.payload,
-        };
-    }
-}

package/dist/packet.types.d.ts

@@ -1,161 +0,0 @@
-import { NodeHash } from "./identity.types";
-export type Uint16 = number;
-export interface IPacket {
-    header: number;
-    transport?: [Uint16, Uint16];
-    pathLength: number;
-    path: Uint8Array;
-    payload: Uint8Array;
-    decode(): Payload;
-}
-export declare enum RouteType {
-    TRANSPORT_FLOOD = 0,
-    FLOOD = 1,
-    DIRECT = 2,
-    TRANSPORT_DIRECT = 3
-}
-export declare enum PayloadType {
-    REQUEST = 0,
-    RESPONSE = 1,
-    TEXT = 2,
-    ACK = 3,
-    ADVERT = 4,
-    GROUP_TEXT = 5,
-    GROUP_DATA = 6,
-    ANON_REQ = 7,
-    PATH = 8,
-    TRACE = 9,
-    RAW_CUSTOM = 15
-}
-export type Payload = RequestPayload | ResponsePayload | TextPayload | AckPayload | AdvertPayload | GroupTextPayload | GroupDataPayload | AnonReqPayload | PathPayload | TracePayload | RawCustomPayload;
-export interface EncryptedPayload {
-    cipherMAC: Uint8Array;
-    cipherText: Uint8Array;
-}
-export interface RequestPayload {
-    type: PayloadType.REQUEST;
-    dst: NodeHash;
-    src: NodeHash;
-    encrypted: EncryptedPayload;
-    decrypted?: DecryptedRequest;
-}
-export declare enum RequestType {
-    GET_STATS = 1,
-    KEEP_ALIVE = 2,
-    GET_TELEMETRY = 3,
-    GET_MIN_MAX_AVG = 4,
-    GET_ACL = 5,
-    GET_NEIGHBORS = 6,
-    GET_OWNER_INFO = 7
-}
-export interface DecryptedRequest {
-    timestamp: Date;
-    requestType: RequestType;
-    requestData: Uint8Array;
-}
-export interface ResponsePayload {
-    type: PayloadType.RESPONSE;
-    dst: NodeHash;
-    src: NodeHash;
-    encrypted: EncryptedPayload;
-    decrypted?: DecryptedResponse;
-}
-export interface DecryptedResponse {
-    timestamp: Date;
-    responseData: Uint8Array;
-}
-export interface TextPayload {
-    type: PayloadType.TEXT;
-    dst: NodeHash;
-    src: NodeHash;
-    encrypted: EncryptedPayload;
-    decrypted?: DecryptedText;
-}
-export declare enum TextType {
-    PLAIN_TEXT = 0,
-    CLI_COMMAND = 1,
-    SIGNED_PLAIN_TEXT = 2
-}
-export interface DecryptedText {
-    timestamp: Date;
-    textType: TextType;
-    attempt: number;
-    message: string;
-}
-export interface AckPayload {
-    type: PayloadType.ACK;
-    checksum: Uint8Array;
-}
-export interface AdvertPayload {
-    type: PayloadType.ADVERT;
-    publicKey: Uint8Array;
-    timestamp: Date;
-    signature: Uint8Array;
-    appdata: AdvertAppData;
-}
-export declare enum NodeType {
-    CHAT_NODE = 1,
-    REPEATER = 2,
-    ROOM_SERVER = 3,
-    SENSOR_NODE = 4
-}
-export interface AdvertAppData {
-    nodeType: NodeType;
-    hasLocation: boolean;
-    location?: [number, number];
-    hasFeature1: boolean;
-    feature1?: Uint16;
-    hasFeature2: boolean;
-    feature2?: Uint16;
-    hasName: boolean;
-    name?: string;
-}
-export interface GroupTextPayload {
-    type: PayloadType.GROUP_TEXT;
-    channelHash: NodeHash;
-    encrypted: EncryptedPayload;
-    decrypted?: DecryptedGroupText;
-}
-export interface DecryptedGroupText {
-    timestamp: Date;
-    textType: TextType;
-    attempt: number;
-    message: string;
-}
-export interface GroupDataPayload {
-    type: PayloadType.GROUP_DATA;
-    channelHash: NodeHash;
-    encrypted: EncryptedPayload;
-    decrypted?: DecryptedGroupData;
-}
-export interface DecryptedGroupData {
-    timestamp: Date;
-    data: Uint8Array;
-}
-export interface AnonReqPayload {
-    type: PayloadType.ANON_REQ;
-    dst: NodeHash;
-    publicKey: Uint8Array;
-    encrypted: EncryptedPayload;
-    decrypted?: DecryptedAnonReq;
-}
-export interface DecryptedAnonReq {
-    timestamp: Date;
-    data: Uint8Array;
-}
-export interface PathPayload {
-    type: PayloadType.PATH;
-    dst: NodeHash;
-    src: NodeHash;
-}
-export interface TracePayload {
-    type: PayloadType.TRACE;
-    tag: number;
-    authCode: number;
-    flags: number;
-    nodes: Uint8Array;
-}
-export interface RawCustomPayload {
-    type: PayloadType.RAW_CUSTOM;
-    data: Uint8Array;
-}

package/dist/packet.types.js

@@ -1,44 +0,0 @@
-export var RouteType;
-(function (RouteType) {
-    RouteType[RouteType["TRANSPORT_FLOOD"] = 0] = "TRANSPORT_FLOOD";
-    RouteType[RouteType["FLOOD"] = 1] = "FLOOD";
-    RouteType[RouteType["DIRECT"] = 2] = "DIRECT";
-    RouteType[RouteType["TRANSPORT_DIRECT"] = 3] = "TRANSPORT_DIRECT";
-})(RouteType || (RouteType = {}));
-export var PayloadType;
-(function (PayloadType) {
-    PayloadType[PayloadType["REQUEST"] = 0] = "REQUEST";
-    PayloadType[PayloadType["RESPONSE"] = 1] = "RESPONSE";
-    PayloadType[PayloadType["TEXT"] = 2] = "TEXT";
-    PayloadType[PayloadType["ACK"] = 3] = "ACK";
-    PayloadType[PayloadType["ADVERT"] = 4] = "ADVERT";
-    PayloadType[PayloadType["GROUP_TEXT"] = 5] = "GROUP_TEXT";
-    PayloadType[PayloadType["GROUP_DATA"] = 6] = "GROUP_DATA";
-    PayloadType[PayloadType["ANON_REQ"] = 7] = "ANON_REQ";
-    PayloadType[PayloadType["PATH"] = 8] = "PATH";
-    PayloadType[PayloadType["TRACE"] = 9] = "TRACE";
-    PayloadType[PayloadType["RAW_CUSTOM"] = 15] = "RAW_CUSTOM";
-})(PayloadType || (PayloadType = {}));
-export var RequestType;
-(function (RequestType) {
-    RequestType[RequestType["GET_STATS"] = 1] = "GET_STATS";
-    RequestType[RequestType["KEEP_ALIVE"] = 2] = "KEEP_ALIVE";
-    RequestType[RequestType["GET_TELEMETRY"] = 3] = "GET_TELEMETRY";
-    RequestType[RequestType["GET_MIN_MAX_AVG"] = 4] = "GET_MIN_MAX_AVG";
-    RequestType[RequestType["GET_ACL"] = 5] = "GET_ACL";
-    RequestType[RequestType["GET_NEIGHBORS"] = 6] = "GET_NEIGHBORS";
-    RequestType[RequestType["GET_OWNER_INFO"] = 7] = "GET_OWNER_INFO";
-})(RequestType || (RequestType = {}));
-export var TextType;
-(function (TextType) {
-    TextType[TextType["PLAIN_TEXT"] = 0] = "PLAIN_TEXT";
-    TextType[TextType["CLI_COMMAND"] = 1] = "CLI_COMMAND";
-    TextType[TextType["SIGNED_PLAIN_TEXT"] = 2] = "SIGNED_PLAIN_TEXT";
-})(TextType || (TextType = {}));
-export var NodeType;
-(function (NodeType) {
-    NodeType[NodeType["CHAT_NODE"] = 1] = "CHAT_NODE";
-    NodeType[NodeType["REPEATER"] = 2] = "REPEATER";
-    NodeType[NodeType["ROOM_SERVER"] = 3] = "ROOM_SERVER";
-    NodeType[NodeType["SENSOR_NODE"] = 4] = "SENSOR_NODE";
-})(NodeType || (NodeType = {}));

package/dist/parser.d.ts

@@ -1,31 +0,0 @@
-import { equalBytes } from "@noble/ciphers/utils.js";
-import { bytesToHex } from "@noble/hashes/utils.js";
-export { bytesToHex, equalBytes };
-export declare const base64ToBytes: (base64: string, size?: number) => Uint8Array;
-export declare const hexToBytes: (hex: string, size?: number) => Uint8Array;
-export declare class BufferReader {
-    private buffer;
-    private offset;
-    constructor(buffer: Uint8Array);
-    readByte(): number;
-    readBytes(length?: number): Uint8Array;
-    hasMore(): boolean;
-    remainingBytes(): number;
-    peekByte(): number;
-    readUint16LE(): number;
-    readUint32LE(): number;
-    readInt16LE(): number;
-    readInt32LE(): number;
-    readTimestamp(): Date;
-}
-export declare class BufferWriter {
-    private buffer;
-    writeByte(value: number): void;
-    writeBytes(bytes: Uint8Array): void;
-    writeUint16LE(value: number): void;
-    writeUint32LE(value: number): void;
-    writeInt16LE(value: number): void;
-    writeInt32LE(value: number): void;
-    writeTimestamp(date: Date): void;
-    toBytes(): Uint8Array;
-}

package/dist/parser.js

@@ -1,124 +0,0 @@
-import { equalBytes } from "@noble/ciphers/utils.js";
-import { bytesToHex, hexToBytes as nobleHexToBytes } from "@noble/hashes/utils.js";
-export { bytesToHex, equalBytes };
-export const base64ToBytes = (base64, size) => {
-    // Normalize URL-safe base64 to standard base64
-    let normalized = base64.replace(/-/g, '+').replace(/_/g, '/');
-    // Add padding if missing
-    while (normalized.length % 4 !== 0) {
-        normalized += '=';
-    }
-    const binaryString = atob(normalized);
-    const bytes = new Uint8Array(binaryString.length);
-    for (let i = 0; i < binaryString.length; i++) {
-        bytes[i] = binaryString.charCodeAt(i);
-    }
-    if (size !== undefined && bytes.length !== size) {
-        throw new Error(`Invalid base64 length: expected ${size} bytes, got ${bytes.length}`);
-    }
-    return bytes;
-};
-// Note: encodedStringToBytes removed — prefer explicit parsers.
-// Use `hexToBytes` for hex inputs and `base64ToBytes` for base64 inputs.
-// Wrapper around @noble/hashes hexToBytes that optionally validates size.
-export const hexToBytes = (hex, size) => {
-    const bytes = nobleHexToBytes(hex);
-    if (size !== undefined && bytes.length !== size) {
-        throw new Error(`Invalid hex length: expected ${size} bytes, got ${bytes.length}`);
-    }
-    return bytes;
-};
-export class BufferReader {
-    constructor(buffer) {
-        this.buffer = buffer;
-        this.offset = 0;
-    }
-    readByte() {
-        if (!this.hasMore())
-            throw new Error('read past end');
-        return this.buffer[this.offset++];
-    }
-    readBytes(length) {
-        if (length === undefined) {
-            length = this.buffer.length - this.offset;
-        }
-        if (this.remainingBytes() < length)
-            throw new Error('read past end');
-        const bytes = this.buffer.slice(this.offset, this.offset + length);
-        this.offset += length;
-        return bytes;
-    }
-    hasMore() {
-        return this.offset < this.buffer.length;
-    }
-    remainingBytes() {
-        return this.buffer.length - this.offset;
-    }
-    peekByte() {
-        if (!this.hasMore())
-            throw new Error('read past end');
-        return this.buffer[this.offset];
-    }
-    readUint16LE() {
-        if (this.remainingBytes() < 2)
-            throw new Error('read past end');
-        const value = this.buffer[this.offset] | (this.buffer[this.offset + 1] << 8);
-        this.offset += 2;
-        return value;
-    }
-    readUint32LE() {
-        if (this.remainingBytes() < 4)
-            throw new Error('read past end');
-        const value = (this.buffer[this.offset] | (this.buffer[this.offset + 1] << 8) | (this.buffer[this.offset + 2] << 16) | (this.buffer[this.offset + 3] << 24)) >>> 0;
-        this.offset += 4;
-        return value;
-    }
-    readInt16LE() {
-        if (this.remainingBytes() < 2)
-            throw new Error('read past end');
-        const value = this.buffer[this.offset] | (this.buffer[this.offset + 1] << 8);
-        this.offset += 2;
-        return value < 0x8000 ? value : value - 0x10000;
-    }
-    readInt32LE() {
-        if (this.remainingBytes() < 4)
-            throw new Error('read past end');
-        const u = (this.buffer[this.offset] | (this.buffer[this.offset + 1] << 8) | (this.buffer[this.offset + 2] << 16) | (this.buffer[this.offset + 3] << 24)) >>> 0;
-        this.offset += 4;
-        return u < 0x80000000 ? u : u - 0x100000000;
-    }
-    readTimestamp() {
-        const timestamp = this.readUint32LE();
-        return new Date(timestamp * 1000);
-    }
-}
-export class BufferWriter {
-    constructor() {
-        this.buffer = [];
-    }
-    writeByte(value) {
-        this.buffer.push(value & 0xFF);
-    }
-    writeBytes(bytes) {
-        this.buffer.push(...bytes);
-    }
-    writeUint16LE(value) {
-        this.buffer.push(value & 0xFF, (value >> 8) & 0xFF);
-    }
-    writeUint32LE(value) {
-        this.buffer.push(value & 0xFF, (value >> 8) & 0xFF, (value >> 16) & 0xFF, (value >> 24) & 0xFF);
-    }
-    writeInt16LE(value) {
-        this.writeUint16LE(value < 0 ? value + 0x10000 : value);
-    }
-    writeInt32LE(value) {
-        this.writeUint32LE(value < 0 ? value + 0x100000000 : value);
-    }
-    writeTimestamp(date) {
-        const timestamp = Math.floor(date.getTime() / 1000);
-        this.writeUint32LE(timestamp);
-    }
-    toBytes() {
-        return new Uint8Array(this.buffer);
-    }
-}