@hamradio/meshcore 1.1.2 → 1.2.0

package/dist/index.mjs

@@ -1,8 +1,51 @@
-// src/crypto.ts
-import { ed25519, x25519 } from "@noble/curves/ed25519.js";
+// src/packet.types.ts
+var RouteType = /* @__PURE__ */ ((RouteType2) => {
+  RouteType2[RouteType2["TRANSPORT_FLOOD"] = 0] = "TRANSPORT_FLOOD";
+  RouteType2[RouteType2["FLOOD"] = 1] = "FLOOD";
+  RouteType2[RouteType2["DIRECT"] = 2] = "DIRECT";
+  RouteType2[RouteType2["TRANSPORT_DIRECT"] = 3] = "TRANSPORT_DIRECT";
+  return RouteType2;
+})(RouteType || {});
+var PayloadType = /* @__PURE__ */ ((PayloadType2) => {
+  PayloadType2[PayloadType2["REQUEST"] = 0] = "REQUEST";
+  PayloadType2[PayloadType2["RESPONSE"] = 1] = "RESPONSE";
+  PayloadType2[PayloadType2["TEXT"] = 2] = "TEXT";
+  PayloadType2[PayloadType2["ACK"] = 3] = "ACK";
+  PayloadType2[PayloadType2["ADVERT"] = 4] = "ADVERT";
+  PayloadType2[PayloadType2["GROUP_TEXT"] = 5] = "GROUP_TEXT";
+  PayloadType2[PayloadType2["GROUP_DATA"] = 6] = "GROUP_DATA";
+  PayloadType2[PayloadType2["ANON_REQ"] = 7] = "ANON_REQ";
+  PayloadType2[PayloadType2["PATH"] = 8] = "PATH";
+  PayloadType2[PayloadType2["TRACE"] = 9] = "TRACE";
+  PayloadType2[PayloadType2["RAW_CUSTOM"] = 15] = "RAW_CUSTOM";
+  return PayloadType2;
+})(PayloadType || {});
+var RequestType = /* @__PURE__ */ ((RequestType2) => {
+  RequestType2[RequestType2["GET_STATS"] = 1] = "GET_STATS";
+  RequestType2[RequestType2["KEEP_ALIVE"] = 2] = "KEEP_ALIVE";
+  RequestType2[RequestType2["GET_TELEMETRY"] = 3] = "GET_TELEMETRY";
+  RequestType2[RequestType2["GET_MIN_MAX_AVG"] = 4] = "GET_MIN_MAX_AVG";
+  RequestType2[RequestType2["GET_ACL"] = 5] = "GET_ACL";
+  RequestType2[RequestType2["GET_NEIGHBORS"] = 6] = "GET_NEIGHBORS";
+  RequestType2[RequestType2["GET_OWNER_INFO"] = 7] = "GET_OWNER_INFO";
+  return RequestType2;
+})(RequestType || {});
+var TextType = /* @__PURE__ */ ((TextType2) => {
+  TextType2[TextType2["PLAIN_TEXT"] = 0] = "PLAIN_TEXT";
+  TextType2[TextType2["CLI_COMMAND"] = 1] = "CLI_COMMAND";
+  TextType2[TextType2["SIGNED_PLAIN_TEXT"] = 2] = "SIGNED_PLAIN_TEXT";
+  return TextType2;
+})(TextType || {});
+var NodeType = /* @__PURE__ */ ((NodeType2) => {
+  NodeType2[NodeType2["CHAT_NODE"] = 1] = "CHAT_NODE";
+  NodeType2[NodeType2["REPEATER"] = 2] = "REPEATER";
+  NodeType2[NodeType2["ROOM_SERVER"] = 3] = "ROOM_SERVER";
+  NodeType2[NodeType2["SENSOR_NODE"] = 4] = "SENSOR_NODE";
+  return NodeType2;
+})(NodeType || {});
+
+// src/packet.ts
 import { sha256 } from "@noble/hashes/sha2.js";
-import { hmac } from "@noble/hashes/hmac.js";
-import { ecb } from "@noble/ciphers/aes.js";
 
 // src/parser.ts
 import { equalBytes } from "@noble/ciphers/utils.js";
@@ -122,7 +165,510 @@ var BufferWriter = class {
   }
 };
 
+// src/packet.ts
+var Packet = 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 & 3;
+    this.payloadVersion = header >> 6 & 3;
+    this.payloadType = header >> 2 & 15;
+    this.pathHashSize = (pathLength >> 6) + 1;
+    this.pathHashCount = pathLength & 63;
+    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 & 3;
+    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 === 0 /* TRANSPORT_FLOOD */ || routeType === 3 /* TRANSPORT_DIRECT */;
+  }
+  hash() {
+    const hash = sha256.create();
+    hash.update(new Uint8Array([this.payloadType]));
+    if (this.payloadType === 9 /* TRACE */) {
+      hash.update(new Uint8Array([this.pathLength]));
+    }
+    hash.update(this.payload);
+    const digest = hash.digest();
+    return bytesToHex(digest.slice(0, 8));
+  }
+  ensureStructure() {
+    if (typeof this.structure !== "undefined") {
+      return;
+    }
+    let pathHashType;
+    switch (this.pathHashSize) {
+      case 1:
+        pathHashType = 6 /* BYTES */;
+        break;
+      case 2:
+        pathHashType = 7 /* WORDS */;
+        break;
+      case 4:
+        pathHashType = 8 /* DWORDS */;
+        break;
+      default:
+        throw new Error(`Unsupported path hash size: ${this.pathHashSize}`);
+    }
+    this.structure = [
+      /* Header segment */
+      { name: "header", data: new Uint8Array([this.header, this.pathLength, ...this.path]), fields: [
+        /* Header flags */
+        {
+          name: "flags",
+          type: 0 /* BITS */,
+          size: 1,
+          bits: [
+            { name: "route type", size: 2 },
+            { name: "payload version", size: 2 },
+            { name: "payload type", size: 4 }
+          ]
+        },
+        /* Transport codes */
+        ..._Packet.hasTransportCodes(this.routeType) ? [
+          {
+            name: "transport code 1",
+            type: 3 /* UINT16_BE */,
+            size: 2
+          },
+          {
+            name: "transport code 2",
+            type: 3 /* UINT16_BE */,
+            size: 2
+          }
+        ] : [],
+        /* Path length and hashes */
+        {
+          name: "path length",
+          type: 1 /* UINT8 */,
+          size: 1,
+          bits: [
+            { name: "path hash size", size: 2 },
+            { name: "path hash count", size: 6 }
+          ]
+        },
+        {
+          name: "path hashes",
+          type: pathHashType,
+          size: this.path.length
+        }
+      ] }
+    ];
+  }
+  decode(withStructure) {
+    let result;
+    switch (this.payloadType) {
+      case 0 /* REQUEST */:
+        result = this.decodeRequest(withStructure);
+        break;
+      case 1 /* RESPONSE */:
+        result = this.decodeResponse(withStructure);
+        break;
+      case 2 /* TEXT */:
+        result = this.decodeText(withStructure);
+        break;
+      case 3 /* ACK */:
+        result = this.decodeAck(withStructure);
+        break;
+      case 4 /* ADVERT */:
+        result = this.decodeAdvert(withStructure);
+        break;
+      case 5 /* GROUP_TEXT */:
+        result = this.decodeGroupText(withStructure);
+        break;
+      case 6 /* GROUP_DATA */:
+        result = this.decodeGroupData(withStructure);
+        break;
+      case 7 /* ANON_REQ */:
+        result = this.decodeAnonReq(withStructure);
+        break;
+      case 8 /* PATH */:
+        result = this.decodePath(withStructure);
+        break;
+      case 9 /* TRACE */:
+        result = this.decodeTrace(withStructure);
+        break;
+      case 15 /* RAW_CUSTOM */:
+        result = this.decodeRawCustom(withStructure);
+        break;
+      default:
+        throw new Error(`Unsupported payload type: ${this.payloadType}`);
+    }
+    console.log("packet decode with structure:", typeof withStructure, withStructure, { result });
+    if (typeof withStructure === "boolean" && withStructure && "segment" in result && "payload" in result) {
+      this.ensureStructure();
+      const structure = [...this.structure, result.segment];
+      return { payload: result.payload, structure };
+    }
+    return result;
+  }
+  decodeEncryptedPayload(reader) {
+    const cipherMAC = reader.readBytes(2);
+    const cipherText = reader.readBytes(reader.remainingBytes());
+    return { cipherMAC, cipherText };
+  }
+  decodeRequest(withSegment) {
+    if (this.payload.length < 4) {
+      throw new Error("Invalid request payload: too short");
+    }
+    const reader = new BufferReader(this.payload);
+    const dst = reader.readByte();
+    const src = reader.readByte();
+    const encrypted = this.decodeEncryptedPayload(reader);
+    const payload = {
+      type: 0 /* REQUEST */,
+      dst,
+      src,
+      encrypted
+    };
+    if (typeof withSegment === "boolean" && withSegment) {
+      const segment = {
+        name: "request payload",
+        data: this.payload,
+        fields: [
+          { name: "destination hash", type: 1 /* UINT8 */, size: 1, value: dst },
+          { name: "source hash", type: 1 /* UINT8 */, size: 1, value: src },
+          { name: "cipher MAC", type: 6 /* BYTES */, size: 2, value: encrypted.cipherMAC },
+          { name: "cipher text", type: 6 /* BYTES */, size: encrypted.cipherText.length, value: encrypted.cipherText }
+        ]
+      };
+      return { payload, segment };
+    }
+    return payload;
+  }
+  decodeResponse(withSegment) {
+    if (this.payload.length < 4) {
+      throw new Error("Invalid response payload: too short");
+    }
+    const reader = new BufferReader(this.payload);
+    const dst = reader.readByte();
+    const src = reader.readByte();
+    const encrypted = this.decodeEncryptedPayload(reader);
+    const payload = {
+      type: 1 /* RESPONSE */,
+      dst,
+      src,
+      encrypted
+    };
+    if (typeof withSegment === "boolean" && withSegment) {
+      const segment = {
+        name: "response payload",
+        data: this.payload,
+        fields: [
+          { name: "destination hash", type: 1 /* UINT8 */, size: 1, value: dst },
+          { name: "source hash", type: 1 /* UINT8 */, size: 1, value: src },
+          { name: "cipher MAC", type: 6 /* BYTES */, size: 2, value: encrypted.cipherMAC },
+          { name: "cipher text", type: 6 /* BYTES */, size: encrypted.cipherText.length, value: encrypted.cipherText }
+        ]
+      };
+      return { payload, segment };
+    }
+    return payload;
+  }
+  decodeText(withSegment) {
+    if (this.payload.length < 4) {
+      throw new Error("Invalid text payload: too short");
+    }
+    const reader = new BufferReader(this.payload);
+    const dst = reader.readByte();
+    const src = reader.readByte();
+    const encrypted = this.decodeEncryptedPayload(reader);
+    const payload = {
+      type: 2 /* TEXT */,
+      dst,
+      src,
+      encrypted
+    };
+    if (typeof withSegment === "boolean" && withSegment) {
+      const segment = {
+        name: "text payload",
+        data: this.payload,
+        fields: [
+          { name: "destination hash", type: 1 /* UINT8 */, size: 1, value: dst },
+          { name: "source hash", type: 1 /* UINT8 */, size: 1, value: src },
+          { name: "cipher MAC", type: 6 /* BYTES */, size: 2, value: encrypted.cipherMAC },
+          { name: "cipher text", type: 6 /* BYTES */, size: encrypted.cipherText.length, value: encrypted.cipherText }
+        ]
+      };
+      return { payload, segment };
+    }
+    return payload;
+  }
+  decodeAck(withSegment) {
+    if (this.payload.length < 4) {
+      throw new Error("Invalid ack payload: too short");
+    }
+    const reader = new BufferReader(this.payload);
+    const checksum = reader.readBytes(4);
+    const payload = {
+      type: 3 /* ACK */,
+      checksum
+    };
+    if (typeof withSegment === "boolean" && withSegment) {
+      const segment = {
+        name: "ack payload",
+        data: this.payload,
+        fields: [
+          { name: "checksum", type: 6 /* BYTES */, size: 4, value: checksum }
+        ]
+      };
+      return { payload, segment };
+    }
+    return payload;
+  }
+  decodeAdvert(withSegment) {
+    if (this.payload.length < 4) {
+      throw new Error("Invalid advert payload: too short");
+    }
+    const reader = new BufferReader(this.payload);
+    const payload = {
+      type: 4 /* ADVERT */,
+      publicKey: reader.readBytes(32),
+      timestamp: reader.readTimestamp(),
+      signature: reader.readBytes(64)
+    };
+    let segment;
+    if (typeof withSegment === "boolean" && withSegment) {
+      segment = {
+        name: "advert payload",
+        data: this.payload,
+        fields: [
+          { type: 6 /* BYTES */, name: "public key", size: 32 },
+          { type: 4 /* UINT32_LE */, name: "timestamp", size: 4, value: payload.timestamp },
+          { type: 6 /* BYTES */, name: "signature", size: 64 }
+        ]
+      };
+    }
+    const flags = reader.readByte();
+    const appdata = {
+      nodeType: flags & 15,
+      hasLocation: (flags & 16 /* HAS_LOCATION */) !== 0,
+      hasFeature1: (flags & 32 /* HAS_FEATURE1 */) !== 0,
+      hasFeature2: (flags & 64 /* HAS_FEATURE2 */) !== 0,
+      hasName: (flags & 128 /* HAS_NAME */) !== 0
+    };
+    if (typeof withSegment === "boolean" && withSegment) {
+      segment.fields.push({ type: 0 /* BITS */, name: "flags", size: 1, value: flags, bits: [
+        { size: 4, name: "node type" },
+        { size: 1, name: "location flag" },
+        { size: 1, name: "feature1 flag" },
+        { size: 1, name: "feature2 flag" },
+        { size: 1, name: "name flag" }
+      ] });
+    }
+    if (appdata.hasLocation) {
+      const lat = reader.readInt32LE() / 1e5;
+      const lon = reader.readInt32LE() / 1e5;
+      appdata.location = [lat, lon];
+      if (typeof withSegment === "boolean" && withSegment) {
+        segment.fields.push({ type: 4 /* UINT32_LE */, name: "latitude", size: 4, value: lat });
+        segment.fields.push({ type: 4 /* UINT32_LE */, name: "longitude", size: 4, value: lon });
+      }
+    }
+    if (appdata.hasFeature1) {
+      appdata.feature1 = reader.readUint16LE();
+      if (typeof withSegment === "boolean" && withSegment) {
+        segment.fields.push({ type: 2 /* UINT16_LE */, name: "feature1", size: 2, value: appdata.feature1 });
+      }
+    }
+    if (appdata.hasFeature2) {
+      appdata.feature2 = reader.readUint16LE();
+      if (typeof withSegment === "boolean" && withSegment) {
+        segment.fields.push({ type: 2 /* UINT16_LE */, name: "feature2", size: 2, value: appdata.feature2 });
+      }
+    }
+    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));
+      if (typeof withSegment === "boolean" && withSegment) {
+        segment.fields.push({ type: 10 /* C_STRING */, name: "name", size: nameBytes.length, value: appdata.name });
+      }
+    }
+    if (typeof withSegment === "boolean" && withSegment && typeof segment !== "undefined") {
+      return { payload: { ...payload, appdata }, segment };
+    }
+    return { ...payload, appdata };
+  }
+  decodeGroupText(withSegment) {
+    if (this.payload.length < 3) {
+      throw new Error("Invalid group text payload: too short");
+    }
+    const reader = new BufferReader(this.payload);
+    const channelHash = reader.readByte();
+    const encrypted = this.decodeEncryptedPayload(reader);
+    const payload = {
+      type: 5 /* GROUP_TEXT */,
+      channelHash,
+      encrypted
+    };
+    if (typeof withSegment === "boolean" && withSegment) {
+      const segment = {
+        name: "group text payload",
+        data: this.payload,
+        fields: [
+          { name: "channel hash", type: 1 /* UINT8 */, size: 1, value: channelHash },
+          { name: "cipher MAC", type: 6 /* BYTES */, size: 2, value: encrypted.cipherMAC },
+          { name: "cipher text", type: 6 /* BYTES */, size: encrypted.cipherText.length, value: encrypted.cipherText }
+        ]
+      };
+      return { payload, segment };
+    }
+    return payload;
+  }
+  decodeGroupData(withSegment) {
+    if (this.payload.length < 3) {
+      throw new Error("Invalid group data payload: too short");
+    }
+    const reader = new BufferReader(this.payload);
+    const payload = {
+      type: 6 /* GROUP_DATA */,
+      channelHash: reader.readByte(),
+      encrypted: this.decodeEncryptedPayload(reader)
+    };
+    if (typeof withSegment === "boolean" && withSegment) {
+      const segment = {
+        name: "group data payload",
+        data: this.payload,
+        fields: [
+          { name: "channel hash", type: 1 /* UINT8 */, size: 1, value: payload.channelHash },
+          { name: "cipher MAC", type: 6 /* BYTES */, size: 2, value: payload.encrypted.cipherMAC },
+          { name: "cipher text", type: 6 /* BYTES */, size: payload.encrypted.cipherText.length, value: payload.encrypted.cipherText }
+        ]
+      };
+      return { payload, segment };
+    }
+    return payload;
+  }
+  decodeAnonReq(withSegment) {
+    if (this.payload.length < 1 + 32 + 2) {
+      throw new Error("Invalid anon req payload: too short");
+    }
+    const reader = new BufferReader(this.payload);
+    const payload = {
+      type: 7 /* ANON_REQ */,
+      dst: reader.readByte(),
+      publicKey: reader.readBytes(32),
+      encrypted: this.decodeEncryptedPayload(reader)
+    };
+    if (typeof withSegment === "boolean" && withSegment) {
+      const segment = {
+        name: "anon req payload",
+        data: this.payload,
+        fields: [
+          { name: "destination hash", type: 1 /* UINT8 */, size: 1, value: payload.dst },
+          { name: "public key", type: 6 /* BYTES */, size: 32, value: payload.publicKey },
+          { name: "cipher MAC", type: 6 /* BYTES */, size: 2, value: payload.encrypted.cipherMAC },
+          { name: "cipher text", type: 6 /* BYTES */, size: payload.encrypted.cipherText.length, value: payload.encrypted.cipherText }
+        ]
+      };
+      return { payload, segment };
+    }
+    return payload;
+  }
+  decodePath(withSegment) {
+    if (this.payload.length < 2) {
+      throw new Error("Invalid path payload: too short");
+    }
+    const reader = new BufferReader(this.payload);
+    const payload = {
+      type: 8 /* PATH */,
+      dst: reader.readByte(),
+      src: reader.readByte()
+    };
+    if (typeof withSegment === "boolean" && withSegment) {
+      const segment = {
+        name: "path payload",
+        data: this.payload,
+        fields: [
+          { name: "destination hash", type: 1 /* UINT8 */, size: 1, value: payload.dst },
+          { name: "source hash", type: 1 /* UINT8 */, size: 1, value: payload.src }
+        ]
+      };
+      return { payload, segment };
+    }
+    return payload;
+  }
+  decodeTrace(withSegment) {
+    if (this.payload.length < 9) {
+      throw new Error("Invalid trace payload: too short");
+    }
+    const reader = new BufferReader(this.payload);
+    const payload = {
+      type: 9 /* TRACE */,
+      tag: reader.readUint32LE() >>> 0,
+      authCode: reader.readUint32LE() >>> 0,
+      flags: reader.readByte() & 3,
+      nodes: reader.readBytes()
+    };
+    if (typeof withSegment === "boolean" && withSegment) {
+      const segment = {
+        name: "trace payload",
+        data: this.payload,
+        fields: [
+          { name: "tag", type: 8 /* DWORDS */, size: 4, value: payload.tag },
+          { name: "auth code", type: 8 /* DWORDS */, size: 4, value: payload.authCode },
+          { name: "flags", type: 1 /* UINT8 */, size: 1, value: payload.flags },
+          { name: "nodes", type: 6 /* BYTES */, size: payload.nodes.length, value: payload.nodes }
+        ]
+      };
+      return { payload, segment };
+    }
+    return payload;
+  }
+  decodeRawCustom(withSegment) {
+    const payload = {
+      type: 15 /* RAW_CUSTOM */,
+      data: this.payload
+    };
+    if (typeof withSegment === "boolean" && withSegment) {
+      const segment = {
+        name: "raw custom payload",
+        data: this.payload,
+        fields: [
+          { name: "data", type: 6 /* BYTES */, size: this.payload.length, value: this.payload }
+        ]
+      };
+      return { payload, segment };
+    }
+    return payload;
+  }
+};
+
 // src/crypto.ts
+import { ed25519, x25519 } from "@noble/curves/ed25519.js";
+import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
+import { hmac } from "@noble/hashes/hmac.js";
+import { ecb } from "@noble/ciphers/aes.js";
 var PUBLIC_KEY_SIZE = 32;
 var SEED_SIZE = 32;
 var HMAC_SIZE = 2;
@@ -141,7 +687,7 @@ var PublicKey = class _PublicKey {
     }
   }
   toHash() {
-    return sha256.create().update(this.key).digest()[0];
+    return sha2562.create().update(this.key).digest()[0];
   }
   toBytes() {
     return this.key;
@@ -274,7 +820,7 @@ var SharedSecret = class _SharedSecret {
     return { hmac: hmac2, ciphertext };
   }
   calculateHmac(data) {
-    return hmac(sha256, this.secret, data).slice(0, HMAC_SIZE);
+    return hmac(sha2562, this.secret, data).slice(0, HMAC_SIZE);
   }
   static fromName(name) {
     if (name === "Public") {
@@ -282,7 +828,7 @@ var SharedSecret = class _SharedSecret {
     } else if (!/^#/.test(name)) {
       throw new Error("Only the 'Public' group or groups starting with '#' are supported");
     }
-    const hash = sha256.create().update(new TextEncoder().encode(name)).digest();
+    const hash = sha2562.create().update(new TextEncoder().encode(name)).digest();
     return new _SharedSecret(hash.slice(0, SHARED_SECRET_SIZE));
   }
 };
@@ -577,258 +1123,21 @@ var Contacts = class {
     throw new Error("Decryption failed with all known groups");
   }
 };
-
-// src/packet.ts
-import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
-var Packet = 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 & 3;
-    this.payloadVersion = header >> 6 & 3;
-    this.payloadType = header >> 2 & 15;
-    this.pathHashCount = (pathLength >> 6) + 1;
-    this.pathHashSize = pathLength & 63;
-    this.pathHashBytes = this.pathHashCount * this.pathHashSize;
-    this.pathHashes = [];
-    for (let i = 0; i < this.pathHashCount; i++) {
-      const hashBytes = this.path.slice(i * this.pathHashSize, (i + 1) * 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 & 3;
-    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 === 0 /* TRANSPORT_FLOOD */ || routeType === 3 /* TRANSPORT_DIRECT */;
-  }
-  hash() {
-    const hash = sha2562.create();
-    hash.update(new Uint8Array([this.payloadType]));
-    if (this.payloadType === 9 /* 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 0 /* REQUEST */:
-        return this.decodeRequest();
-      case 1 /* RESPONSE */:
-        return this.decodeResponse();
-      case 2 /* TEXT */:
-        return this.decodeText();
-      case 3 /* ACK */:
-        return this.decodeAck();
-      case 4 /* ADVERT */:
-        return this.decodeAdvert();
-      case 5 /* GROUP_TEXT */:
-        return this.decodeGroupText();
-      case 6 /* GROUP_DATA */:
-        return this.decodeGroupData();
-      case 7 /* ANON_REQ */:
-        return this.decodeAnonReq();
-      case 8 /* PATH */:
-        return this.decodePath();
-      case 9 /* TRACE */:
-        return this.decodeTrace();
-      case 15 /* 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: 0 /* 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: 1 /* 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: 2 /* 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: 3 /* 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: 4 /* ADVERT */,
-      publicKey: reader.readBytes(32),
-      timestamp: reader.readTimestamp(),
-      signature: reader.readBytes(64)
-    };
-    const flags = reader.readByte();
-    const appdata = {
-      nodeType: flags & 15,
-      hasLocation: (flags & 16) !== 0,
-      hasFeature1: (flags & 32) !== 0,
-      hasFeature2: (flags & 64) !== 0,
-      hasName: (flags & 128) !== 0
-    };
-    if (appdata.hasLocation) {
-      const lat = reader.readInt32LE() / 1e5;
-      const lon = reader.readInt32LE() / 1e5;
-      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: 5 /* 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: 6 /* 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: 7 /* 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: 8 /* 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: 9 /* TRACE */,
-      tag: reader.readUint32LE() >>> 0,
-      authCode: reader.readUint32LE() >>> 0,
-      flags: reader.readByte() & 3,
-      nodes: reader.readBytes()
-    };
-  }
-  decodeRawCustom() {
-    return {
-      type: 15 /* RAW_CUSTOM */,
-      data: this.payload
-    };
-  }
-};
 export {
   Contact,
   Contacts,
   Group,
   Identity,
   LocalIdentity,
+  NodeType,
   Packet,
+  PayloadType,
   PrivateKey,
   PublicKey,
+  RequestType,
+  RouteType,
   SharedSecret,
   StaticSecret,
+  TextType,
   parseNodeHash
 };