@waku/sds 0.0.4-f911bf8.0 → 0.0.4

package/src/message_channel/command_queue.ts

@@ -0,0 +1,33 @@
+import type { Message } from "./events.js";
+
+export enum Command {
+  Send = "send",
+  Receive = "receive",
+  SendEphemeral = "sendEphemeral"
+}
+
+export interface ParamsByAction {
+  [Command.Send]: {
+    payload: Uint8Array;
+    callback?: (message: Message) => Promise<{
+      success: boolean;
+      retrievalHint?: Uint8Array;
+    }>;
+  };
+  [Command.Receive]: {
+    message: Message;
+  };
+  [Command.SendEphemeral]: {
+    payload: Uint8Array;
+    callback?: (message: Message) => Promise<boolean>;
+  };
+}
+
+export type Task<A extends Command = Command> = {
+  command: A;
+  params: ParamsByAction[A];
+};
+
+export type Handlers = {
+  [A in Command]: (params: ParamsByAction[A]) => Promise<void>;
+};

package/src/message_channel/events.ts

@@ -0,0 +1,41 @@
+import { proto_sds_message } from "@waku/proto";
+
+export enum MessageChannelEvent {
+  MessageSent = "messageSent",
+  MessageDelivered = "messageDelivered",
+  MessageReceived = "messageReceived",
+  MessageAcknowledged = "messageAcknowledged",
+  PartialAcknowledgement = "partialAcknowledgement",
+  MissedMessages = "missedMessages",
+  SyncSent = "syncSent",
+  SyncReceived = "syncReceived"
+}
+
+export type Message = proto_sds_message.SdsMessage;
+export type HistoryEntry = proto_sds_message.HistoryEntry;
+export type ChannelId = string;
+
+export function encodeMessage(message: Message): Uint8Array {
+  return proto_sds_message.SdsMessage.encode(message);
+}
+
+export function decodeMessage(data: Uint8Array): Message {
+  return proto_sds_message.SdsMessage.decode(data);
+}
+
+export type MessageChannelEvents = {
+  [MessageChannelEvent.MessageSent]: CustomEvent<Message>;
+  [MessageChannelEvent.MessageDelivered]: CustomEvent<{
+    messageId: string;
+    sentOrReceived: "sent" | "received";
+  }>;
+  [MessageChannelEvent.MessageReceived]: CustomEvent<Message>;
+  [MessageChannelEvent.MessageAcknowledged]: CustomEvent<string>;
+  [MessageChannelEvent.PartialAcknowledgement]: CustomEvent<{
+    messageId: string;
+    count: number;
+  }>;
+  [MessageChannelEvent.MissedMessages]: CustomEvent<HistoryEntry[]>;
+  [MessageChannelEvent.SyncSent]: CustomEvent<Message>;
+  [MessageChannelEvent.SyncReceived]: CustomEvent<Message>;
+};

package/src/message_channel/index.ts

@@ -0,0 +1,3 @@
+export * from "./command_queue.js";
+export * from "./events.js";
+export * from "./message_channel.js";

package/src/{sds.ts → message_channel/message_channel.ts}

@@ -1,20 +1,18 @@
 import { TypedEventEmitter } from "@libp2p/interface";
 import { sha256 } from "@noble/hashes/sha256";
 import { bytesToHex } from "@noble/hashes/utils";
-import { proto_sds_message } from "@waku/proto";
+import { Logger } from "@waku/utils";
 
-import { DefaultBloomFilter } from "./bloom.js";
+import { DefaultBloomFilter } from "../bloom_filter/bloom.js";
 
-export enum MessageChannelEvent {
-  MessageDelivered = "messageDelivered"
-}
-type MessageChannelEvents = {
-  [MessageChannelEvent.MessageDelivered]: CustomEvent<string>;
-};
-
-export type Message = proto_sds_message.SdsMessage;
-export type HistoryEntry = proto_sds_message.HistoryEntry;
-export type ChannelId = string;
+import { Command, Handlers, ParamsByAction, Task } from "./command_queue.js";
+import {
+  ChannelId,
+  HistoryEntry,
+  Message,
+  MessageChannelEvent,
+  MessageChannelEvents
+} from "./events.js";
 
 export const DEFAULT_BLOOM_FILTER_OPTIONS = {
   capacity: 10000,
@@ -24,27 +22,46 @@ export const DEFAULT_BLOOM_FILTER_OPTIONS = {
 const DEFAULT_CAUSAL_HISTORY_SIZE = 2;
 const DEFAULT_RECEIVED_MESSAGE_TIMEOUT = 1000 * 60 * 5; // 5 minutes
 
+const log = new Logger("sds:message-channel");
+
 interface MessageChannelOptions {
   causalHistorySize?: number;
   receivedMessageTimeoutEnabled?: boolean;
   receivedMessageTimeout?: number;
-  deliveredMessageCallback?: (messageId: string) => void;
 }
 
 export class MessageChannel extends TypedEventEmitter<MessageChannelEvents> {
+  public readonly channelId: ChannelId;
   private lamportTimestamp: number;
   private filter: DefaultBloomFilter;
   private outgoingBuffer: Message[];
   private acknowledgements: Map<string, number>;
   private incomingBuffer: Message[];
   private localHistory: { timestamp: number; historyEntry: HistoryEntry }[];
-  private channelId: ChannelId;
   private causalHistorySize: number;
   private acknowledgementCount: number;
   private timeReceived: Map<string, number>;
   private receivedMessageTimeoutEnabled: boolean;
   private receivedMessageTimeout: number;
-  private deliveredMessageCallback?: (messageId: string) => void;
+
+  private tasks: Task[] = [];
+  private handlers: Handlers = {
+    [Command.Send]: async (
+      params: ParamsByAction[Command.Send]
+    ): Promise<void> => {
+      await this._sendMessage(params.payload, params.callback);
+    },
+    [Command.Receive]: async (
+      params: ParamsByAction[Command.Receive]
+    ): Promise<void> => {
+      this._receiveMessage(params.message);
+    },
+    [Command.SendEphemeral]: async (
+      params: ParamsByAction[Command.SendEphemeral]
+    ): Promise<void> => {
+      await this._sendEphemeralMessage(params.payload, params.callback);
+    }
+  };
 
   public constructor(
     channelId: ChannelId,
@@ -66,7 +83,6 @@ export class MessageChannel extends TypedEventEmitter<MessageChannelEvents> {
       options.receivedMessageTimeoutEnabled ?? false;
     this.receivedMessageTimeout =
       options.receivedMessageTimeout ?? DEFAULT_RECEIVED_MESSAGE_TIMEOUT;
-    this.deliveredMessageCallback = options.deliveredMessageCallback;
   }
 
   public static getMessageId(payload: Uint8Array): string {
@@ -74,20 +90,59 @@ export class MessageChannel extends TypedEventEmitter<MessageChannelEvents> {
   }
 
   /**
-   * Send a message to the SDS channel.
+   * Processes all queued tasks sequentially to ensure proper message ordering.
    *
-   * Increments the lamport timestamp, constructs a `Message` object
-   * with the given payload, and adds it to the outgoing buffer.
+   * This method should be called periodically by the library consumer to execute
+   * queued send/receive operations in the correct sequence.
    *
-   * If the callback is successful, the message is also added to
-   * the bloom filter and message history. In the context of
-   * Waku, this likely means the message was published via
-   * light push or relay.
+   * @example
+   * ```typescript
+   * const channel = new MessageChannel("my-channel");
    *
-   * See https://rfc.vac.dev/vac/raw/sds/#send-message
+   * // Queue some operations
+   * await channel.sendMessage(payload, callback);
+   * channel.receiveMessage(incomingMessage);
    *
-   * @param payload - The payload to send.
-   * @param callback - A callback function that returns a boolean indicating whether the message was sent successfully.
+   * // Process all queued operations
+   * await channel.processTasks();
+   * ```
+   *
+   * @throws Will emit a 'taskError' event if any task fails, but continues processing remaining tasks
+   */
+  public async processTasks(): Promise<void> {
+    while (this.tasks.length > 0) {
+      const item = this.tasks.shift();
+      if (!item) {
+        continue;
+      }
+
+      await this.executeTask(item);
+    }
+  }
+
+  /**
+   * Queues a message to be sent on this channel.
+   *
+   * The message will be processed sequentially when processTasks() is called.
+   * This ensures proper lamport timestamp ordering and causal history tracking.
+   *
+   * @param payload - The message content as a byte array
+   * @param callback - Optional callback function called after the message is processed
+   * @returns Promise that resolves when the message is queued (not sent)
+   *
+   * @example
+   * ```typescript
+   * const channel = new MessageChannel("chat-room");
+   * const message = new TextEncoder().encode("Hello, world!");
+   *
+   * await channel.sendMessage(message, async (processedMessage) => {
+   *   console.log("Message processed:", processedMessage.messageId);
+   *   return { success: true };
+   * });
+   *
+   * // Actually send the message
+   * await channel.processTasks();
+   * ```
    */
   public async sendMessage(
     payload: Uint8Array,
@@ -96,36 +151,13 @@ export class MessageChannel extends TypedEventEmitter<MessageChannelEvents> {
       retrievalHint?: Uint8Array;
     }>
   ): Promise<void> {
-    this.lamportTimestamp++;
-
-    const messageId = MessageChannel.getMessageId(payload);
-
-    const message: Message = {
-      messageId,
-      channelId: this.channelId,
-      lamportTimestamp: this.lamportTimestamp,
-      causalHistory: this.localHistory
-        .slice(-this.causalHistorySize)
-        .map(({ historyEntry }) => historyEntry),
-      bloomFilter: this.filter.toBytes(),
-      content: payload
-    };
-
-    this.outgoingBuffer.push(message);
-
-    if (callback) {
-      const { success, retrievalHint } = await callback(message);
-      if (success) {
-        this.filter.insert(messageId);
-        this.localHistory.push({
-          timestamp: this.lamportTimestamp,
-          historyEntry: {
-            messageId,
-            retrievalHint
-          }
-        });
+    this.tasks.push({
+      command: Command.Send,
+      params: {
+        payload,
+        callback
       }
-    }
+    });
   }
 
   /**
@@ -141,72 +173,58 @@ export class MessageChannel extends TypedEventEmitter<MessageChannelEvents> {
    * @param payload - The payload to send.
    * @param callback - A callback function that returns a boolean indicating whether the message was sent successfully.
    */
-  public sendEphemeralMessage(
+  public async sendEphemeralMessage(
     payload: Uint8Array,
-    callback?: (message: Message) => boolean
-  ): void {
-    const message: Message = {
-      messageId: MessageChannel.getMessageId(payload),
-      channelId: this.channelId,
-      content: payload,
-      lamportTimestamp: undefined,
-      causalHistory: [],
-      bloomFilter: undefined
-    };
-
-    if (callback) {
-      callback(message);
-    }
+    callback?: (message: Message) => Promise<boolean>
+  ): Promise<void> {
+    this.tasks.push({
+      command: Command.SendEphemeral,
+      params: {
+        payload,
+        callback
+      }
+    });
   }
+
   /**
-   * Process a received SDS message for this channel.
+   * Queues a received message for processing.
    *
-   * Review the acknowledgement status of messages in the outgoing buffer
-   * by inspecting the received message's bloom filter and causal history.
-   * Add the received message to the bloom filter.
-   * If the local history contains every message in the received message's
-   * causal history, deliver the message. Otherwise, add the message to the
-   * incoming buffer.
+   * The message will be processed when processTasks() is called, ensuring
+   * proper dependency resolution and causal ordering.
    *
-   * See https://rfc.vac.dev/vac/raw/sds/#receive-message
+   * @param message - The message to receive and process
    *
-   * @param message - The received SDS message.
+   * @example
+   * ```typescript
+   * const channel = new MessageChannel("chat-room");
+   *
+   * // Receive a message from the network
+   * channel.receiveMessage(incomingMessage);
+   *
+   * // Process the received message
+   * await channel.processTasks();
+   * ```
    */
   public receiveMessage(message: Message): void {
-    if (!message.lamportTimestamp) {
-      // Messages with no timestamp are ephemeral messages and should be delivered immediately
-      this.deliverMessage(message);
-      return;
-    }
-    // review ack status
-    this.reviewAckStatus(message);
-    // add to bloom filter (skip for messages with empty content)
-    if (message.content?.length && message.content.length > 0) {
-      this.filter.insert(message.messageId);
-    }
-    // verify causal history
-    const dependenciesMet = message.causalHistory.every((historyEntry) =>
-      this.localHistory.some(
-        ({ historyEntry: { messageId } }) =>
-          messageId === historyEntry.messageId
-      )
-    );
-    if (!dependenciesMet) {
-      this.incomingBuffer.push(message);
-      this.timeReceived.set(message.messageId, Date.now());
-    } else {
-      this.deliverMessage(message);
-    }
+    this.tasks.push({
+      command: Command.Receive,
+      params: {
+        message
+      }
+    });
   }
 
-  // https://rfc.vac.dev/vac/raw/sds/#periodic-incoming-buffer-sweep
+  /**
+   * Processes messages in the incoming buffer, delivering those with satisfied dependencies.
+   *
+   * @returns Array of history entries for messages still missing dependencies
+   */
   public sweepIncomingBuffer(): HistoryEntry[] {
     const { buffer, missing } = this.incomingBuffer.reduce<{
       buffer: Message[];
-      missing: HistoryEntry[];
+      missing: Set<HistoryEntry>;
     }>(
       ({ buffer, missing }, message) => {
-        // Check each message for missing dependencies
         const missingDependencies = message.causalHistory.filter(
           (messageHistoryEntry) =>
             !this.localHistory.some(
@@ -215,9 +233,13 @@ export class MessageChannel extends TypedEventEmitter<MessageChannelEvents> {
             )
         );
         if (missingDependencies.length === 0) {
-          // Any message with no missing dependencies is delivered
-          // and removed from the buffer (implicitly by not adding it to the new incoming buffer)
           this.deliverMessage(message);
+          this.safeSendEvent(MessageChannelEvent.MessageDelivered, {
+            detail: {
+              messageId: message.messageId,
+              sentOrReceived: "received"
+            }
+          });
           return { buffer, missing };
         }
 
@@ -232,18 +254,23 @@ export class MessageChannel extends TypedEventEmitter<MessageChannelEvents> {
             return { buffer, missing };
           }
         }
-        // Any message with missing dependencies stays in the buffer
-        // and the missing message IDs are returned for processing.
+        missingDependencies.forEach((dependency) => {
+          missing.add(dependency);
+        });
         return {
           buffer: buffer.concat(message),
-          missing: missing.concat(missingDependencies)
+          missing
         };
       },
-      { buffer: new Array<Message>(), missing: new Array<HistoryEntry>() }
+      { buffer: new Array<Message>(), missing: new Set<HistoryEntry>() }
     );
-    // Update the incoming buffer to only include messages with no missing dependencies
     this.incomingBuffer = buffer;
-    return missing;
+
+    this.safeSendEvent(MessageChannelEvent.MissedMessages, {
+      detail: Array.from(missing)
+    });
+
+    return Array.from(missing);
   }
 
   // https://rfc.vac.dev/vac/raw/sds/#periodic-outgoing-buffer-sweep
@@ -251,7 +278,6 @@ export class MessageChannel extends TypedEventEmitter<MessageChannelEvents> {
     unacknowledged: Message[];
     possiblyAcknowledged: Message[];
   } {
-    // Partition all messages in the outgoing buffer into unacknowledged and possibly acknowledged messages
     return this.outgoingBuffer.reduce<{
       unacknowledged: Message[];
       possiblyAcknowledged: Message[];
@@ -285,7 +311,7 @@ export class MessageChannel extends TypedEventEmitter<MessageChannelEvents> {
    *
    * @param callback - A callback function that returns a boolean indicating whether the message was sent successfully.
    */
-  public sendSyncMessage(
+  public async sendSyncMessage(
     callback?: (message: Message) => Promise<boolean>
   ): Promise<boolean> {
     this.lamportTimestamp++;
@@ -304,15 +330,165 @@ export class MessageChannel extends TypedEventEmitter<MessageChannelEvents> {
     };
 
     if (callback) {
-      return callback(message);
+      try {
+        await callback(message);
+        this.safeSendEvent(MessageChannelEvent.SyncSent, {
+          detail: message
+        });
+        return true;
+      } catch (error) {
+        log.error("Callback execution failed in sendSyncMessage:", error);
+        throw error;
+      }
+    }
+    return false;
+  }
+
+  private _receiveMessage(message: Message): void {
+    const isDuplicate =
+      message.content &&
+      message.content.length > 0 &&
+      this.timeReceived.has(message.messageId);
+
+    if (isDuplicate) {
+      return;
+    }
+
+    if (!message.lamportTimestamp) {
+      this.deliverMessage(message);
+      return;
+    }
+    if (message.content?.length === 0) {
+      this.safeSendEvent(MessageChannelEvent.SyncReceived, {
+        detail: message
+      });
+    } else {
+      this.safeSendEvent(MessageChannelEvent.MessageReceived, {
+        detail: message
+      });
+    }
+    this.reviewAckStatus(message);
+    if (message.content?.length && message.content.length > 0) {
+      this.filter.insert(message.messageId);
+    }
+    const dependenciesMet = message.causalHistory.every((historyEntry) =>
+      this.localHistory.some(
+        ({ historyEntry: { messageId } }) =>
+          messageId === historyEntry.messageId
+      )
+    );
+    if (!dependenciesMet) {
+      this.incomingBuffer.push(message);
+      this.timeReceived.set(message.messageId, Date.now());
+    } else {
+      this.deliverMessage(message);
+      this.safeSendEvent(MessageChannelEvent.MessageDelivered, {
+        detail: {
+          messageId: message.messageId,
+          sentOrReceived: "received"
+        }
+      });
+    }
+  }
+
+  private async executeTask<A extends Command>(item: Task<A>): Promise<void> {
+    try {
+      const handler = this.handlers[item.command];
+      await handler(item.params as ParamsByAction[A]);
+    } catch (error) {
+      log.error(`Task execution failed for command ${item.command}:`, error);
+      this.dispatchEvent(
+        new CustomEvent("taskError", {
+          detail: { command: item.command, error, params: item.params }
+        })
+      );
+    }
+  }
+
+  private safeSendEvent<T extends MessageChannelEvent>(
+    event: T,
+    eventInit?: CustomEventInit
+  ): void {
+    try {
+      this.dispatchEvent(new CustomEvent(event, eventInit));
+    } catch (error) {
+      log.error(`Failed to dispatch event ${event}:`, error);
+    }
+  }
+
+  private async _sendMessage(
+    payload: Uint8Array,
+    callback?: (message: Message) => Promise<{
+      success: boolean;
+      retrievalHint?: Uint8Array;
+    }>
+  ): Promise<void> {
+    this.lamportTimestamp++;
+
+    const messageId = MessageChannel.getMessageId(payload);
+
+    const message: Message = {
+      messageId,
+      channelId: this.channelId,
+      lamportTimestamp: this.lamportTimestamp,
+      causalHistory: this.localHistory
+        .slice(-this.causalHistorySize)
+        .map(({ historyEntry }) => historyEntry),
+      bloomFilter: this.filter.toBytes(),
+      content: payload
+    };
+
+    this.outgoingBuffer.push(message);
+
+    if (callback) {
+      try {
+        const { success, retrievalHint } = await callback(message);
+        if (success) {
+          this.filter.insert(messageId);
+          this.localHistory.push({
+            timestamp: this.lamportTimestamp,
+            historyEntry: {
+              messageId,
+              retrievalHint
+            }
+          });
+          this.timeReceived.set(messageId, Date.now());
+          this.safeSendEvent(MessageChannelEvent.MessageSent, {
+            detail: message
+          });
+        }
+      } catch (error) {
+        log.error("Callback execution failed in _sendMessage:", error);
+        throw error;
+      }
+    }
+  }
+
+  private async _sendEphemeralMessage(
+    payload: Uint8Array,
+    callback?: (message: Message) => Promise<boolean>
+  ): Promise<void> {
+    const message: Message = {
+      messageId: MessageChannel.getMessageId(payload),
+      channelId: this.channelId,
+      content: payload,
+      lamportTimestamp: undefined,
+      causalHistory: [],
+      bloomFilter: undefined
+    };
+
+    if (callback) {
+      try {
+        await callback(message);
+      } catch (error) {
+        log.error("Callback execution failed in _sendEphemeralMessage:", error);
+        throw error;
+      }
     }
-    return Promise.resolve(false);
   }
 
   // See https://rfc.vac.dev/vac/raw/sds/#deliver-message
   private deliverMessage(message: Message, retrievalHint?: Uint8Array): void {
-    this.notifyDeliveredMessage(message.messageId);
-
     const messageLamportTimestamp = message.lamportTimestamp ?? 0;
     if (messageLamportTimestamp > this.lamportTimestamp) {
       this.lamportTimestamp = messageLamportTimestamp;
@@ -352,17 +528,23 @@ export class MessageChannel extends TypedEventEmitter<MessageChannelEvents> {
   // to determine the acknowledgement status of messages in the outgoing buffer.
   // See https://rfc.vac.dev/vac/raw/sds/#review-ack-status
   private reviewAckStatus(receivedMessage: Message): void {
-    // the participant MUST mark all messages in the received causal_history as acknowledged.
     receivedMessage.causalHistory.forEach(({ messageId }) => {
       this.outgoingBuffer = this.outgoingBuffer.filter(
-        ({ messageId: outgoingMessageId }) => outgoingMessageId !== messageId
+        ({ messageId: outgoingMessageId }) => {
+          if (outgoingMessageId !== messageId) {
+            return true;
+          }
+          this.safeSendEvent(MessageChannelEvent.MessageAcknowledged, {
+            detail: messageId
+          });
+          return false;
+        }
       );
       this.acknowledgements.delete(messageId);
       if (!this.filter.lookup(messageId)) {
         this.filter.insert(messageId);
       }
     });
-    // the participant MUST mark all messages included in the bloom_filter as possibly acknowledged
     if (!receivedMessage.bloomFilter) {
       return;
     }
@@ -380,6 +562,12 @@ export class MessageChannel extends TypedEventEmitter<MessageChannelEvents> {
       const count = (this.acknowledgements.get(message.messageId) ?? 0) + 1;
       if (count < this.acknowledgementCount) {
         this.acknowledgements.set(message.messageId, count);
+        this.safeSendEvent(MessageChannelEvent.PartialAcknowledgement, {
+          detail: {
+            messageId: message.messageId,
+            count
+          }
+        });
         return true;
       }
       this.acknowledgements.delete(message.messageId);
@@ -391,15 +579,4 @@ export class MessageChannel extends TypedEventEmitter<MessageChannelEvents> {
   private getAcknowledgementCount(): number {
     return 2;
   }
-
-  private notifyDeliveredMessage(messageId: string): void {
-    if (this.deliveredMessageCallback) {
-      this.deliveredMessageCallback(messageId);
-    }
-    this.dispatchEvent(
-      new CustomEvent(MessageChannelEvent.MessageDelivered, {
-        detail: messageId
-      })
-    );
-  }
 }

package/dist/bloom.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"bloom.js","sourceRoot":"","sources":["../src/bloom.ts"],"names":[],"mappings":"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"}