@hamradio/meshcore 1.1.1

package/dist/index.d.mts

@@ -0,0 +1,392 @@
+type NodeHash = number;
+interface IIdentity {
+    hash(): NodeHash;
+    toString(): string;
+    verify(signature: Uint8Array, message: Uint8Array): boolean;
+    matches(other: IIdentity | IPublicKey | Uint8Array | string): boolean;
+}
+interface ILocalIdentity extends IIdentity {
+    sign(message: Uint8Array): Uint8Array;
+    calculateSharedSecret(other: IIdentity | IPublicKey): ISharedSecret;
+}
+interface IContact {
+    name: string;
+    identity: IIdentity;
+    calculateSharedSecret(me: ILocalIdentity): ISharedSecret;
+}
+
+type identity_types_IContact = IContact;
+type identity_types_IIdentity = IIdentity;
+type identity_types_ILocalIdentity = ILocalIdentity;
+type identity_types_NodeHash = NodeHash;
+declare namespace identity_types {
+  export type { identity_types_IContact as IContact, identity_types_IIdentity as IIdentity, identity_types_ILocalIdentity as ILocalIdentity, identity_types_NodeHash as NodeHash };
+}
+
+interface IPublicKey {
+    toHash(): NodeHash;
+    toBytes(): Uint8Array;
+    toString(): string;
+    equals(other: IPublicKey | Uint8Array | string): boolean;
+    verify(message: Uint8Array, signature: Uint8Array): boolean;
+}
+interface IPrivateKey extends IPublicKey {
+    toPublicKey(): IPublicKey;
+    sign(message: Uint8Array): Uint8Array;
+}
+interface ISharedSecret {
+    toHash(): NodeHash;
+    toBytes(): Uint8Array;
+    toString(): string;
+    decrypt(hmac: Uint8Array, ciphertext: Uint8Array): Uint8Array;
+    encrypt(data: Uint8Array): {
+        hmac: Uint8Array;
+        ciphertext: Uint8Array;
+    };
+}
+interface IStaticSecret {
+    publicKey(): IPublicKey;
+    diffieHellman(otherPublicKey: IPublicKey): ISharedSecret;
+}
+
+type crypto_types_IPrivateKey = IPrivateKey;
+type crypto_types_IPublicKey = IPublicKey;
+type crypto_types_ISharedSecret = ISharedSecret;
+type crypto_types_IStaticSecret = IStaticSecret;
+declare namespace crypto_types {
+  export type { crypto_types_IPrivateKey as IPrivateKey, crypto_types_IPublicKey as IPublicKey, crypto_types_ISharedSecret as ISharedSecret, crypto_types_IStaticSecret as IStaticSecret };
+}
+
+declare class PublicKey implements IPublicKey {
+    key: Uint8Array;
+    constructor(key: Uint8Array | string);
+    toHash(): NodeHash;
+    toBytes(): Uint8Array;
+    toString(): string;
+    equals(other: PublicKey | Uint8Array | string): boolean;
+    verify(message: Uint8Array, signature: Uint8Array): boolean;
+}
+declare class PrivateKey {
+    private secretKey;
+    private publicKey;
+    constructor(seed: Uint8Array | string);
+    toPublicKey(): PublicKey;
+    toBytes(): Uint8Array;
+    toString(): string;
+    sign(message: Uint8Array): Uint8Array;
+    calculateSharedSecret(other: PublicKey | Uint8Array | string): Uint8Array;
+    static generate(): PrivateKey;
+}
+declare class SharedSecret implements ISharedSecret {
+    private secret;
+    constructor(secret: Uint8Array);
+    toHash(): NodeHash;
+    toBytes(): Uint8Array;
+    toString(): string;
+    decrypt(hmac: Uint8Array, ciphertext: Uint8Array): Uint8Array;
+    encrypt(data: Uint8Array): {
+        hmac: Uint8Array;
+        ciphertext: Uint8Array;
+    };
+    private calculateHmac;
+    static fromName(name: string): SharedSecret;
+}
+declare class StaticSecret implements IStaticSecret {
+    private secret;
+    constructor(secret: Uint8Array | string);
+    publicKey(): IPublicKey;
+    diffieHellman(otherPublicKey: IPublicKey): SharedSecret;
+}
+
+type Uint16 = number;
+interface IPacket {
+    header: number;
+    transport?: [Uint16, Uint16];
+    pathLength: number;
+    path: Uint8Array;
+    payload: Uint8Array;
+    decode(): Payload;
+}
+declare enum RouteType {
+    TRANSPORT_FLOOD = 0,
+    FLOOD = 1,
+    DIRECT = 2,
+    TRANSPORT_DIRECT = 3
+}
+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
+}
+type Payload = RequestPayload | ResponsePayload | TextPayload | AckPayload | AdvertPayload | GroupTextPayload | GroupDataPayload | AnonReqPayload | PathPayload | TracePayload | RawCustomPayload;
+interface EncryptedPayload {
+    cipherMAC: Uint8Array;
+    cipherText: Uint8Array;
+}
+interface RequestPayload {
+    type: PayloadType.REQUEST;
+    dst: NodeHash;
+    src: NodeHash;
+    encrypted: EncryptedPayload;
+    decrypted?: DecryptedRequest;
+}
+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
+}
+interface DecryptedRequest {
+    timestamp: Date;
+    requestType: RequestType;
+    requestData: Uint8Array;
+}
+interface ResponsePayload {
+    type: PayloadType.RESPONSE;
+    dst: NodeHash;
+    src: NodeHash;
+    encrypted: EncryptedPayload;
+    decrypted?: DecryptedResponse;
+}
+interface DecryptedResponse {
+    timestamp: Date;
+    responseData: Uint8Array;
+}
+interface TextPayload {
+    type: PayloadType.TEXT;
+    dst: NodeHash;
+    src: NodeHash;
+    encrypted: EncryptedPayload;
+    decrypted?: DecryptedText;
+}
+declare enum TextType {
+    PLAIN_TEXT = 0,
+    CLI_COMMAND = 1,
+    SIGNED_PLAIN_TEXT = 2
+}
+interface DecryptedText {
+    timestamp: Date;
+    textType: TextType;
+    attempt: number;
+    message: string;
+}
+interface AckPayload {
+    type: PayloadType.ACK;
+    checksum: Uint8Array;
+}
+interface AdvertPayload {
+    type: PayloadType.ADVERT;
+    publicKey: Uint8Array;
+    timestamp: Date;
+    signature: Uint8Array;
+    appdata: AdvertAppData;
+}
+declare enum NodeType {
+    CHAT_NODE = 1,
+    REPEATER = 2,
+    ROOM_SERVER = 3,
+    SENSOR_NODE = 4
+}
+interface AdvertAppData {
+    nodeType: NodeType;
+    hasLocation: boolean;
+    location?: [number, number];
+    hasFeature1: boolean;
+    feature1?: Uint16;
+    hasFeature2: boolean;
+    feature2?: Uint16;
+    hasName: boolean;
+    name?: string;
+}
+interface GroupTextPayload {
+    type: PayloadType.GROUP_TEXT;
+    channelHash: NodeHash;
+    encrypted: EncryptedPayload;
+    decrypted?: DecryptedGroupText;
+}
+interface DecryptedGroupText {
+    timestamp: Date;
+    textType: TextType;
+    attempt: number;
+    message: string;
+}
+interface GroupDataPayload {
+    type: PayloadType.GROUP_DATA;
+    channelHash: NodeHash;
+    encrypted: EncryptedPayload;
+    decrypted?: DecryptedGroupData;
+}
+interface DecryptedGroupData {
+    timestamp: Date;
+    data: Uint8Array;
+}
+interface AnonReqPayload {
+    type: PayloadType.ANON_REQ;
+    dst: NodeHash;
+    publicKey: Uint8Array;
+    encrypted: EncryptedPayload;
+    decrypted?: DecryptedAnonReq;
+}
+interface DecryptedAnonReq {
+    timestamp: Date;
+    data: Uint8Array;
+}
+interface PathPayload {
+    type: PayloadType.PATH;
+    dst: NodeHash;
+    src: NodeHash;
+}
+interface TracePayload {
+    type: PayloadType.TRACE;
+    tag: number;
+    authCode: number;
+    flags: number;
+    nodes: Uint8Array;
+}
+interface RawCustomPayload {
+    type: PayloadType.RAW_CUSTOM;
+    data: Uint8Array;
+}
+
+type packet_types_AckPayload = AckPayload;
+type packet_types_AdvertAppData = AdvertAppData;
+type packet_types_AdvertPayload = AdvertPayload;
+type packet_types_AnonReqPayload = AnonReqPayload;
+type packet_types_DecryptedAnonReq = DecryptedAnonReq;
+type packet_types_DecryptedGroupData = DecryptedGroupData;
+type packet_types_DecryptedGroupText = DecryptedGroupText;
+type packet_types_DecryptedRequest = DecryptedRequest;
+type packet_types_DecryptedResponse = DecryptedResponse;
+type packet_types_DecryptedText = DecryptedText;
+type packet_types_EncryptedPayload = EncryptedPayload;
+type packet_types_GroupDataPayload = GroupDataPayload;
+type packet_types_GroupTextPayload = GroupTextPayload;
+type packet_types_IPacket = IPacket;
+type packet_types_NodeType = NodeType;
+declare const packet_types_NodeType: typeof NodeType;
+type packet_types_PathPayload = PathPayload;
+type packet_types_Payload = Payload;
+type packet_types_PayloadType = PayloadType;
+declare const packet_types_PayloadType: typeof PayloadType;
+type packet_types_RawCustomPayload = RawCustomPayload;
+type packet_types_RequestPayload = RequestPayload;
+type packet_types_RequestType = RequestType;
+declare const packet_types_RequestType: typeof RequestType;
+type packet_types_ResponsePayload = ResponsePayload;
+type packet_types_RouteType = RouteType;
+declare const packet_types_RouteType: typeof RouteType;
+type packet_types_TextPayload = TextPayload;
+type packet_types_TextType = TextType;
+declare const packet_types_TextType: typeof TextType;
+type packet_types_TracePayload = TracePayload;
+type packet_types_Uint16 = Uint16;
+declare namespace packet_types {
+  export { type packet_types_AckPayload as AckPayload, type packet_types_AdvertAppData as AdvertAppData, type packet_types_AdvertPayload as AdvertPayload, type packet_types_AnonReqPayload as AnonReqPayload, type packet_types_DecryptedAnonReq as DecryptedAnonReq, type packet_types_DecryptedGroupData as DecryptedGroupData, type packet_types_DecryptedGroupText as DecryptedGroupText, type packet_types_DecryptedRequest as DecryptedRequest, type packet_types_DecryptedResponse as DecryptedResponse, type packet_types_DecryptedText as DecryptedText, type packet_types_EncryptedPayload as EncryptedPayload, type packet_types_GroupDataPayload as GroupDataPayload, type packet_types_GroupTextPayload as GroupTextPayload, type packet_types_IPacket as IPacket, packet_types_NodeType as NodeType, type packet_types_PathPayload as PathPayload, type packet_types_Payload as Payload, packet_types_PayloadType as PayloadType, type packet_types_RawCustomPayload as RawCustomPayload, type packet_types_RequestPayload as RequestPayload, packet_types_RequestType as RequestType, type packet_types_ResponsePayload as ResponsePayload, packet_types_RouteType as RouteType, type packet_types_TextPayload as TextPayload, packet_types_TextType as TextType, type packet_types_TracePayload as TracePayload, type packet_types_Uint16 as Uint16 };
+}
+
+declare const parseNodeHash: (hash: NodeHash | string | Uint8Array) => NodeHash;
+declare class Identity implements IIdentity {
+    publicKey: PublicKey;
+    constructor(publicKey: PublicKey | Uint8Array | string);
+    hash(): NodeHash;
+    toString(): string;
+    verify(signature: Uint8Array, message: Uint8Array): boolean;
+    matches(other: Identity | PublicKey | Uint8Array | string): boolean;
+}
+declare class LocalIdentity extends Identity implements ILocalIdentity {
+    private privateKey;
+    constructor(privateKey: PrivateKey | Uint8Array | string, publicKey: PublicKey | Uint8Array | string);
+    sign(message: Uint8Array): Uint8Array;
+    calculateSharedSecret(other: IIdentity | IPublicKey): SharedSecret;
+}
+declare class Contact {
+    name: string;
+    identity: Identity;
+    constructor(name: string, identity: Identity | PublicKey | Uint8Array | string);
+    matches(hash: Uint8Array | PublicKey): boolean;
+    publicKey(): PublicKey;
+    calculateSharedSecret(me: LocalIdentity): SharedSecret;
+}
+declare class Group {
+    name: string;
+    private secret;
+    constructor(name: string, secret?: SharedSecret);
+    hash(): NodeHash;
+    decryptText(hmac: Uint8Array, ciphertext: Uint8Array): DecryptedGroupText;
+    encryptText(plain: DecryptedGroupText): {
+        hmac: Uint8Array;
+        ciphertext: Uint8Array;
+    };
+    decryptData(hmac: Uint8Array, ciphertext: Uint8Array): DecryptedGroupData;
+    encryptData(plain: DecryptedGroupData): {
+        hmac: Uint8Array;
+        ciphertext: Uint8Array;
+    };
+}
+declare class Contacts {
+    private localIdentities;
+    private contacts;
+    private groups;
+    addLocalIdentity(identity: LocalIdentity): void;
+    addContact(contact: Contact): void;
+    decrypt(src: NodeHash | PublicKey, dst: NodeHash, hmac: Uint8Array, ciphertext: Uint8Array): {
+        localIdentity: LocalIdentity;
+        contact: Contact;
+        decrypted: Uint8Array;
+    };
+    private calculateSharedSecret;
+    addGroup(group: Group): void;
+    decryptGroupText(channelHash: NodeHash, hmac: Uint8Array, ciphertext: Uint8Array): {
+        decrypted: DecryptedGroupText;
+        group: Group;
+    };
+    decryptGroupData(channelHash: NodeHash, hmac: Uint8Array, ciphertext: Uint8Array): {
+        decrypted: DecryptedGroupData;
+        group: Group;
+    };
+}
+
+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;
+}
+
+export { Contact, Contacts, Group, Identity, LocalIdentity, Packet, PrivateKey, PublicKey, SharedSecret, StaticSecret, crypto_types as cryptoTypes, crypto_types as cryptoTypesTypes, identity_types as identityTypes, identity_types as identityTypesTypes, packet_types as packetTypes, packet_types as packetTypesTypes, parseNodeHash };