@waku/core 0.0.36-16328a3.0 → 0.0.36-3730abc.0

package/src/lib/light_push/push_rpc_v3.ts

@@ -0,0 +1,46 @@
+import { proto_lightpush_v3, WakuMessage } from "@waku/proto";
+import type { Uint8ArrayList } from "uint8arraylist";
+import { v4 as uuid } from "uuid";
+
+export class PushRpcV3 {
+  public request?: proto_lightpush_v3.LightpushRequest;
+  public response?: proto_lightpush_v3.LightpushResponse;
+
+  private constructor(
+    request?: proto_lightpush_v3.LightpushRequest,
+    response?: proto_lightpush_v3.LightpushResponse
+  ) {
+    this.request = request;
+    this.response = response;
+  }
+
+  public static createRequest(
+    message: WakuMessage,
+    pubsubTopic?: string
+  ): PushRpcV3 {
+    const request: proto_lightpush_v3.LightpushRequest = {
+      requestId: uuid(),
+      message: message,
+      // Only include pubsubTopic if explicitly provided (for nwaku autosharding compatibility)
+      ...(pubsubTopic && { pubsubTopic })
+    };
+
+    return new PushRpcV3(request, undefined);
+  }
+
+  public static decode(bytes: Uint8ArrayList | Uint8Array): PushRpcV3 {
+    const response = proto_lightpush_v3.LightpushResponse.decode(bytes);
+    return new PushRpcV3(undefined, response);
+  }
+
+  public encode(): Uint8Array {
+    if (!this.request) {
+      throw new Error("Cannot encode without a request");
+    }
+    return proto_lightpush_v3.LightpushRequest.encode(this.request);
+  }
+
+  public get query(): proto_lightpush_v3.LightpushRequest | undefined {
+    return this.request;
+  }
+}

package/src/lib/light_push/status_codes.ts

@@ -0,0 +1,71 @@
+import { ProtocolError } from "@waku/interfaces";
+
+export enum LightPushStatusCode {
+  SUCCESS = 200,
+  BAD_REQUEST = 400,
+  UNSUPPORTED_PUBSUB_TOPIC = 404,
+  REQUEST_TOO_LARGE = 413,
+  TOO_MANY_REQUESTS = 429,
+  INTERNAL_SERVER_ERROR = 500,
+  NO_PEERS_TO_RELAY = 503
+}
+
+export function lightPushStatusCodeToProtocolError(
+  statusCode: number
+): ProtocolError | null {
+  switch (statusCode) {
+    case LightPushStatusCode.SUCCESS:
+      return null;
+
+    case LightPushStatusCode.BAD_REQUEST:
+      return ProtocolError.GENERIC_FAIL;
+
+    case LightPushStatusCode.UNSUPPORTED_PUBSUB_TOPIC:
+      return ProtocolError.TOPIC_NOT_CONFIGURED;
+
+    case LightPushStatusCode.REQUEST_TOO_LARGE:
+      return ProtocolError.SIZE_TOO_BIG;
+
+    case LightPushStatusCode.TOO_MANY_REQUESTS:
+      return ProtocolError.GENERIC_FAIL;
+
+    case LightPushStatusCode.INTERNAL_SERVER_ERROR:
+      return ProtocolError.REMOTE_PEER_REJECTED;
+
+    case LightPushStatusCode.NO_PEERS_TO_RELAY:
+      return ProtocolError.NO_PEER_AVAILABLE;
+
+    default:
+      return ProtocolError.REMOTE_PEER_REJECTED;
+  }
+}
+
+export const lightPushStatusDescriptions: Record<number, string> = {
+  [LightPushStatusCode.SUCCESS]: "Message pushed successfully",
+  [LightPushStatusCode.BAD_REQUEST]:
+    "Invalid request format or missing required fields",
+  [LightPushStatusCode.UNSUPPORTED_PUBSUB_TOPIC]:
+    "The specified pubsub topic is not supported",
+  [LightPushStatusCode.REQUEST_TOO_LARGE]:
+    "Message size exceeds maximum allowed size",
+  [LightPushStatusCode.TOO_MANY_REQUESTS]:
+    "Rate limit exceeded, too many requests",
+  [LightPushStatusCode.INTERNAL_SERVER_ERROR]: "Internal server error occurred",
+  [LightPushStatusCode.NO_PEERS_TO_RELAY]:
+    "No relay peers available to forward the message"
+};
+
+export function isSuccessStatusCode(statusCode: number): boolean {
+  return statusCode === LightPushStatusCode.SUCCESS;
+}
+
+export function getLightPushStatusDescription(
+  statusCode: number,
+  statusDesc?: string
+): string {
+  return (
+    statusDesc ||
+    lightPushStatusDescriptions[statusCode] ||
+    `Unknown status code: ${statusCode}`
+  );
+}

package/src/lib/light_push/status_codes_v3.ts

@@ -0,0 +1,97 @@
+import { ProtocolError } from "@waku/interfaces";
+
+export enum LightPushStatusCodeV3 {
+  SUCCESS = 200,
+  BAD_REQUEST = 400,
+  PAYLOAD_TOO_LARGE = 413,
+  INVALID_MESSAGE_ERROR = 420,
+  UNSUPPORTED_PUBSUB_TOPIC = 421,
+  TOO_MANY_REQUESTS = 429,
+  INTERNAL_SERVER_ERROR = 500,
+  SERVICE_NOT_AVAILABLE = 503,
+  OUT_OF_RLN_PROOF = 504,
+  NO_PEERS_TO_RELAY = 505
+}
+
+export const lightPushStatusDescriptionsV3: Record<
+  LightPushStatusCodeV3,
+  string
+> = {
+  [LightPushStatusCodeV3.SUCCESS]: "Message sent successfully",
+  [LightPushStatusCodeV3.BAD_REQUEST]: "Bad request format",
+  [LightPushStatusCodeV3.PAYLOAD_TOO_LARGE]:
+    "Message payload exceeds maximum size",
+  [LightPushStatusCodeV3.INVALID_MESSAGE_ERROR]: "Message validation failed",
+  [LightPushStatusCodeV3.UNSUPPORTED_PUBSUB_TOPIC]: "Unsupported pubsub topic",
+  [LightPushStatusCodeV3.TOO_MANY_REQUESTS]: "Rate limit exceeded",
+  [LightPushStatusCodeV3.INTERNAL_SERVER_ERROR]: "Internal server error",
+  [LightPushStatusCodeV3.SERVICE_NOT_AVAILABLE]:
+    "Service temporarily unavailable",
+  [LightPushStatusCodeV3.OUT_OF_RLN_PROOF]: "RLN proof generation failed",
+  [LightPushStatusCodeV3.NO_PEERS_TO_RELAY]: "No relay peers available"
+};
+
+export function lightPushStatusCodeToProtocolErrorV3(
+  statusCode: LightPushStatusCodeV3 | number | undefined
+): ProtocolError {
+  if (!statusCode) {
+    return ProtocolError.GENERIC_FAIL;
+  }
+
+  switch (statusCode) {
+    case LightPushStatusCodeV3.SUCCESS:
+      return ProtocolError.GENERIC_FAIL;
+
+    case LightPushStatusCodeV3.BAD_REQUEST:
+      return ProtocolError.DECODE_FAILED;
+
+    case LightPushStatusCodeV3.PAYLOAD_TOO_LARGE:
+      return ProtocolError.SIZE_TOO_BIG;
+
+    case LightPushStatusCodeV3.INVALID_MESSAGE_ERROR:
+      return ProtocolError.EMPTY_PAYLOAD;
+
+    case LightPushStatusCodeV3.UNSUPPORTED_PUBSUB_TOPIC:
+      return ProtocolError.TOPIC_NOT_CONFIGURED;
+
+    case LightPushStatusCodeV3.TOO_MANY_REQUESTS:
+      return ProtocolError.REMOTE_PEER_REJECTED;
+
+    case LightPushStatusCodeV3.INTERNAL_SERVER_ERROR:
+      return ProtocolError.GENERIC_FAIL;
+
+    case LightPushStatusCodeV3.SERVICE_NOT_AVAILABLE:
+      return ProtocolError.NO_PEER_AVAILABLE;
+
+    case LightPushStatusCodeV3.OUT_OF_RLN_PROOF:
+      return ProtocolError.RLN_PROOF_GENERATION;
+
+    case LightPushStatusCodeV3.NO_PEERS_TO_RELAY:
+      return ProtocolError.NO_PEER_AVAILABLE;
+
+    default:
+      return ProtocolError.REMOTE_PEER_REJECTED;
+  }
+}
+
+export function isSuccessStatusCodeV3(statusCode: number | undefined): boolean {
+  return statusCode === LightPushStatusCodeV3.SUCCESS;
+}
+
+export function getLightPushStatusDescriptionV3(
+  statusCode: number | undefined,
+  customDesc?: string
+): string {
+  if (customDesc) {
+    return customDesc;
+  }
+
+  if (!statusCode) {
+    return "Unknown error";
+  }
+
+  return (
+    lightPushStatusDescriptionsV3[statusCode as LightPushStatusCodeV3] ||
+    `Unknown status code: ${statusCode}`
+  );
+}

package/src/lib/message/version_0.ts

@@ -22,7 +22,7 @@ export { proto };
 export class DecodedMessage implements IDecodedMessage {
   public constructor(
     public pubsubTopic: string,
-    protected proto: proto.WakuMessage
+    private proto: proto.WakuMessage
   ) {}
 
   public get ephemeral(): boolean {
@@ -37,10 +37,6 @@ export class DecodedMessage implements IDecodedMessage {
     return this.proto.contentTopic;
   }
 
-  public get _rawTimestamp(): bigint | undefined {
-    return this.proto.timestamp;
-  }
-
   public get timestamp(): Date | undefined {
     // In the case we receive a value that is bigger than JS's max number,
     // we catch the error and return undefined.
@@ -63,7 +59,7 @@ export class DecodedMessage implements IDecodedMessage {
   public get version(): number {
     // https://rfc.vac.dev/spec/14/
     // > If omitted, the value SHOULD be interpreted as version 0.
-    return this.proto.version ?? 0;
+    return this.proto.version ?? Version;
   }
 
   public get rateLimitProof(): IRateLimitProof | undefined {
@@ -160,7 +156,7 @@ export class Decoder implements IDecoder<IDecodedMessage> {
   public async fromProtoObj(
     pubsubTopic: string,
     proto: IProtoMessage
-  ): Promise<DecodedMessage | undefined> {
+  ): Promise<IDecodedMessage | undefined> {
     // https://rfc.vac.dev/spec/14/
     // > If omitted, the value SHOULD be interpreted as version 0.
     if (proto.version ?? 0 !== Version) {

package/src/lib/message_hash/index.ts

@@ -0,0 +1 @@
+export { messageHash, messageHashStr } from "./message_hash.js";

package/src/lib/message_hash/message_hash.ts

@@ -0,0 +1,106 @@
+import { sha256 } from "@noble/hashes/sha256";
+import type { IDecodedMessage, IProtoMessage } from "@waku/interfaces";
+import { isDefined } from "@waku/utils";
+import {
+  bytesToHex,
+  concat,
+  numberToBytes,
+  utf8ToBytes
+} from "@waku/utils/bytes";
+
+/**
+ * Deterministic Message Hashing as defined in
+ * [14/WAKU2-MESSAGE](https://rfc.vac.dev/spec/14/#deterministic-message-hashing)
+ *
+ * Computes a SHA-256 hash of the concatenation of pubsub topic, payload, content topic, meta, and timestamp.
+ *
+ * @param pubsubTopic - The pubsub topic string
+ * @param message - The message to be hashed
+ * @returns A Uint8Array containing the SHA-256 hash
+ *
+ * @example
+ * ```typescript
+ * import { messageHash } from "@waku/core";
+ *
+ * const pubsubTopic = "/waku/2/default-waku/proto";
+ * const message = {
+ *   payload: new Uint8Array([1, 2, 3, 4]),
+ *   contentTopic: "/waku/2/default-content/proto",
+ *   meta: new Uint8Array([5, 6, 7, 8]),
+ *   timestamp: new Date()
+ * };
+ *
+ * const hash = messageHash(pubsubTopic, message);
+ * ```
+ */
+export function messageHash(
+  pubsubTopic: string,
+  message: IProtoMessage | IDecodedMessage
+): Uint8Array {
+  const pubsubTopicBytes = utf8ToBytes(pubsubTopic);
+  const contentTopicBytes = utf8ToBytes(message.contentTopic);
+  const timestampBytes = tryConvertTimestampToBytes(message.timestamp);
+
+  const bytes = concat(
+    [
+      pubsubTopicBytes,
+      message.payload,
+      contentTopicBytes,
+      message.meta,
+      timestampBytes
+    ].filter(isDefined)
+  );
+
+  return sha256(bytes);
+}
+
+function tryConvertTimestampToBytes(
+  timestamp: Date | number | bigint | undefined
+): undefined | Uint8Array {
+  if (!timestamp) {
+    return;
+  }
+
+  let bigIntTimestamp: bigint;
+
+  if (typeof timestamp === "bigint") {
+    bigIntTimestamp = timestamp;
+  } else {
+    bigIntTimestamp = BigInt(timestamp.valueOf()) * 1000000n;
+  }
+
+  return numberToBytes(bigIntTimestamp);
+}
+
+/**
+ * Computes a deterministic message hash and returns it as a hexadecimal string.
+ * This is a convenience wrapper around messageHash that converts the result to a hex string.
+ *
+ * @param pubsubTopic - The pubsub topic string
+ * @param message - The message to be hashed
+ * @returns A string containing the hex representation of the SHA-256 hash
+ *
+ * @example
+ * ```typescript
+ * import { messageHashStr } from "@waku/core";
+ *
+ * const pubsubTopic = "/waku/2/default-waku/proto";
+ * const message = {
+ *   payload: new Uint8Array([1, 2, 3, 4]),
+ *   contentTopic: "/waku/2/default-content/proto",
+ *   meta: new Uint8Array([5, 6, 7, 8]),
+ *   timestamp: new Date()
+ * };
+ *
+ * const hashString = messageHashStr(pubsubTopic, message);
+ * console.log(hashString); // e.g. "a1b2c3d4..."
+ * ```
+ */
+export function messageHashStr(
+  pubsubTopic: string,
+  message: IProtoMessage | IDecodedMessage
+): string {
+  const hash = messageHash(pubsubTopic, message);
+  const hashStr = bytesToHex(hash);
+  return hashStr;
+}

package/src/lib/store/rpc.ts

@@ -14,6 +14,7 @@ export class StoreQueryRequest {
   public static create(params: QueryRequestParams): StoreQueryRequest {
     const request = new StoreQueryRequest({
       ...params,
+      contentTopics: params.contentTopics || [],
       requestId: uuid(),
       timeStart: params.timeStart
         ? BigInt(params.timeStart.getTime() * ONE_MILLION)
@@ -27,26 +28,29 @@ export class StoreQueryRequest {
         : undefined
     });
 
-    // Validate request parameters based on RFC
-    if (
-      (params.pubsubTopic && !params.contentTopics) ||
-      (!params.pubsubTopic && params.contentTopics)
-    ) {
-      throw new Error(
-        "Both pubsubTopic and contentTopics must be set or unset"
-      );
-    }
+    const isHashQuery = params.messageHashes && params.messageHashes.length > 0;
+    const hasContentTopics =
+      params.contentTopics && params.contentTopics.length > 0;
+    const hasTimeFilter = params.timeStart || params.timeEnd;
 
-    if (
-      params.messageHashes &&
-      (params.pubsubTopic ||
-        params.contentTopics ||
-        params.timeStart ||
-        params.timeEnd)
-    ) {
-      throw new Error(
-        "Message hash lookup queries cannot include content filter criteria"
-      );
+    if (isHashQuery) {
+      if (hasContentTopics || hasTimeFilter) {
+        throw new Error(
+          "Message hash lookup queries cannot include content filter criteria (contentTopics, timeStart, or timeEnd)"
+        );
+      }
+    } else {
+      if (
+        (params.pubsubTopic &&
+          (!params.contentTopics || params.contentTopics.length === 0)) ||
+        (!params.pubsubTopic &&
+          params.contentTopics &&
+          params.contentTopics.length > 0)
+      ) {
+        throw new Error(
+          "Both pubsubTopic and contentTopics must be set together for content-filtered queries"
+        );
+      }
     }
 
     return request;

package/src/lib/store/store.ts

@@ -40,9 +40,14 @@ export class StoreCore extends BaseProtocol implements IStoreCore {
     decoders: Map<string, IDecoder<T>>,
     peerId: PeerId
   ): AsyncGenerator<Promise<T | undefined>[]> {
+    // Only validate decoder content topics for content-filtered queries
+    const isHashQuery =
+      queryOpts.messageHashes && queryOpts.messageHashes.length > 0;
     if (
+      !isHashQuery &&
+      queryOpts.contentTopics &&
       queryOpts.contentTopics.toString() !==
-      Array.from(decoders.keys()).toString()
+        Array.from(decoders.keys()).toString()
     ) {
       throw new Error(
         "Internal error, the decoders should match the query's content topics"
@@ -56,6 +61,13 @@ export class StoreCore extends BaseProtocol implements IStoreCore {
         paginationCursor: currentCursor
       });
 
+      log.info("Sending store query request:", {
+        hasMessageHashes: !!queryOpts.messageHashes?.length,
+        messageHashCount: queryOpts.messageHashes?.length,
+        pubsubTopic: queryOpts.pubsubTopic,
+        contentTopics: queryOpts.contentTopics
+      });
+
       let stream;
       try {
         stream = await this.getStream(peerId);