react-native-ble-mesh 1.0.1

package/src/constants/errors.js

@@ -0,0 +1,202 @@
+/**
+ * @fileoverview Error code definitions
+ * @module constants/errors
+ */
+
+'use strict';
+
+/**
+ * Error codes organized by category
+ * @constant {Object.<string, string>}
+ */
+const ERROR_CODE = Object.freeze({
+  // Initialization errors (E0xx)
+  E001: 'INIT_FAILED',
+  E002: 'ALREADY_INITIALIZED',
+  E003: 'NOT_INITIALIZED',
+  E004: 'INVALID_CONFIG',
+  E005: 'STORAGE_INIT_FAILED',
+
+  // Bluetooth errors (E1xx)
+  E100: 'BLUETOOTH_UNAVAILABLE',
+  E101: 'BLUETOOTH_UNAUTHORIZED',
+  E102: 'BLUETOOTH_POWERED_OFF',
+  E103: 'SCAN_FAILED',
+  E104: 'ADVERTISE_FAILED',
+  E105: 'MTU_NEGOTIATION_FAILED',
+
+  // Connection errors (E2xx)
+  E200: 'CONNECTION_FAILED',
+  E201: 'CONNECTION_TIMEOUT',
+  E202: 'CONNECTION_LOST',
+  E203: 'MAX_CONNECTIONS_REACHED',
+  E204: 'PEER_NOT_FOUND',
+  E205: 'PEER_BLOCKED',
+  E206: 'ALREADY_CONNECTED',
+  E207: 'NOT_CONNECTED',
+
+  // Handshake errors (E3xx)
+  E300: 'HANDSHAKE_FAILED',
+  E301: 'HANDSHAKE_TIMEOUT',
+  E302: 'HANDSHAKE_INVALID_STATE',
+  E303: 'HANDSHAKE_DECRYPTION_FAILED',
+  E304: 'HANDSHAKE_ALREADY_IN_PROGRESS',
+  E305: 'HANDSHAKE_INVALID_MESSAGE',
+
+  // Crypto errors (E4xx)
+  E400: 'KEY_GENERATION_FAILED',
+  E401: 'ENCRYPTION_FAILED',
+  E402: 'DECRYPTION_FAILED',
+  E403: 'INVALID_KEY',
+  E404: 'INVALID_NONCE',
+  E405: 'AUTH_TAG_MISMATCH',
+  E406: 'NONCE_EXHAUSTED',
+  E407: 'INVALID_SIGNATURE',
+
+  // Message errors (E5xx)
+  E500: 'MESSAGE_TOO_LARGE',
+  E501: 'MESSAGE_EXPIRED',
+  E502: 'MESSAGE_INVALID_FORMAT',
+  E503: 'MESSAGE_INVALID_CHECKSUM',
+  E504: 'MESSAGE_DUPLICATE',
+  E505: 'MESSAGE_MAX_HOPS_EXCEEDED',
+  E506: 'MESSAGE_SEND_FAILED',
+  E507: 'MESSAGE_INVALID_TYPE',
+  E508: 'FRAGMENT_ASSEMBLY_FAILED',
+  E509: 'FRAGMENT_TIMEOUT',
+
+  // Channel errors (E6xx)
+  E600: 'CHANNEL_NOT_FOUND',
+  E601: 'CHANNEL_ALREADY_JOINED',
+  E602: 'CHANNEL_NOT_JOINED',
+  E603: 'CHANNEL_INVALID_PASSWORD',
+  E604: 'CHANNEL_FULL',
+
+  // Session errors (E7xx)
+  E700: 'SESSION_NOT_FOUND',
+  E701: 'SESSION_EXPIRED',
+  E702: 'SESSION_INVALID',
+
+  // Validation errors (E8xx)
+  E800: 'VALIDATION_FAILED',
+  E801: 'INVALID_ARGUMENT',
+  E802: 'MISSING_ARGUMENT',
+  E803: 'INVALID_TYPE',
+  E804: 'OUT_OF_RANGE',
+
+  // General errors (E9xx)
+  E900: 'UNKNOWN_ERROR',
+  E901: 'OPERATION_CANCELLED',
+  E902: 'TIMEOUT',
+  E903: 'NOT_SUPPORTED',
+  E904: 'INTERNAL_ERROR',
+
+  // Audio errors (EAxx)
+  EA00: 'AUDIO_ERROR',
+  EA01: 'CODEC_INIT_FAILED',
+  EA02: 'ENCODING_FAILED',
+  EA03: 'DECODING_FAILED',
+  EA04: 'AUDIO_SESSION_FAILED',
+  EA05: 'AUDIO_BUFFER_OVERFLOW',
+  EA06: 'AUDIO_BUFFER_UNDERRUN',
+  EA07: 'VOICE_MESSAGE_TOO_LARGE',
+  EA08: 'AUDIO_STREAM_REJECTED',
+  EA09: 'CODEC_NOT_AVAILABLE',
+  EA10: 'AUDIO_INVALID_CONFIG',
+  EA11: 'VOICE_MESSAGE_TIMEOUT'
+});
+
+/**
+ * Error messages for each error code
+ * @constant {Object.<string, string>}
+ */
+const ERROR_MESSAGES = Object.freeze({
+  E001: 'Initialization failed',
+  E002: 'Service is already initialized',
+  E003: 'Service is not initialized',
+  E004: 'Invalid configuration provided',
+  E005: 'Storage initialization failed',
+
+  E100: 'Bluetooth is not available on this device',
+  E101: 'Bluetooth permission not granted',
+  E102: 'Bluetooth is powered off',
+  E103: 'Failed to start BLE scan',
+  E104: 'Failed to start BLE advertising',
+  E105: 'MTU negotiation failed',
+
+  E200: 'Failed to establish connection',
+  E201: 'Connection timed out',
+  E202: 'Connection was lost',
+  E203: 'Maximum number of connections reached',
+  E204: 'Peer not found',
+  E205: 'Peer is blocked',
+  E206: 'Already connected to this peer',
+  E207: 'Not connected to this peer',
+
+  E300: 'Handshake failed',
+  E301: 'Handshake timed out',
+  E302: 'Invalid handshake state',
+  E303: 'Failed to decrypt handshake message',
+  E304: 'Handshake already in progress with this peer',
+  E305: 'Invalid handshake message received',
+
+  E400: 'Failed to generate cryptographic key',
+  E401: 'Encryption failed',
+  E402: 'Decryption failed',
+  E403: 'Invalid key provided',
+  E404: 'Invalid nonce provided',
+  E405: 'Authentication tag mismatch',
+  E406: 'Nonce counter exhausted, rekey required',
+  E407: 'Invalid signature',
+
+  E500: 'Message exceeds maximum size',
+  E501: 'Message has expired',
+  E502: 'Invalid message format',
+  E503: 'Message checksum validation failed',
+  E504: 'Duplicate message detected',
+  E505: 'Message exceeded maximum hop count',
+  E506: 'Failed to send message',
+  E507: 'Invalid message type',
+  E508: 'Failed to assemble message fragments',
+  E509: 'Fragment assembly timed out',
+
+  E600: 'Channel not found',
+  E601: 'Already joined this channel',
+  E602: 'Not a member of this channel',
+  E603: 'Invalid channel password',
+  E604: 'Channel is full',
+
+  E700: 'Session not found',
+  E701: 'Session has expired',
+  E702: 'Invalid session',
+
+  E800: 'Validation failed',
+  E801: 'Invalid argument provided',
+  E802: 'Required argument is missing',
+  E803: 'Invalid type',
+  E804: 'Value is out of valid range',
+
+  E900: 'An unknown error occurred',
+  E901: 'Operation was cancelled',
+  E902: 'Operation timed out',
+  E903: 'Operation not supported',
+  E904: 'Internal error',
+
+  EA00: 'Audio operation failed',
+  EA01: 'LC3 codec initialization failed',
+  EA02: 'Audio encoding failed',
+  EA03: 'Audio decoding failed',
+  EA04: 'Audio session failed',
+  EA05: 'Audio buffer overflow',
+  EA06: 'Audio buffer underrun',
+  EA07: 'Voice message exceeds maximum size',
+  EA08: 'Audio stream was rejected',
+  EA09: 'LC3 codec not available - native module not installed',
+  EA10: 'Invalid audio configuration',
+  EA11: 'Voice message assembly timed out'
+});
+
+module.exports = {
+  ERROR_CODE,
+  ERROR_MESSAGES
+};

package/src/constants/events.js

@@ -0,0 +1,94 @@
+/**
+ * @fileoverview Event name constants
+ * @module constants/events
+ */
+
+'use strict';
+
+/**
+ * Event names for the mesh network
+ * @constant {Object.<string, string>}
+ */
+const EVENTS = Object.freeze({
+  // Lifecycle events
+  INITIALIZED: 'initialized',
+  DESTROYED: 'destroyed',
+  STATE_CHANGED: 'state:changed',
+  ERROR: 'error',
+
+  // Bluetooth events
+  BLUETOOTH_STATE: 'bluetooth:state',
+  SCAN_STARTED: 'scan:started',
+  SCAN_STOPPED: 'scan:stopped',
+
+  // Peer events
+  PEER_DISCOVERED: 'peer:discovered',
+  PEER_CONNECTED: 'peer:connected',
+  PEER_DISCONNECTED: 'peer:disconnected',
+  PEER_SECURED: 'peer:secured',
+  PEER_UPDATED: 'peer:updated',
+  PEER_LOST: 'peer:lost',
+  PEER_BLOCKED: 'peer:blocked',
+  PEER_UNBLOCKED: 'peer:unblocked',
+
+  // Handshake events
+  HANDSHAKE_STARTED: 'handshake:started',
+  HANDSHAKE_PROGRESS: 'handshake:progress',
+  HANDSHAKE_COMPLETE: 'handshake:complete',
+  HANDSHAKE_FAILED: 'handshake:failed',
+
+  // Message events
+  MESSAGE_RECEIVED: 'message:received',
+  MESSAGE_SENT: 'message:sent',
+  MESSAGE_FAILED: 'message:failed',
+  MESSAGE_RELAYED: 'message:relayed',
+  MESSAGE_DROPPED: 'message:dropped',
+  MESSAGE_ACK: 'message:ack',
+
+  // Private message events
+  PRIVATE_MESSAGE_RECEIVED: 'private:received',
+  PRIVATE_MESSAGE_SENT: 'private:sent',
+
+  // Broadcast events
+  BROADCAST_RECEIVED: 'broadcast:received',
+  BROADCAST_SENT: 'broadcast:sent',
+
+  // Channel events
+  CHANNEL_JOINED: 'channel:joined',
+  CHANNEL_LEFT: 'channel:left',
+  CHANNEL_MESSAGE: 'channel:message',
+  CHANNEL_MEMBER_JOINED: 'channel:memberJoined',
+  CHANNEL_MEMBER_LEFT: 'channel:memberLeft',
+
+  // Route events
+  ROUTE_ADDED: 'route:added',
+  ROUTE_UPDATED: 'route:updated',
+  ROUTE_REMOVED: 'route:removed',
+
+  // Session events
+  SESSION_CREATED: 'session:created',
+  SESSION_DESTROYED: 'session:destroyed',
+  SESSION_EXPIRED: 'session:expired',
+
+  // Audio streaming events
+  AUDIO_STREAM_REQUEST: 'audio:stream-request',
+  AUDIO_STREAM_STARTED: 'audio:stream-started',
+  AUDIO_STREAM_ENDED: 'audio:stream-ended',
+  AUDIO_STREAM_PAUSED: 'audio:stream-paused',
+  AUDIO_STREAM_RESUMED: 'audio:stream-resumed',
+
+  // Voice message events
+  VOICE_MESSAGE_RECEIVED: 'audio:voice-message-received',
+  VOICE_MESSAGE_SENT: 'audio:voice-message-sent',
+  VOICE_MESSAGE_PROGRESS: 'audio:voice-message-progress',
+  VOICE_MESSAGE_FAILED: 'audio:voice-message-failed',
+
+  // Audio quality events
+  AUDIO_BUFFER_UNDERRUN: 'audio:buffer-underrun',
+  AUDIO_BUFFER_OVERFLOW: 'audio:buffer-overflow',
+  AUDIO_QUALITY_CHANGE: 'audio:quality-change'
+});
+
+module.exports = {
+  EVENTS
+};

package/src/constants/index.js

@@ -0,0 +1,22 @@
+/**
+ * @fileoverview Constants module exports
+ * @module constants
+ */
+
+'use strict';
+
+const protocol = require('./protocol');
+const ble = require('./ble');
+const crypto = require('./crypto');
+const errors = require('./errors');
+const events = require('./events');
+const audio = require('./audio');
+
+module.exports = {
+  ...protocol,
+  ...ble,
+  ...crypto,
+  ...errors,
+  ...events,
+  ...audio
+};

package/src/constants/protocol.js

@@ -0,0 +1,151 @@
+/**
+ * @fileoverview Protocol constants for the BLE Mesh Network
+ * @module constants/protocol
+ */
+
+'use strict';
+
+/**
+ * Protocol version for compatibility checking
+ * @constant {number}
+ */
+const PROTOCOL_VERSION = 1;
+
+/**
+ * Message type identifiers
+ * @constant {Object.<string, number>}
+ */
+const MESSAGE_TYPE = Object.freeze({
+  // Data messages (0x01-0x0F)
+  TEXT: 0x01,
+  TEXT_ACK: 0x02,
+
+  // Handshake (0x10-0x1F)
+  HANDSHAKE_INIT: 0x10,
+  HANDSHAKE_RESPONSE: 0x11,
+  HANDSHAKE_FINAL: 0x12,
+
+  // Discovery (0x20-0x2F)
+  PEER_ANNOUNCE: 0x20,
+  PEER_REQUEST: 0x21,
+  PEER_RESPONSE: 0x22,
+
+  // Channels (0x30-0x3F)
+  CHANNEL_JOIN: 0x30,
+  CHANNEL_LEAVE: 0x31,
+  CHANNEL_MESSAGE: 0x32,
+
+  // Private (0x40-0x4F)
+  PRIVATE_MESSAGE: 0x40,
+  PRIVATE_ACK: 0x41,
+
+  // Control (0x60-0x6F)
+  HEARTBEAT: 0x60,
+  PING: 0x61,
+  PONG: 0x62,
+
+  // Fragments (0x70-0x7F)
+  FRAGMENT: 0x70,
+
+  // Audio messages (0x80-0x8F)
+  VOICE_MESSAGE_START: 0x80,
+  VOICE_MESSAGE_DATA: 0x81,
+  VOICE_MESSAGE_END: 0x82,
+  VOICE_MESSAGE_ACK: 0x83,
+  AUDIO_STREAM_REQUEST: 0x84,
+  AUDIO_STREAM_ACCEPT: 0x85,
+  AUDIO_STREAM_REJECT: 0x86,
+  AUDIO_STREAM_DATA: 0x87,
+  AUDIO_STREAM_END: 0x88,
+
+  // Error (0xFF)
+  ERROR: 0xFF
+});
+
+/**
+ * Message flags
+ * @constant {Object.<string, number>}
+ */
+const MESSAGE_FLAGS = Object.freeze({
+  NONE: 0x00,
+  ENCRYPTED: 0x01,
+  COMPRESSED: 0x02,
+  REQUIRES_ACK: 0x04,
+  IS_FRAGMENT: 0x08,
+  IS_BROADCAST: 0x10,
+  HIGH_PRIORITY: 0x20
+});
+
+/**
+ * Mesh network configuration
+ * @constant {Object.<string, number>}
+ */
+const MESH_CONFIG = Object.freeze({
+  /** Maximum number of hops a message can travel */
+  MAX_HOPS: 7,
+  /** Maximum message payload size in bytes */
+  MAX_MESSAGE_SIZE: 500,
+  /** Fragment payload size in bytes */
+  FRAGMENT_SIZE: 180,
+  /** Message header size in bytes */
+  HEADER_SIZE: 48,
+  /** Message time-to-live in milliseconds (30 minutes) */
+  MESSAGE_TTL_MS: 30 * 60 * 1000,
+  /** Peer timeout in milliseconds (5 minutes) */
+  PEER_TIMEOUT_MS: 5 * 60 * 1000,
+  /** Heartbeat interval in milliseconds (30 seconds) */
+  HEARTBEAT_INTERVAL_MS: 30 * 1000,
+  /** Handshake timeout in milliseconds (30 seconds) */
+  HANDSHAKE_TIMEOUT_MS: 30 * 1000,
+  /** Maximum retry attempts */
+  MAX_RETRIES: 3,
+  /** Bloom filter size in bits */
+  BLOOM_FILTER_SIZE: 2048,
+  /** Number of hash functions for bloom filter */
+  BLOOM_HASH_COUNT: 7,
+  /** Maximum pending fragments per message */
+  MAX_PENDING_FRAGMENTS: 256,
+  /** Fragment assembly timeout in milliseconds (60 seconds) */
+  FRAGMENT_TIMEOUT_MS: 60 * 1000,
+  /** Maximum connected peers */
+  MAX_PEERS: 8,
+  /** Route entry timeout in milliseconds (10 minutes) */
+  ROUTE_TIMEOUT_MS: 10 * 60 * 1000
+});
+
+/**
+ * Connection states
+ * @constant {Object.<string, string>}
+ */
+const CONNECTION_STATE = Object.freeze({
+  DISCONNECTED: 'disconnected',
+  CONNECTING: 'connecting',
+  CONNECTED: 'connected',
+  SECURING: 'securing',
+  SECURED: 'secured',
+  DISCONNECTING: 'disconnecting',
+  FAILED: 'failed'
+});
+
+/**
+ * Service states
+ * @constant {Object.<string, string>}
+ */
+const SERVICE_STATE = Object.freeze({
+  UNINITIALIZED: 'uninitialized',
+  INITIALIZING: 'initializing',
+  READY: 'ready',
+  ACTIVE: 'active',
+  SUSPENDED: 'suspended',
+  DESTROYED: 'destroyed',
+  ERROR: 'error'
+});
+
+module.exports = {
+  PROTOCOL_VERSION,
+  MESSAGE_TYPE,
+  MESSAGE_FLAGS,
+  MESH_CONFIG,
+  CONNECTION_STATE,
+  SERVICE_STATE
+};

package/src/crypto/aead.js

@@ -0,0 +1,189 @@
+/**
+ * @fileoverview ChaCha20-Poly1305 AEAD implementation (RFC 8439)
+ * @module crypto/aead
+ */
+
+'use strict';
+
+const { chacha20 } = require('./chacha20');
+const { poly1305 } = require('./poly1305');
+
+/**
+ * Generates Poly1305 key using ChaCha20 with counter=0
+ * @param {Uint8Array} key - 32-byte encryption key
+ * @param {Uint8Array} nonce - 12-byte nonce
+ * @returns {Uint8Array} 32-byte Poly1305 key
+ */
+function generatePolyKey(key, nonce) {
+  const zeros = new Uint8Array(64);
+  const block = chacha20(key, nonce, 0, zeros);
+  return block.subarray(0, 32);
+}
+
+/**
+ * Pads data to 16-byte boundary with zeros
+ * @param {number} length - Current data length
+ * @returns {Uint8Array} Padding bytes (0-15 bytes)
+ */
+function pad16(length) {
+  const remainder = length % 16;
+  if (remainder === 0) {
+    return new Uint8Array(0);
+  }
+  return new Uint8Array(16 - remainder);
+}
+
+/**
+ * Encodes a 64-bit little-endian integer
+ * @param {number} value - Value to encode
+ * @returns {Uint8Array} 8-byte little-endian representation
+ */
+function encode64LE(value) {
+  const bytes = new Uint8Array(8);
+  const view = new DataView(bytes.buffer);
+  // JavaScript numbers are 64-bit floats, safe for values up to 2^53-1
+  view.setUint32(0, value >>> 0, true);
+  view.setUint32(4, Math.floor(value / 0x100000000) >>> 0, true);
+  return bytes;
+}
+
+/**
+ * Constructs Poly1305 MAC input per RFC 8439
+ * @param {Uint8Array} aad - Additional authenticated data
+ * @param {Uint8Array} ciphertext - Ciphertext
+ * @returns {Uint8Array} MAC input
+ */
+function constructMacData(aad, ciphertext) {
+  const aadPad = pad16(aad.length);
+  const ctPad = pad16(ciphertext.length);
+  const aadLen = encode64LE(aad.length);
+  const ctLen = encode64LE(ciphertext.length);
+
+  const totalLen = aad.length + aadPad.length + ciphertext.length +
+                   ctPad.length + 8 + 8;
+  const data = new Uint8Array(totalLen);
+
+  let offset = 0;
+  data.set(aad, offset);
+  offset += aad.length;
+  data.set(aadPad, offset);
+  offset += aadPad.length;
+  data.set(ciphertext, offset);
+  offset += ciphertext.length;
+  data.set(ctPad, offset);
+  offset += ctPad.length;
+  data.set(aadLen, offset);
+  offset += 8;
+  data.set(ctLen, offset);
+
+  return data;
+}
+
+/**
+ * Constant-time comparison of two byte arrays
+ * @param {Uint8Array} a - First array
+ * @param {Uint8Array} b - Second array
+ * @returns {boolean} True if arrays are equal
+ */
+function constantTimeEqual(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) {
+    diff |= a[i] ^ b[i];
+  }
+  return diff === 0;
+}
+
+/**
+ * Encrypts and authenticates data using ChaCha20-Poly1305 AEAD
+ * @param {Uint8Array} key - 32-byte encryption key
+ * @param {Uint8Array} nonce - 12-byte nonce (must be unique per key)
+ * @param {Uint8Array} plaintext - Data to encrypt
+ * @param {Uint8Array} [aad] - Additional authenticated data (optional)
+ * @returns {Uint8Array} Ciphertext with appended 16-byte authentication tag
+ * @throws {Error} If key is not 32 bytes or nonce is not 12 bytes
+ */
+function encrypt(key, nonce, plaintext, aad = new Uint8Array(0)) {
+  if (!(key instanceof Uint8Array) || key.length !== 32) {
+    throw new Error('Key must be 32 bytes');
+  }
+  if (!(nonce instanceof Uint8Array) || nonce.length !== 12) {
+    throw new Error('Nonce must be 12 bytes');
+  }
+  if (!(plaintext instanceof Uint8Array)) {
+    throw new Error('Plaintext must be a Uint8Array');
+  }
+  if (!(aad instanceof Uint8Array)) {
+    throw new Error('AAD must be a Uint8Array');
+  }
+
+  // Generate Poly1305 key
+  const polyKey = generatePolyKey(key, nonce);
+
+  // Encrypt plaintext with counter starting at 1
+  const ciphertext = chacha20(key, nonce, 1, plaintext);
+
+  // Compute MAC
+  const macData = constructMacData(aad, ciphertext);
+  const tag = poly1305(polyKey, macData);
+
+  // Concatenate ciphertext and tag
+  const result = new Uint8Array(ciphertext.length + 16);
+  result.set(ciphertext);
+  result.set(tag, ciphertext.length);
+
+  return result;
+}
+
+/**
+ * Decrypts and verifies data using ChaCha20-Poly1305 AEAD
+ * @param {Uint8Array} key - 32-byte encryption key
+ * @param {Uint8Array} nonce - 12-byte nonce
+ * @param {Uint8Array} ciphertext - Ciphertext with 16-byte authentication tag
+ * @param {Uint8Array} [aad] - Additional authenticated data (optional)
+ * @returns {Uint8Array|null} Decrypted plaintext, or null if authentication fails
+ * @throws {Error} If key is not 32 bytes, nonce is not 12 bytes, or ciphertext too short
+ */
+function decrypt(key, nonce, ciphertext, aad = new Uint8Array(0)) {
+  if (!(key instanceof Uint8Array) || key.length !== 32) {
+    throw new Error('Key must be 32 bytes');
+  }
+  if (!(nonce instanceof Uint8Array) || nonce.length !== 12) {
+    throw new Error('Nonce must be 12 bytes');
+  }
+  if (!(ciphertext instanceof Uint8Array)) {
+    throw new Error('Ciphertext must be a Uint8Array');
+  }
+  if (ciphertext.length < 16) {
+    throw new Error('Ciphertext must be at least 16 bytes (tag size)');
+  }
+  if (!(aad instanceof Uint8Array)) {
+    throw new Error('AAD must be a Uint8Array');
+  }
+
+  // Split ciphertext and tag
+  const ct = ciphertext.subarray(0, ciphertext.length - 16);
+  const receivedTag = ciphertext.subarray(ciphertext.length - 16);
+
+  // Generate Poly1305 key
+  const polyKey = generatePolyKey(key, nonce);
+
+  // Compute expected MAC
+  const macData = constructMacData(aad, ct);
+  const expectedTag = poly1305(polyKey, macData);
+
+  // Verify tag using constant-time comparison
+  if (!constantTimeEqual(receivedTag, expectedTag)) {
+    return null;
+  }
+
+  // Decrypt ciphertext with counter starting at 1
+  return chacha20(key, nonce, 1, ct);
+}
+
+module.exports = {
+  encrypt,
+  decrypt
+};