@waku/core 0.0.36-4997440.0 → 0.0.36-76fb1ea.0

package/src/lib/light_push/light_push.ts

@@ -9,7 +9,7 @@ import {
   PubsubTopic,
   type ThisOrThat
 } from "@waku/interfaces";
-import { PushResponse } from "@waku/proto";
+import { proto_lightpush_v2, PushResponse } from "@waku/proto";
 import { isMessageSizeUnderCap } from "@waku/utils";
 import { Logger } from "@waku/utils";
 import all from "it-all";
@@ -19,19 +19,17 @@ import { Uint8ArrayList } from "uint8arraylist";
 
 import { BaseProtocol } from "../base_protocol.js";
 
-import { PushRpc } from "./push_rpc.js";
-import { isRLNResponseError } from "./utils.js";
+import { PushRpcV2 } from "./push_rpc_v2.js";
+import { mapInfoToProtocolError } from "./utils.js";
 
 const log = new Logger("light-push");
 
 export const LightPushCodec = "/vac/waku/lightpush/2.0.0-beta1";
-export { PushResponse };
 
-type PreparePushMessageResult = ThisOrThat<"query", PushRpc>;
+export const LightPushCodecV2 = LightPushCodec;
+
+type PreparePushMessageResult = ThisOrThat<"query", PushRpcV2>;
 
-/**
- * Implements the [Waku v2 Light Push protocol](https://rfc.vac.dev/spec/19/).
- */
 export class LightPushCore extends BaseProtocol implements IBaseProtocolCore {
   public constructor(
     public readonly pubsubTopics: PubsubTopic[],
@@ -64,7 +62,7 @@ export class LightPushCore extends BaseProtocol implements IBaseProtocolCore {
         };
       }
 
-      const query = PushRpc.createRequest(protoMessage, encoder.pubsubTopic);
+      const query = PushRpcV2.createRequest(protoMessage, encoder.pubsubTopic);
       return { query, error: null };
     } catch (error) {
       log.error("Failed to prepare push message", error);
@@ -120,7 +118,6 @@ export class LightPushCore extends BaseProtocol implements IBaseProtocolCore {
         async (source) => await all(source)
       );
     } catch (err) {
-      // can fail only because of `stream` abortion
       log.error("Failed to send waku light push request", err);
       return {
         success: null,
@@ -136,9 +133,9 @@ export class LightPushCore extends BaseProtocol implements IBaseProtocolCore {
       bytes.append(chunk);
     });
 
-    let response: PushResponse | undefined;
+    let response: proto_lightpush_v2.PushResponse | undefined;
     try {
-      response = PushRpc.decode(bytes).response;
+      response = PushRpcV2.decode(bytes).response;
     } catch (err) {
       log.error("Failed to decode push reply", err);
       return {
@@ -161,23 +158,17 @@ export class LightPushCore extends BaseProtocol implements IBaseProtocolCore {
       };
     }
 
-    if (isRLNResponseError(response.info)) {
-      log.error("Remote peer fault: RLN generation");
-      return {
-        success: null,
-        failure: {
-          error: ProtocolError.RLN_PROOF_GENERATION,
-          peerId: peerId
-        }
-      };
-    }
-
     if (!response.isSuccess) {
-      log.error("Remote peer rejected the message: ", response.info);
+      const errorMessage = response.info || "Message rejected";
+      log.error("Remote peer rejected the message: ", errorMessage);
+
+      // Use pattern matching to determine the appropriate error type
+      const error = mapInfoToProtocolError(response.info);
+
       return {
         success: null,
         failure: {
-          error: ProtocolError.REMOTE_PEER_REJECTED,
+          error: error,
           peerId: peerId
         }
       };
@@ -186,3 +177,6 @@ export class LightPushCore extends BaseProtocol implements IBaseProtocolCore {
     return { success: peerId, failure: null };
   }
 }
+
+export const LightPushCoreV2 = LightPushCore;
+export { PushResponse };

package/src/lib/light_push/light_push_v3.ts

@@ -0,0 +1,232 @@
+import type { PeerId, Stream } from "@libp2p/interface";
+import {
+  type CoreProtocolResult,
+  type IBaseProtocolCore,
+  type IEncoder,
+  type IMessage,
+  isSuccessStatusCodeV3,
+  type Libp2p,
+  LightPushCodecV3,
+  LightPushStatusCodeV3,
+  ProtocolError,
+  PubsubTopic,
+  type ThisOrThat
+} from "@waku/interfaces";
+import { proto_lightpush_v3, WakuMessage } from "@waku/proto";
+import { isMessageSizeUnderCap } from "@waku/utils";
+import { Logger } from "@waku/utils";
+import all from "it-all";
+import * as lp from "it-length-prefixed";
+import { pipe } from "it-pipe";
+import { Uint8ArrayList } from "uint8arraylist";
+
+import { BaseProtocol } from "../base_protocol.js";
+
+import { PushRpcV3 } from "./push_rpc_v3.js";
+import {
+  getLightPushStatusDescriptionV3,
+  lightPushStatusCodeToProtocolErrorV3
+} from "./status_codes_v3.js";
+import { isRLNResponseError } from "./utils.js";
+
+const log = new Logger("light-push-v3");
+
+type PreparePushMessageResult = ThisOrThat<"query", PushRpcV3>;
+
+export class LightPushCoreV3 extends BaseProtocol implements IBaseProtocolCore {
+  public constructor(
+    public readonly pubsubTopics: PubsubTopic[],
+    libp2p: Libp2p
+  ) {
+    super(LightPushCodecV3, libp2p.components, pubsubTopics);
+  }
+
+  private async preparePushMessage(
+    encoder: IEncoder,
+    message: IMessage
+  ): Promise<PreparePushMessageResult> {
+    try {
+      if (!message.payload || message.payload.length === 0) {
+        log.error("Failed to send waku light push: payload is empty");
+        return { query: null, error: ProtocolError.EMPTY_PAYLOAD };
+      }
+
+      if (!(await isMessageSizeUnderCap(encoder, message))) {
+        log.error("Failed to send waku light push: message is bigger than 1MB");
+        return { query: null, error: ProtocolError.SIZE_TOO_BIG };
+      }
+
+      const protoMessage = await encoder.toProtoObj(message);
+      if (!protoMessage) {
+        log.error("Failed to encode to protoMessage, aborting push");
+        return {
+          query: null,
+          error: ProtocolError.ENCODE_FAILED
+        };
+      }
+
+      const query = PushRpcV3.createRequest(
+        protoMessage as WakuMessage,
+        encoder.pubsubTopic
+      );
+      return { query, error: null };
+    } catch (error) {
+      log.error("Failed to prepare push message", error);
+
+      return {
+        query: null,
+        error: ProtocolError.GENERIC_FAIL
+      };
+    }
+  }
+
+  public async send(
+    encoder: IEncoder,
+    message: IMessage,
+    peerId: PeerId
+  ): Promise<CoreProtocolResult> {
+    const { query, error: preparationError } = await this.preparePushMessage(
+      encoder,
+      message
+    );
+
+    if (preparationError || !query) {
+      return {
+        success: null,
+        failure: {
+          error: preparationError,
+          peerId
+        }
+      };
+    }
+
+    let stream: Stream;
+    try {
+      stream = await this.getStream(peerId);
+    } catch (error) {
+      log.error("Failed to get stream", error);
+      return {
+        success: null,
+        failure: {
+          error: ProtocolError.NO_STREAM_AVAILABLE,
+          peerId: peerId
+        }
+      };
+    }
+
+    let res: Uint8ArrayList[] | undefined;
+    try {
+      res = await pipe(
+        [query.encode()],
+        lp.encode,
+        stream,
+        lp.decode,
+        async (source) => await all(source)
+      );
+    } catch (err) {
+      log.error("Failed to send waku light push request", err);
+      return {
+        success: null,
+        failure: {
+          error: ProtocolError.STREAM_ABORTED,
+          peerId: peerId
+        }
+      };
+    }
+
+    const bytes = new Uint8ArrayList();
+    res.forEach((chunk) => {
+      bytes.append(chunk);
+    });
+
+    let response: proto_lightpush_v3.LightpushResponse | undefined;
+    try {
+      response = proto_lightpush_v3.LightpushResponse.decode(bytes);
+    } catch (err) {
+      log.error("Failed to decode push response", err);
+      return {
+        success: null,
+        failure: {
+          error: ProtocolError.DECODE_FAILED,
+          peerId: peerId
+        }
+      };
+    }
+
+    if (!response) {
+      log.error("Remote peer fault: No response received");
+      return {
+        success: null,
+        failure: {
+          error: ProtocolError.NO_RESPONSE,
+          peerId: peerId
+        }
+      };
+    }
+
+    // Validate request ID matches (except for rate limiting responses)
+    if (response.requestId !== query.query?.requestId) {
+      // nwaku sends "N/A" for rate limiting responses
+      if (response.statusCode !== LightPushStatusCodeV3.TOO_MANY_REQUESTS) {
+        log.error("Request ID mismatch", {
+          sent: query.query?.requestId,
+          received: response.requestId
+        });
+        return {
+          success: null,
+          failure: {
+            error: ProtocolError.GENERIC_FAIL,
+            peerId: peerId
+          }
+        };
+      }
+    }
+
+    const statusCode = response.statusCode;
+    const isSuccess = isSuccessStatusCodeV3(statusCode);
+
+    // Special handling for nwaku rate limiting
+    if (statusCode === LightPushStatusCodeV3.TOO_MANY_REQUESTS) {
+      if (response.requestId === "N/A") {
+        log.warn("Rate limited by nwaku node", {
+          statusDesc:
+            response.statusDesc || "Request rejected due to too many requests"
+        });
+      }
+    }
+
+    if (response.relayPeerCount !== undefined) {
+      log.info(`Message relayed to ${response.relayPeerCount} peers`);
+    }
+
+    if (response.statusDesc && isRLNResponseError(response.statusDesc)) {
+      log.error("Remote peer fault: RLN generation");
+      return {
+        success: null,
+        failure: {
+          error: ProtocolError.RLN_PROOF_GENERATION,
+          peerId: peerId
+        }
+      };
+    }
+
+    if (!isSuccess) {
+      const errorMessage = getLightPushStatusDescriptionV3(
+        statusCode,
+        response.statusDesc
+      );
+      log.error("Remote peer rejected the message: ", errorMessage);
+
+      const protocolError = lightPushStatusCodeToProtocolErrorV3(statusCode);
+      return {
+        success: null,
+        failure: {
+          error: protocolError,
+          peerId: peerId
+        }
+      };
+    }
+
+    return { success: peerId, failure: null };
+  }
+}

package/src/lib/light_push/push_rpc.ts

@@ -7,7 +7,7 @@ export class PushRpc {
 
   public static createRequest(
     message: proto.WakuMessage,
-    pubsubTopic: string
+    pubsubTopic?: string
   ): PushRpc {
     return new PushRpc({
       requestId: uuid(),

package/src/lib/light_push/push_rpc_v2.ts

@@ -0,0 +1,38 @@
+import { proto_lightpush_v2 as proto } from "@waku/proto";
+import type { Uint8ArrayList } from "uint8arraylist";
+import { v4 as uuid } from "uuid";
+
+export class PushRpcV2 {
+  public constructor(public proto: proto.PushRpc) {}
+
+  public static createRequest(
+    message: proto.WakuMessage,
+    pubsubTopic: string
+  ): PushRpcV2 {
+    return new PushRpcV2({
+      requestId: uuid(),
+      request: {
+        message: message,
+        pubsubTopic: pubsubTopic
+      },
+      response: undefined
+    });
+  }
+
+  public static decode(bytes: Uint8ArrayList): PushRpcV2 {
+    const res = proto.PushRpc.decode(bytes);
+    return new PushRpcV2(res);
+  }
+
+  public encode(): Uint8Array {
+    return proto.PushRpc.encode(this.proto);
+  }
+
+  public get query(): proto.PushRequest | undefined {
+    return this.proto.request;
+  }
+
+  public get response(): proto.PushResponse | undefined {
+    return this.proto.response;
+  }
+}

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,80 @@
+import { LightPushStatusCodeV3, ProtocolError } from "@waku/interfaces";
+
+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 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/light_push/utils.ts

@@ -1,3 +1,5 @@
+import { ProtocolError } from "@waku/interfaces";
+
 // should match nwaku
 // https://github.com/waku-org/nwaku/blob/c3cb06ac6c03f0f382d3941ea53b330f6a8dd127/waku/waku_rln_relay/rln_relay.nim#L309
 // https://github.com/waku-org/nwaku/blob/c3cb06ac6c03f0f382d3941ea53b330f6a8dd127/tests/waku_rln_relay/rln/waku_rln_relay_utils.nim#L20
@@ -21,3 +23,58 @@ export const isRLNResponseError = (info?: string): boolean => {
     info.includes(RLN_REMOTE_VALIDATION)
   );
 };
+
+/**
+ * Maps error information from push response to appropriate ProtocolError
+ * Uses pattern matching to handle various error cases
+ */
+export function mapInfoToProtocolError(info?: string): ProtocolError {
+  if (!info) {
+    return ProtocolError.REMOTE_PEER_REJECTED;
+  }
+
+  const lowerInfo = info.toLowerCase();
+
+  // RLN errors
+  if (isRLNResponseError(info)) {
+    return ProtocolError.RLN_PROOF_GENERATION;
+  }
+
+  // Rate limiting patterns
+  if (
+    lowerInfo.includes("rate limit") ||
+    lowerInfo.includes("too many requests")
+  ) {
+    return ProtocolError.REMOTE_PEER_REJECTED;
+  }
+
+  // Topic errors
+  if (
+    lowerInfo.includes("topic") &&
+    (lowerInfo.includes("not found") || lowerInfo.includes("not configured"))
+  ) {
+    return ProtocolError.TOPIC_NOT_CONFIGURED;
+  }
+
+  // Size errors
+  if (lowerInfo.includes("too large") || lowerInfo.includes("size")) {
+    return ProtocolError.SIZE_TOO_BIG;
+  }
+
+  // Decoding errors
+  if (
+    lowerInfo.includes("decode") ||
+    lowerInfo.includes("invalid") ||
+    lowerInfo.includes("malformed")
+  ) {
+    return ProtocolError.DECODE_FAILED;
+  }
+
+  // Empty payload
+  if (lowerInfo.includes("empty") && lowerInfo.includes("payload")) {
+    return ProtocolError.EMPTY_PAYLOAD;
+  }
+
+  // Default case
+  return ProtocolError.REMOTE_PEER_REJECTED;
+}