@hamradio/meshcore 1.1.1

package/dist/index.mjs

@@ -0,0 +1,834 @@
+// src/crypto.ts
+import { ed25519, x25519 } from "@noble/curves/ed25519.js";
+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";
+import { bytesToHex, hexToBytes as nobleHexToBytes } from "@noble/hashes/utils.js";
+var base64ToBytes = (base64, size) => {
+  let normalized = base64.replace(/-/g, "+").replace(/_/g, "/");
+  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 !== void 0 && bytes.length !== size) {
+    throw new Error(`Invalid base64 length: expected ${size} bytes, got ${bytes.length}`);
+  }
+  return bytes;
+};
+var hexToBytes = (hex, size) => {
+  const bytes = nobleHexToBytes(hex);
+  if (size !== void 0 && bytes.length !== size) {
+    throw new Error(`Invalid hex length: expected ${size} bytes, got ${bytes.length}`);
+  }
+  return bytes;
+};
+var BufferReader = class {
+  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 === void 0) {
+      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 < 32768 ? value : value - 65536;
+  }
+  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 < 2147483648 ? u : u - 4294967296;
+  }
+  readTimestamp() {
+    const timestamp = this.readUint32LE();
+    return new Date(timestamp * 1e3);
+  }
+};
+var BufferWriter = class {
+  constructor() {
+    this.buffer = [];
+  }
+  writeByte(value) {
+    this.buffer.push(value & 255);
+  }
+  writeBytes(bytes) {
+    this.buffer.push(...bytes);
+  }
+  writeUint16LE(value) {
+    this.buffer.push(value & 255, value >> 8 & 255);
+  }
+  writeUint32LE(value) {
+    this.buffer.push(
+      value & 255,
+      value >> 8 & 255,
+      value >> 16 & 255,
+      value >> 24 & 255
+    );
+  }
+  writeInt16LE(value) {
+    this.writeUint16LE(value < 0 ? value + 65536 : value);
+  }
+  writeInt32LE(value) {
+    this.writeUint32LE(value < 0 ? value + 4294967296 : value);
+  }
+  writeTimestamp(date) {
+    const timestamp = Math.floor(date.getTime() / 1e3);
+    this.writeUint32LE(timestamp);
+  }
+  toBytes() {
+    return new Uint8Array(this.buffer);
+  }
+};
+
+// src/crypto.ts
+var PUBLIC_KEY_SIZE = 32;
+var SEED_SIZE = 32;
+var HMAC_SIZE = 2;
+var SHARED_SECRET_SIZE = 32;
+var SIGNATURE_SIZE = 64;
+var STATIC_SECRET_SIZE = 32;
+var publicSecret = hexToBytes("8b3387e9c5cdea6ac9e5edbaa115cd72", 16);
+var PublicKey = class _PublicKey {
+  constructor(key) {
+    if (typeof key === "string") {
+      this.key = hexToBytes(key, PUBLIC_KEY_SIZE);
+    } else if (key instanceof Uint8Array) {
+      this.key = key;
+    } else {
+      throw new Error("Invalid type for PublicKey constructor");
+    }
+  }
+  toHash() {
+    return sha256.create().update(this.key).digest()[0];
+  }
+  toBytes() {
+    return this.key;
+  }
+  toString() {
+    return bytesToHex(this.key);
+  }
+  equals(other) {
+    let otherKey;
+    if (other instanceof _PublicKey) {
+      otherKey = other.toBytes();
+    } else if (other instanceof Uint8Array) {
+      otherKey = other;
+    } else if (typeof other === "string") {
+      otherKey = hexToBytes(other, PUBLIC_KEY_SIZE);
+    } else {
+      throw new Error("Invalid type for PublicKey comparison");
+    }
+    return equalBytes(this.key, otherKey);
+  }
+  verify(message, signature) {
+    if (signature.length !== SIGNATURE_SIZE) {
+      throw new Error(`Invalid signature length: expected ${SIGNATURE_SIZE} bytes, got ${signature.length}`);
+    }
+    return ed25519.verify(signature, message, this.key);
+  }
+};
+var PrivateKey = class _PrivateKey {
+  constructor(seed) {
+    if (typeof seed === "string") {
+      seed = hexToBytes(seed, SEED_SIZE);
+    }
+    if (seed.length !== SEED_SIZE) {
+      throw new Error(`Invalid seed length: expected ${SEED_SIZE} bytes, got ${seed.length}`);
+    }
+    const { secretKey, publicKey } = ed25519.keygen(seed);
+    this.secretKey = secretKey;
+    this.publicKey = new PublicKey(publicKey);
+  }
+  toPublicKey() {
+    return this.publicKey;
+  }
+  toBytes() {
+    return this.secretKey;
+  }
+  toString() {
+    return bytesToHex(this.secretKey);
+  }
+  sign(message) {
+    return ed25519.sign(message, this.secretKey);
+  }
+  calculateSharedSecret(other) {
+    let otherPublicKey;
+    if (other instanceof PublicKey) {
+      otherPublicKey = other;
+    } else if (other instanceof Uint8Array) {
+      otherPublicKey = new PublicKey(other);
+    } else if (typeof other === "string") {
+      otherPublicKey = new PublicKey(other);
+    } else {
+      throw new Error("Invalid type for calculateSharedSecret comparison");
+    }
+    return x25519.getSharedSecret(this.secretKey, otherPublicKey.toBytes());
+  }
+  static generate() {
+    const { secretKey } = ed25519.keygen();
+    return new _PrivateKey(secretKey);
+  }
+};
+var SharedSecret = class _SharedSecret {
+  constructor(secret) {
+    if (secret.length === SHARED_SECRET_SIZE / 2) {
+      const padded = new Uint8Array(SHARED_SECRET_SIZE);
+      padded.set(secret, SHARED_SECRET_SIZE - secret.length);
+      secret = padded;
+    }
+    if (secret.length !== SHARED_SECRET_SIZE) {
+      throw new Error(`Invalid shared secret length: expected ${SHARED_SECRET_SIZE} bytes, got ${secret.length}`);
+    }
+    this.secret = secret;
+  }
+  toHash() {
+    return this.secret[0];
+  }
+  toBytes() {
+    return this.secret;
+  }
+  toString() {
+    return bytesToHex(this.secret);
+  }
+  decrypt(hmac2, ciphertext) {
+    if (hmac2.length !== HMAC_SIZE) {
+      throw new Error(`Invalid HMAC length: expected ${HMAC_SIZE} bytes, got ${hmac2.length}`);
+    }
+    const expectedHmac = this.calculateHmac(ciphertext);
+    if (!equalBytes(hmac2, expectedHmac)) {
+      throw new Error(`Invalid HMAC: decryption failed: expected ${bytesToHex(expectedHmac)}, got ${bytesToHex(hmac2)}`);
+    }
+    const cipher = ecb(this.secret.slice(0, 16), { disablePadding: true });
+    const plaintext = new Uint8Array(ciphertext.length);
+    for (let i = 0; i < ciphertext.length; i += 16) {
+      const block = ciphertext.slice(i, i + 16);
+      const dec = cipher.decrypt(block);
+      plaintext.set(dec, i);
+    }
+    let end = plaintext.length;
+    while (end > 0 && plaintext[end - 1] === 0) {
+      end--;
+    }
+    return plaintext.slice(0, end);
+  }
+  encrypt(data) {
+    const key = this.secret.slice(0, 16);
+    const cipher = ecb(key, { disablePadding: true });
+    const fullBlocks = Math.floor(data.length / 16);
+    const remaining = data.length % 16;
+    const ciphertext = new Uint8Array((fullBlocks + (remaining > 0 ? 1 : 0)) * 16);
+    for (let i = 0; i < fullBlocks; i++) {
+      const block = data.slice(i * 16, (i + 1) * 16);
+      const enc = cipher.encrypt(block);
+      ciphertext.set(enc, i * 16);
+    }
+    if (remaining > 0) {
+      const lastBlock = new Uint8Array(16);
+      lastBlock.set(data.slice(fullBlocks * 16));
+      const enc = cipher.encrypt(lastBlock);
+      ciphertext.set(enc, fullBlocks * 16);
+    }
+    const hmac2 = this.calculateHmac(ciphertext);
+    return { hmac: hmac2, ciphertext };
+  }
+  calculateHmac(data) {
+    return hmac(sha256, this.secret, data).slice(0, HMAC_SIZE);
+  }
+  static fromName(name) {
+    if (name === "Public") {
+      return new _SharedSecret(publicSecret);
+    } 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();
+    return new _SharedSecret(hash.slice(0, SHARED_SECRET_SIZE));
+  }
+};
+var StaticSecret = class {
+  constructor(secret) {
+    if (typeof secret === "string") {
+      secret = hexToBytes(secret, STATIC_SECRET_SIZE);
+    }
+    if (secret.length !== STATIC_SECRET_SIZE) {
+      throw new Error(`Invalid static secret length: expected ${STATIC_SECRET_SIZE} bytes, got ${secret.length}`);
+    }
+    this.secret = secret;
+  }
+  publicKey() {
+    const publicKey = x25519.getPublicKey(this.secret);
+    return new PublicKey(publicKey);
+  }
+  diffieHellman(otherPublicKey) {
+    const sharedSecret = x25519.getSharedSecret(this.secret, otherPublicKey.toBytes());
+    return new SharedSecret(sharedSecret);
+  }
+};
+
+// src/identity.ts
+var parseNodeHash = (hash) => {
+  if (hash instanceof Uint8Array) {
+    return hash[0];
+  }
+  if (typeof hash === "number") {
+    if (hash < 0 || hash > 255) {
+      throw new Error("NodeHash number must be between 0x00 and 0xFF");
+    }
+    return hash;
+  } else if (typeof hash === "string") {
+    const parsed = hexToBytes(hash);
+    if (parsed.length !== 1) {
+      throw new Error("NodeHash string must represent a single byte");
+    }
+    return parsed[0];
+  }
+  throw new Error("Invalid NodeHash type");
+};
+var toPublicKeyBytes = (key) => {
+  if (key instanceof Identity) {
+    return key.publicKey.toBytes();
+  } else if (key instanceof PublicKey) {
+    return key.toBytes();
+  } else if (key instanceof Uint8Array) {
+    return key;
+  } else if (typeof key === "string") {
+    return hexToBytes(key);
+  } else {
+    throw new Error("Invalid type for toPublicKeyBytes");
+  }
+};
+var Identity = class {
+  constructor(publicKey) {
+    if (publicKey instanceof PublicKey) {
+      this.publicKey = publicKey;
+    } else if (publicKey instanceof Uint8Array || typeof publicKey === "string") {
+      this.publicKey = new PublicKey(publicKey);
+    } else {
+      throw new Error("Invalid type for Identity constructor");
+    }
+  }
+  hash() {
+    return this.publicKey.toHash();
+  }
+  toString() {
+    return this.publicKey.toString();
+  }
+  verify(signature, message) {
+    return this.publicKey.verify(message, signature);
+  }
+  matches(other) {
+    return this.publicKey.equals(toPublicKeyBytes(other));
+  }
+};
+var LocalIdentity = class extends Identity {
+  constructor(privateKey, publicKey) {
+    if (publicKey instanceof PublicKey) {
+      super(publicKey.toBytes());
+    } else {
+      super(publicKey);
+    }
+    if (privateKey instanceof PrivateKey) {
+      this.privateKey = privateKey;
+    } else {
+      this.privateKey = new PrivateKey(privateKey);
+    }
+  }
+  sign(message) {
+    return this.privateKey.sign(message);
+  }
+  calculateSharedSecret(other) {
+    let otherPublicKey;
+    if (other instanceof Identity) {
+      otherPublicKey = other.publicKey;
+    } else if ("toBytes" in other) {
+      otherPublicKey = new PublicKey(other.toBytes());
+    } else if ("publicKey" in other && other.publicKey instanceof Uint8Array) {
+      otherPublicKey = new PublicKey(other.publicKey);
+    } else if ("publicKey" in other && other.publicKey instanceof PublicKey) {
+      otherPublicKey = other.publicKey;
+    } else if ("publicKey" in other && typeof other.publicKey === "function") {
+      otherPublicKey = new PublicKey(other.publicKey().toBytes());
+    } else {
+      throw new Error("Invalid type for calculateSharedSecret comparison");
+    }
+    return new SharedSecret(this.privateKey.calculateSharedSecret(otherPublicKey));
+  }
+};
+var Contact = class {
+  constructor(name, identity) {
+    this.name = "";
+    this.name = name;
+    if (identity instanceof Identity) {
+      this.identity = identity;
+    } else if (identity instanceof PublicKey) {
+      this.identity = new Identity(identity);
+    } else if (identity instanceof Uint8Array || typeof identity === "string") {
+      this.identity = new Identity(identity);
+    } else {
+      throw new Error("Invalid type for Contact constructor");
+    }
+  }
+  matches(hash) {
+    return this.identity.publicKey.equals(hash);
+  }
+  publicKey() {
+    return this.identity.publicKey;
+  }
+  calculateSharedSecret(me) {
+    return me.calculateSharedSecret(this.identity);
+  }
+};
+var Group = class {
+  constructor(name, secret) {
+    this.name = name;
+    if (secret) {
+      this.secret = secret;
+    } else {
+      this.secret = SharedSecret.fromName(name);
+    }
+  }
+  hash() {
+    return this.secret.toHash();
+  }
+  decryptText(hmac2, ciphertext) {
+    const data = this.secret.decrypt(hmac2, ciphertext);
+    if (data.length < 5) {
+      throw new Error("Invalid ciphertext");
+    }
+    const reader = new BufferReader(data);
+    const timestamp = reader.readTimestamp();
+    const flags = reader.readByte();
+    const textType = flags >> 2 & 63;
+    const attempt = flags & 3;
+    const message = new TextDecoder("utf-8").decode(reader.readBytes());
+    return {
+      timestamp,
+      textType,
+      attempt,
+      message
+    };
+  }
+  encryptText(plain) {
+    const writer = new BufferWriter();
+    writer.writeTimestamp(plain.timestamp);
+    const flags = (plain.textType & 63) << 2 | plain.attempt & 3;
+    writer.writeByte(flags);
+    writer.writeBytes(new TextEncoder().encode(plain.message));
+    const data = writer.toBytes();
+    return this.secret.encrypt(data);
+  }
+  decryptData(hmac2, ciphertext) {
+    const data = this.secret.decrypt(hmac2, ciphertext);
+    if (data.length < 4) {
+      throw new Error("Invalid ciphertext");
+    }
+    const reader = new BufferReader(data);
+    return {
+      timestamp: reader.readTimestamp(),
+      data: reader.readBytes(reader.remainingBytes())
+    };
+  }
+  encryptData(plain) {
+    const writer = new BufferWriter();
+    writer.writeTimestamp(plain.timestamp);
+    writer.writeBytes(plain.data);
+    const data = writer.toBytes();
+    return this.secret.encrypt(data);
+  }
+};
+var Contacts = class {
+  constructor() {
+    this.localIdentities = [];
+    this.contacts = {};
+    this.groups = {};
+  }
+  addLocalIdentity(identity) {
+    this.localIdentities.push({ identity, sharedSecrets: {} });
+  }
+  addContact(contact) {
+    const hash = parseNodeHash(contact.identity.hash());
+    if (!this.contacts[hash]) {
+      this.contacts[hash] = [];
+    }
+    this.contacts[hash].push(contact);
+  }
+  decrypt(src, dst, hmac2, ciphertext) {
+    let contacts = [];
+    if (src instanceof PublicKey) {
+      const srcHash = parseNodeHash(src.toHash());
+      for (const contact of this.contacts[srcHash] || []) {
+        if (contact.identity.matches(src)) {
+          contacts.push(contact);
+        }
+      }
+      if (contacts.length === 0) {
+        contacts.push(new Contact("", new Identity(src.toBytes())));
+      }
+    } else {
+      const srcHash = parseNodeHash(src);
+      contacts = this.contacts[srcHash] || [];
+    }
+    if (contacts.length === 0) {
+      throw new Error("Unknown source hash");
+    }
+    const dstHash = parseNodeHash(dst);
+    const localIdentities = this.localIdentities.filter((li) => li.identity.publicKey.key[0] === dstHash);
+    if (localIdentities.length === 0) {
+      throw new Error("Unknown destination hash");
+    }
+    for (const localIdentity of localIdentities) {
+      for (const contact of contacts) {
+        const sharedSecret = this.calculateSharedSecret(localIdentity, contact);
+        try {
+          const decrypted = sharedSecret.decrypt(hmac2, ciphertext);
+          return { localIdentity: localIdentity.identity, contact, decrypted };
+        } catch {
+        }
+      }
+    }
+    throw new Error("Decryption failed with all known identities and contacts");
+  }
+  // Caches the calculated shared secret for a given local identity and contact to avoid redundant calculations.
+  calculateSharedSecret(localIdentity, contact) {
+    const cacheKey = contact.identity.toString();
+    if (localIdentity.sharedSecrets[cacheKey]) {
+      return localIdentity.sharedSecrets[cacheKey];
+    }
+    const sharedSecret = localIdentity.identity.calculateSharedSecret(contact.identity);
+    localIdentity.sharedSecrets[cacheKey] = sharedSecret;
+    return sharedSecret;
+  }
+  addGroup(group) {
+    const hash = parseNodeHash(group.hash());
+    if (!this.groups[hash]) {
+      this.groups[hash] = [];
+    }
+    this.groups[hash].push(group);
+  }
+  decryptGroupText(channelHash, hmac2, ciphertext) {
+    const hash = parseNodeHash(channelHash);
+    const groups = this.groups[hash] || [];
+    if (groups.length === 0) {
+      throw new Error("Unknown group hash");
+    }
+    for (const group of groups) {
+      try {
+        const decrypted = group.decryptText(hmac2, ciphertext);
+        return { decrypted, group };
+      } catch {
+      }
+    }
+    throw new Error("Decryption failed with all known groups");
+  }
+  decryptGroupData(channelHash, hmac2, ciphertext) {
+    const hash = parseNodeHash(channelHash);
+    const groups = this.groups[hash] || [];
+    if (groups.length === 0) {
+      throw new Error("Unknown group hash");
+    }
+    for (const group of groups) {
+      try {
+        const decrypted = group.decryptData(hmac2, ciphertext);
+        return { decrypted, group };
+      } catch {
+      }
+    }
+    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,
+  Packet,
+  PrivateKey,
+  PublicKey,
+  SharedSecret,
+  StaticSecret,
+  parseNodeHash
+};