@seriousme/opifex 1.9.4 → 1.11.0

package/mqttPacket/Properties.ts

@@ -0,0 +1,276 @@
+import { PacketType } from "./PacketType.ts";
+import type { InvertRecord, UTF8StringPair } from "./types.ts";
+
+export const PropertySetType = {
+  ...PacketType,
+  will: 100,
+} as const;
+
+export type TPropertySetType =
+  typeof PropertySetType[keyof typeof PropertySetType];
+
+export const propertyKind = {
+  boolean: 0, // its a byte in the MQTT standard, but for convenience we convert to boolean
+  byte: 1,
+  int16: 2,
+  int32: 3,
+  varInt: 4,
+  byteArray: 5,
+  utf8string: 6,
+  utf8StringPairs: 7,
+  varIntArray: 8,
+} as const;
+
+export const propertyToId = {
+  payloadFormatIndicator: 0x01,
+  messageExpiryInterval: 0x02,
+  contentType: 0x03,
+  responseTopic: 0x08,
+  correlationData: 0x09,
+  subscriptionIdentifier: 0x0b,
+  // special case,placeholder to encode decode multiple subscription identifiers
+  subscriptionIdentifiers: 0xff,
+  sessionExpiryInterval: 0x11,
+  assignedClientIdentifier: 0x12,
+  serverKeepAlive: 0x13,
+  authenticationMethod: 0x15,
+  authenticationData: 0x16,
+  requestProblemInformation: 0x17,
+  willDelayInterval: 0x18,
+  requestResponseInformation: 0x19,
+  responseInformation: 0x1a,
+  serverReference: 0x1c,
+  reasonString: 0x1f,
+  receiveMaximum: 0x21,
+  topicAliasMaximum: 0x22,
+  topicAlias: 0x23,
+  maximumQos: 0x24,
+  retainAvailable: 0x25,
+  userProperty: 0x26,
+  maximumPacketSize: 0x27,
+  wildcardSubscriptionAvailable: 0x28,
+  subscriptionIdentifierAvailable: 0x29,
+  sharedSubscriptionAvailable: 0x2a,
+} as const;
+
+type PropertyNames = keyof typeof propertyToId;
+// A helper type to convert a tuple of numbers to a union of strings
+
+export const propertyToKind = {
+  [propertyToId.payloadFormatIndicator]: propertyKind.boolean,
+  [propertyToId.messageExpiryInterval]: propertyKind.int32,
+  [propertyToId.contentType]: propertyKind.utf8string,
+  [propertyToId.responseTopic]: propertyKind.utf8string,
+  [propertyToId.correlationData]: propertyKind.byteArray,
+  [propertyToId.subscriptionIdentifier]: propertyKind.varInt,
+  [propertyToId.subscriptionIdentifiers]: propertyKind.varIntArray,
+  [propertyToId.sessionExpiryInterval]: propertyKind.int32,
+  [propertyToId.assignedClientIdentifier]: propertyKind.utf8string,
+  [propertyToId.serverKeepAlive]: propertyKind.int16,
+  [propertyToId.authenticationMethod]: propertyKind.utf8string,
+  [propertyToId.authenticationData]: propertyKind.byteArray,
+  [propertyToId.requestProblemInformation]: propertyKind.boolean,
+  [propertyToId.willDelayInterval]: propertyKind.int32,
+  [propertyToId.requestResponseInformation]: propertyKind.boolean,
+  [propertyToId.responseInformation]: propertyKind.utf8string,
+  [propertyToId.serverReference]: propertyKind.utf8string,
+  [propertyToId.reasonString]: propertyKind.utf8string,
+  [propertyToId.receiveMaximum]: propertyKind.int16,
+  [propertyToId.topicAliasMaximum]: propertyKind.int16,
+  [propertyToId.topicAlias]: propertyKind.int16,
+  [propertyToId.maximumQos]: propertyKind.byte,
+  [propertyToId.retainAvailable]: propertyKind.boolean,
+  [propertyToId.userProperty]: propertyKind.utf8StringPairs,
+  [propertyToId.maximumPacketSize]: propertyKind.int32,
+  [propertyToId.wildcardSubscriptionAvailable]: propertyKind.boolean,
+  [propertyToId.subscriptionIdentifierAvailable]: propertyKind.boolean,
+  [propertyToId.sharedSubscriptionAvailable]: propertyKind.boolean,
+} as const;
+
+export type UserPropertyType = Array<UTF8StringPair>;
+export type SubscriptionIdentifiersType = Array<number>;
+
+type PropertyKindMap = {
+  [propertyKind.boolean]: boolean;
+  [propertyKind.byte]: number;
+  [propertyKind.int16]: number;
+  [propertyKind.int32]: number;
+  [propertyKind.varInt]: number;
+  [propertyKind.byteArray]: Uint8Array;
+  [propertyKind.utf8string]: string;
+  [propertyKind.utf8StringPairs]: UserPropertyType;
+  [propertyKind.varIntArray]: SubscriptionIdentifiersType;
+};
+
+type Mqttv5PropertyType<K extends number> = K extends keyof PropertyKindMap
+  ? PropertyKindMap[K]
+  : never;
+
+export type Mqttv5PropertyTypes = PropertyKindMap[keyof PropertyKindMap];
+export type Mqttv5PropertyTypesNoUser = Exclude<
+  Mqttv5PropertyTypes,
+  UserPropertyType
+>;
+
+// First, create a type for all valid property numbers
+export type ValidPropertyNumber =
+  (typeof propertyToId)[keyof typeof propertyToId];
+// Then, create a mapped type that iterates over the property names
+// and uses propertyToKind to look up the correct TypeScript type.
+
+type AllMqttv5Properties = {
+  [K in PropertyNames]?: Mqttv5PropertyType<
+    typeof propertyToKind[typeof propertyToId[K]]
+  >;
+};
+
+type PropertyByNumberType = InvertRecord<typeof propertyToId>;
+
+export const propertyByNumber = Object.fromEntries(
+  Object.entries(propertyToId).map(
+    ([k, v]) => [v, k],
+  ),
+) as PropertyByNumberType;
+
+export const PropertyByPropertySetType = {
+  [PropertySetType.reserved]: [],
+  [PropertySetType.connect]: [
+    propertyToId.sessionExpiryInterval,
+    propertyToId.authenticationMethod,
+    propertyToId.authenticationData,
+    propertyToId.requestProblemInformation,
+    propertyToId.requestResponseInformation,
+    propertyToId.receiveMaximum,
+    propertyToId.topicAliasMaximum,
+    propertyToId.userProperty,
+    propertyToId.maximumPacketSize,
+  ],
+  [PropertySetType.connack]: [
+    propertyToId.sessionExpiryInterval,
+    propertyToId.assignedClientIdentifier,
+    propertyToId.serverKeepAlive,
+    propertyToId.authenticationMethod,
+    propertyToId.authenticationData,
+    propertyToId.responseInformation,
+    propertyToId.serverReference,
+    propertyToId.reasonString,
+    propertyToId.receiveMaximum,
+    propertyToId.topicAliasMaximum,
+    propertyToId.maximumQos,
+    propertyToId.retainAvailable,
+    propertyToId.userProperty,
+    propertyToId.maximumPacketSize,
+    propertyToId.wildcardSubscriptionAvailable,
+    propertyToId.subscriptionIdentifierAvailable,
+    propertyToId.sharedSubscriptionAvailable,
+  ],
+  [PropertySetType.publish]: [
+    propertyToId.payloadFormatIndicator,
+    propertyToId.messageExpiryInterval,
+    propertyToId.contentType,
+    propertyToId.responseTopic,
+    propertyToId.correlationData,
+    propertyToId.subscriptionIdentifiers,
+    propertyToId.topicAlias,
+    propertyToId.userProperty,
+  ],
+  [PropertySetType.subscribe]: [
+    propertyToId.subscriptionIdentifier,
+    propertyToId.userProperty,
+  ],
+  [PropertySetType.unsubscribe]: [
+    propertyToId.userProperty,
+  ],
+
+  [PropertySetType.disconnect]: [
+    propertyToId.sessionExpiryInterval,
+    propertyToId.serverReference,
+    propertyToId.reasonString,
+    propertyToId.userProperty,
+  ],
+  [PropertySetType.auth]: [
+    propertyToId.authenticationMethod,
+    propertyToId.authenticationData,
+    propertyToId.reasonString,
+    propertyToId.userProperty,
+  ],
+  [PropertySetType.puback]: [
+    propertyToId.reasonString,
+    propertyToId.userProperty,
+  ],
+  [PropertySetType.pubrec]: [
+    propertyToId.reasonString,
+    propertyToId.userProperty,
+  ],
+  [PropertySetType.pubrel]: [
+    propertyToId.reasonString,
+    propertyToId.userProperty,
+  ],
+  [PropertySetType.pubcomp]: [
+    propertyToId.reasonString,
+    propertyToId.userProperty,
+  ],
+  [PropertySetType.suback]: [
+    propertyToId.reasonString,
+    propertyToId.userProperty,
+  ],
+  [PropertySetType.unsuback]: [
+    propertyToId.reasonString,
+    propertyToId.userProperty,
+  ],
+  [PropertySetType.pingreq]: [],
+  [PropertySetType.pingres]: [],
+
+  [PropertySetType.will]: [
+    propertyToId.payloadFormatIndicator,
+    propertyToId.messageExpiryInterval,
+    propertyToId.contentType,
+    propertyToId.responseTopic,
+    propertyToId.correlationData,
+    propertyToId.willDelayInterval,
+    propertyToId.userProperty,
+  ],
+} as const;
+
+// helper types
+type PropertyIdsToKeys<T extends readonly ValidPropertyNumber[]> = {
+  [K in T[number]]: (typeof propertyByNumber)[K];
+}[T[number]];
+
+// from AllMqttv5Properties pick the ones returned by PropertyIdsToKeys for this type
+type GeneratePacketTypeProperties<T extends readonly ValidPropertyNumber[]> =
+  Pick<AllMqttv5Properties, PropertyIdsToKeys<T>>;
+
+export type PropsByPacketSetType = {
+  [K in TPropertySetType]: GeneratePacketTypeProperties<
+    typeof PropertyByPropertySetType[K]
+  >;
+};
+
+// props per PacketType
+export type ConnectProperties =
+  PropsByPacketSetType[typeof PropertySetType.connect];
+export type ConnackProperties =
+  PropsByPacketSetType[typeof PropertySetType.connack];
+export type PublishProperties =
+  PropsByPacketSetType[typeof PropertySetType.publish];
+export type PubackProperties =
+  PropsByPacketSetType[typeof PropertySetType.puback];
+export type PubrecProperties =
+  PropsByPacketSetType[typeof PropertySetType.pubrec];
+export type PubrelProperties =
+  PropsByPacketSetType[typeof PropertySetType.pubrel];
+export type PubcompProperties =
+  PropsByPacketSetType[typeof PropertySetType.pubcomp];
+export type SubscribeProperties =
+  PropsByPacketSetType[typeof PropertySetType.subscribe];
+export type SubackProperties =
+  PropsByPacketSetType[typeof PropertySetType.suback];
+export type UnsubscribeProperties =
+  PropsByPacketSetType[typeof PropertySetType.unsubscribe];
+export type UnsubackProperties =
+  PropsByPacketSetType[typeof PropertySetType.unsuback];
+export type DisconnectProperties =
+  PropsByPacketSetType[typeof PropertySetType.disconnect];
+export type AuthProperties = PropsByPacketSetType[typeof PropertySetType.auth];
+export type WillProperties = PropsByPacketSetType[typeof PropertySetType.will];

package/mqttPacket/ReasonCode.test.ts

@@ -0,0 +1,22 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { ReasonCode, reasonCodeToString } from "./ReasonCode.ts";
+import { PacketType } from "./mod.ts";
+
+test("lookup of reason codes works", () => {
+  assert.equal(
+    reasonCodeToString(PacketType.connect, ReasonCode.success),
+    "Success",
+    "Succes on Connect works",
+  );
+  assert.equal(
+    reasonCodeToString(PacketType.suback, ReasonCode.success),
+    "Granted QoS 0",
+    "Granted QoS 0 on Suback works",
+  );
+  assert.equal(
+    reasonCodeToString(PacketType.disconnect, ReasonCode.success),
+    "Normal disconnection",
+    "Normal disconnection on Disconnect works",
+  );
+});

package/mqttPacket/ReasonCode.ts

@@ -0,0 +1,256 @@
+/**
+ *  Possible MQTT V5 reason codes
+ */
+
+import { PacketType } from "./PacketType.ts";
+import type { InvertRecord } from "./types.ts";
+
+export const ReasonCode = {
+  success: 0x00,
+  normalDisconnection: 0x00,
+  grantedQos0: 0x00,
+  grantedQos1: 0x01,
+  grantedQos2: 0x02,
+  disconnectWithWillMessage: 0x04,
+  noMatchingSubscribers: 0x10,
+  noSubscriptionExisted: 0x11,
+  continueAuthentication: 0x18,
+  reAuthenticate: 0x19,
+  unspecifiedError: 0x80,
+  malformedPacket: 0x81,
+  protocolError: 0x82,
+  implementationSpecificError: 0x83,
+  unsupportedProtocolVersion: 0x84,
+  clientIdentifierNotValid: 0x85,
+  badUserNameOrPassword: 0x86,
+  notAuthorized: 0x87,
+  serverUnavailable: 0x88,
+  serverBusy: 0x89,
+  banned: 0x8a,
+  serverShuttingDown: 0x8b,
+  badAuthenticationMethod: 0x8c,
+  keepAliveTimeout: 0x8d,
+  sessionTakenOver: 0x8e,
+  topicFilterInvalid: 0x8f,
+  topicNameInvalid: 0x90,
+  packetIdentifierInUse: 0x91,
+  packetIdentifierNotFound: 0x92,
+  receiveMaximumExceeded: 0x93,
+  topicAliasInvalid: 0x94,
+  packetTooLarge: 0x95,
+  messageRateTooHigh: 0x96,
+  quotaExceeded: 0x97,
+  administrativeAction: 0x98,
+  payloadFormatInvalid: 0x99,
+  retainNotSupported: 0x9a,
+  qosNotSupported: 0x9b,
+  useAnotherServer: 0x9c,
+  serverMoved: 0x9d,
+  sharedSubscriptionsNotSupported: 0x9e,
+  connectionRateExceeded: 0x9f,
+  maximumConnectTime: 0xa0,
+  subscriptionIdentifiersNotSupported: 0xa1,
+  wildcardSubscriptionsNotSupported: 0xa2,
+} as const;
+
+/**
+ * Reverse lookup for ReasonCode
+ */
+
+export type ReasonCodeByNumberType = InvertRecord<typeof ReasonCode>;
+export const ReasonCodeByNumber = Object
+  .fromEntries(
+    Object.entries(ReasonCode).map(([k, v]) => [v, k]),
+  ) as ReasonCodeByNumberType;
+
+export const ReasonCodebyPacket = {
+  [PacketType.connack]: [
+    ReasonCode.success,
+    ReasonCode.unspecifiedError,
+    ReasonCode.malformedPacket,
+    ReasonCode.protocolError,
+    ReasonCode.implementationSpecificError,
+    ReasonCode.unsupportedProtocolVersion,
+    ReasonCode.clientIdentifierNotValid,
+    ReasonCode.badUserNameOrPassword,
+    ReasonCode.notAuthorized,
+    ReasonCode.serverUnavailable,
+    ReasonCode.serverBusy,
+    ReasonCode.banned,
+    ReasonCode.badAuthenticationMethod,
+    ReasonCode.topicNameInvalid,
+    ReasonCode.packetTooLarge,
+    ReasonCode.quotaExceeded,
+    ReasonCode.payloadFormatInvalid,
+    ReasonCode.retainNotSupported,
+    ReasonCode.qosNotSupported,
+    ReasonCode.useAnotherServer,
+    ReasonCode.serverMoved,
+    ReasonCode.connectionRateExceeded,
+  ],
+  [PacketType.puback]: [
+    ReasonCode.success,
+    ReasonCode.noMatchingSubscribers,
+    ReasonCode.unspecifiedError,
+    ReasonCode.implementationSpecificError,
+    ReasonCode.notAuthorized,
+    ReasonCode.topicNameInvalid,
+    ReasonCode.packetIdentifierInUse,
+    ReasonCode.quotaExceeded,
+    ReasonCode.payloadFormatInvalid,
+  ],
+  [PacketType.pubrec]: [
+    ReasonCode.success,
+    ReasonCode.noMatchingSubscribers,
+    ReasonCode.unspecifiedError,
+    ReasonCode.implementationSpecificError,
+    ReasonCode.notAuthorized,
+    ReasonCode.topicNameInvalid,
+    ReasonCode.packetIdentifierInUse,
+    ReasonCode.quotaExceeded,
+    ReasonCode.payloadFormatInvalid,
+  ],
+  [PacketType.pubrel]: [
+    ReasonCode.success,
+    ReasonCode.packetIdentifierNotFound,
+  ],
+  [PacketType.pubcomp]: [
+    ReasonCode.success,
+    ReasonCode.packetIdentifierNotFound,
+  ],
+  [PacketType.unsuback]: [
+    ReasonCode.success,
+    ReasonCode.noSubscriptionExisted,
+    ReasonCode.unspecifiedError,
+    ReasonCode.implementationSpecificError,
+    ReasonCode.notAuthorized,
+    ReasonCode.topicFilterInvalid,
+    ReasonCode.packetIdentifierInUse,
+  ],
+  [PacketType.auth]: [
+    ReasonCode.success,
+    ReasonCode.continueAuthentication,
+    ReasonCode.reAuthenticate,
+  ],
+  [PacketType.disconnect]: [
+    ReasonCode.normalDisconnection,
+    ReasonCode.disconnectWithWillMessage,
+    ReasonCode.unspecifiedError,
+    ReasonCode.malformedPacket,
+    ReasonCode.protocolError,
+    ReasonCode.implementationSpecificError,
+    ReasonCode.notAuthorized,
+    ReasonCode.serverBusy,
+    ReasonCode.serverShuttingDown,
+    ReasonCode.badAuthenticationMethod,
+    ReasonCode.keepAliveTimeout,
+    ReasonCode.sessionTakenOver,
+    ReasonCode.topicFilterInvalid,
+    ReasonCode.topicNameInvalid,
+    ReasonCode.receiveMaximumExceeded,
+    ReasonCode.topicAliasInvalid,
+    ReasonCode.packetTooLarge,
+    ReasonCode.messageRateTooHigh,
+    ReasonCode.quotaExceeded,
+    ReasonCode.administrativeAction,
+    ReasonCode.payloadFormatInvalid,
+    ReasonCode.retainNotSupported,
+    ReasonCode.qosNotSupported,
+    ReasonCode.useAnotherServer,
+    ReasonCode.serverMoved,
+    ReasonCode.sharedSubscriptionsNotSupported,
+    ReasonCode.connectionRateExceeded,
+    ReasonCode.maximumConnectTime,
+    ReasonCode.subscriptionIdentifiersNotSupported,
+    ReasonCode.wildcardSubscriptionsNotSupported,
+  ],
+  [PacketType.suback]: [
+    ReasonCode.grantedQos0,
+    ReasonCode.grantedQos1,
+    ReasonCode.grantedQos2,
+    ReasonCode.unspecifiedError,
+    ReasonCode.implementationSpecificError,
+    ReasonCode.notAuthorized,
+    ReasonCode.topicFilterInvalid,
+    ReasonCode.packetIdentifierInUse,
+    ReasonCode.quotaExceeded,
+    ReasonCode.sharedSubscriptionsNotSupported,
+    ReasonCode.subscriptionIdentifiersNotSupported,
+    ReasonCode.wildcardSubscriptionsNotSupported,
+  ],
+} as const;
+
+const reasonCodesToString = {
+  [0x00]: "Success",
+  [0x01]: "Granted QoS 1",
+  [0x02]: "Granted QoS 2",
+  [0x04]: "Disconnect with Will Message",
+  [0x10]: "No matching subscribers",
+  [0x11]: "No subscription existed",
+  [0x18]: "Continue authentication",
+  [0x19]: "Re-authenticate",
+  [0x80]: "Unspecified error",
+  [0x81]: "Malformed Packet",
+  [0x82]: "Protocol Error",
+  [0x83]: "Implementation specific error",
+  [0x84]: "Unsupported Protocol Version",
+  [0x85]: "Client Identifier not valid",
+  [0x86]: "Bad User Name or Password",
+  [0x87]: "Not authorized",
+  [0x88]: "Server unavailable",
+  [0x89]: "Server busy",
+  [0x8a]: "Banned",
+  [0x8b]: "Server shutting down",
+  [0x8c]: "Bad authentication method",
+  [0x8d]: "Keep Alive timeout",
+  [0x8e]: "Session taken over",
+  [0x8f]: "Topic Filter invalid",
+  [0x90]: "Topic Name invalid",
+  [0x91]: "Packet Identifier in use",
+  [0x92]: "Packet Identifier not found",
+  [0x93]: "Receive Maximum exceeded",
+  [0x94]: "Topic Alias invalid",
+  [0x95]: "Packet too large",
+  [0x96]: "Message rate too high",
+  [0x97]: "Quota exceeded",
+  [0x98]: "Administrative action",
+  [0x99]: "Payload format invalid",
+  [0x9a]: "Retain not supported",
+  [0x9b]: "QoS not supported",
+  [0x9c]: "Use another server",
+  [0x9d]: "Server moved",
+  [0x9e]: "Shared Subscriptions not supported",
+  [0x9f]: "Connection rate exceeded",
+  [0xa0]: "Maximum connect time",
+  [0xa1]: "Subscription Identifiers not supported",
+  [0xa2]: "Wildcard Subscriptions not supported",
+} as const;
+
+// Can't import this from types as this would create an import loop
+type TPacketType = typeof PacketType[keyof typeof PacketType];
+export type TReasonCode = typeof ReasonCode[keyof typeof ReasonCode];
+type TReasonCodeByPacket = keyof typeof ReasonCodebyPacket;
+
+export function reasonCodeToString(
+  packetType: TPacketType,
+  code: TReasonCode,
+): string {
+  if (code === 0) {
+    if (packetType === PacketType.disconnect) {
+      return "Normal disconnection";
+    }
+    if (packetType === PacketType.suback) {
+      return "Granted QoS 0";
+    }
+  }
+  return reasonCodesToString[code];
+}
+
+export function isValidReasonCode(
+  packetType: TPacketType,
+  code: number,
+): boolean {
+  const validReasonCodes =
+    ReasonCodebyPacket[packetType as TReasonCodeByPacket] as readonly number[];
+  return validReasonCodes.includes(code);
+}

package/mqttPacket/RetainHandling.ts

@@ -0,0 +1,11 @@
+/**
+ *RetainHandling
+ 0 = Send retained messages at the time of the subscribe
+ 1 = Send retained messages at subscribe only if the subscription does not currently exist
+ 2 = Do not send retained messages at the time of the subscribe
+ */
+export const RetainHandling = {
+  sendRetained: 0,
+  ifSubscriptionNotExists: 1,
+  noRetain: 2,
+} as const;

package/mqttPacket/auth.test.ts

@@ -0,0 +1,112 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { decode, encode, MQTTLevel, PacketType, ReasonCode } from "./mod.ts";
+import type { AuthPacket, CodecOpts } from "./mod.ts";
+
+const codecOptsV5: CodecOpts = {
+  protocolLevel: MQTTLevel.v5,
+  maxIncomingPacketSize: 0xffff,
+  maxOutgoingPacketSize: 0xffff,
+};
+
+const codecOptsV4: CodecOpts = {
+  protocolLevel: MQTTLevel.v4,
+  maxIncomingPacketSize: 0xffff,
+  maxOutgoingPacketSize: 0xffff,
+};
+
+test("decode Auth V5 with invalid reasonCode", () => {
+  assert.throws(
+    () =>
+      decode(
+        Uint8Array.from([
+          // fixedHeader
+          0x20, // packetType + flags
+          2, // remainingLength
+          // variableHeader
+          0, // reason code
+          64, // (reserved)
+        ]),
+        codecOptsV5,
+      ),
+    /Invalid reason code/,
+  );
+});
+
+test("decode Auth V5 as V4", () => {
+  assert.throws(
+    () =>
+      decode(
+        Uint8Array.from([
+          // fixedHeader
+          0xf0, // packetType + flags
+          2, // remainingLength
+          // variableHeader
+          0, // reason code
+          0, // properties length
+        ]),
+        codecOptsV4,
+      ),
+    /Invalid protocol level/,
+  );
+});
+
+test("encode/decode minimal auth V5", () => {
+  const packet = {
+    protocolLevel: MQTTLevel.v5,
+    type: PacketType.auth,
+    reasonCode: ReasonCode.success,
+  };
+  const encoded = encode(packet, codecOptsV5);
+  assert.deepStrictEqual(
+    encoded,
+    Uint8Array.from([
+      // fixedHeader
+
+      0xf0, // auth packet + flags
+      2, // remaining length
+      0, // reason code
+      0, // property length
+    ]),
+  );
+  const decoded = decode(encoded, codecOptsV5);
+  assert.deepStrictEqual(decoded, { ...packet, properties: {} });
+});
+
+test("encode/decode auth V5", () => {
+  const packet: AuthPacket = {
+    protocolLevel: 5,
+    type: PacketType.auth,
+    reasonCode: ReasonCode.continueAuthentication,
+    properties: {
+      userProperty: [["key", "value"]],
+    },
+  };
+  const encoded = encode(packet, codecOptsV5);
+  assert.deepStrictEqual(
+    encoded,
+    Uint8Array.from([
+      // fixedHeader
+
+      0xf0, // auth packet + flags
+      15, // remaining length
+      24, // reason code
+      13, // property length
+      38, // user property
+      0, // string MSB
+      3, // string LSB
+      107, // k
+      101, // e
+      121, // y
+      0, // string MSB
+      5, // string LSB
+      118, // v
+      97, // a
+      108, // l
+      117, // u
+      101, // e
+    ]),
+  );
+  const decoded = decode(encoded, codecOptsV5);
+  assert.deepStrictEqual(decoded, packet);
+});