@waku/core 0.0.39-9684e7b.0 → 0.0.39-c0ee9ec.0

package/src/lib/light_push/light_push.ts

@@ -1,14 +1,12 @@
-import type { PeerId } from "@libp2p/interface";
+import type { PeerId, Stream } from "@libp2p/interface";
 import {
-  type CoreProtocolResult,
   type IEncoder,
   type IMessage,
   type Libp2p,
-  ProtocolError,
-  type ThisOrThat
+  type LightPushCoreResult,
+  LightPushError
 } from "@waku/interfaces";
 import { PushResponse } 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";
@@ -17,170 +15,125 @@ import { Uint8ArrayList } from "uint8arraylist";
 
 import { StreamManager } from "../stream_manager/index.js";
 
-import { PushRpc } from "./push_rpc.js";
-import { isRLNResponseError } from "./utils.js";
+import { CODECS, ProtocolHandler } from "./protocol_handler.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 LightPushCodec = CODECS.v3;
+export const LightPushCodecV2 = CODECS.v2;
 
 /**
  * Implements the [Waku v2 Light Push protocol](https://rfc.vac.dev/spec/19/).
  */
 export class LightPushCore {
   private readonly streamManager: StreamManager;
-
-  public readonly multicodec = LightPushCodec;
-
-  public constructor(libp2p: Libp2p) {
-    this.streamManager = new StreamManager(LightPushCodec, libp2p.components);
-  }
-
-  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 = PushRpc.createRequest(protoMessage, encoder.pubsubTopic);
-      return { query, error: null };
-    } catch (error) {
-      log.error("Failed to prepare push message", error);
-
-      return {
-        query: null,
-        error: ProtocolError.GENERIC_FAIL
-      };
-    }
+  private readonly streamManagerV2: StreamManager;
+  public readonly multicodec = [CODECS.v3, CODECS.v2];
+
+  public constructor(
+    private libp2p: Libp2p,
+    legacy?: boolean
+  ) {
+    this.streamManagerV2 = new StreamManager(CODECS.v2, libp2p.components);
+    this.streamManager = legacy
+      ? this.streamManagerV2
+      : new StreamManager(CODECS.v3, libp2p.components);
   }
 
   public async send(
     encoder: IEncoder,
     message: IMessage,
     peerId: PeerId
-  ): Promise<CoreProtocolResult> {
-    const { query, error: preparationError } = await this.preparePushMessage(
-      encoder,
-      message
-    );
+  ): Promise<LightPushCoreResult> {
+    let stream: Stream | undefined;
+    let protocol: string;
 
-    if (preparationError || !query) {
+    try {
+      const peer = await this.libp2p.peerStore.get(peerId);
+
+      if (
+        this.streamManager.multicodec === CODECS.v3 &&
+        peer.protocols.includes(CODECS.v3)
+      ) {
+        stream = await this.streamManager.getStream(peerId);
+        protocol = CODECS.v3;
+      } else {
+        stream = await this.streamManagerV2.getStream(peerId);
+        protocol = CODECS.v2;
+      }
+    } catch (error) {
+      log.error("Failed to get stream", error);
       return {
         success: null,
         failure: {
-          error: preparationError,
+          error: LightPushError.GENERIC_FAIL,
           peerId
         }
       };
     }
 
-    const stream = await this.streamManager.getStream(peerId);
-
     if (!stream) {
       log.error(`Failed to get a stream for remote peer:${peerId.toString()}`);
       return {
         success: null,
         failure: {
-          error: ProtocolError.NO_STREAM_AVAILABLE,
+          error: LightPushError.NO_STREAM_AVAILABLE,
           peerId: peerId
         }
       };
     }
 
+    const { rpc, error: prepError } = await ProtocolHandler.preparePushMessage(
+      encoder,
+      message,
+      protocol
+    );
+
+    if (prepError || !rpc) {
+      return {
+        success: null,
+        failure: {
+          error: prepError ?? LightPushError.GENERIC_FAIL,
+          peerId
+        }
+      };
+    }
+
     let res: Uint8ArrayList[] | undefined;
     try {
       res = await pipe(
-        [query.encode()],
+        [rpc.encode()],
         lp.encode,
         stream,
         lp.decode,
         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,
         failure: {
-          error: ProtocolError.STREAM_ABORTED,
+          error: LightPushError.STREAM_ABORTED,
           peerId: peerId
         }
       };
     }
 
     const bytes = new Uint8ArrayList();
-    res.forEach((chunk) => {
-      bytes.append(chunk);
-    });
-
-    let response: PushResponse | undefined;
-    try {
-      response = PushRpc.decode(bytes).response;
-    } catch (err) {
-      log.error("Failed to decode push reply", err);
-      return {
-        success: null,
-        failure: {
-          error: ProtocolError.DECODE_FAILED,
-          peerId: peerId
-        }
-      };
-    }
-
-    if (!response) {
-      log.error("Remote peer fault: No response in PushRPC");
-      return {
-        success: null,
-        failure: {
-          error: ProtocolError.NO_RESPONSE,
-          peerId: peerId
-        }
-      };
-    }
-
-    if (isRLNResponseError(response.info)) {
-      log.error("Remote peer fault: RLN generation");
-      return {
-        success: null,
-        failure: {
-          error: ProtocolError.RLN_PROOF_GENERATION,
-          peerId: peerId
-        }
-      };
-    }
+    res.forEach((chunk) => bytes.append(chunk));
 
-    if (!response.isSuccess) {
-      log.error("Remote peer rejected the message: ", response.info);
+    if (bytes.length === 0) {
       return {
         success: null,
         failure: {
-          error: ProtocolError.REMOTE_PEER_REJECTED,
+          error: LightPushError.NO_RESPONSE,
           peerId: peerId
         }
       };
     }
 
-    return { success: peerId, failure: null };
+    return ProtocolHandler.handleResponse(bytes, protocol, peerId);
   }
 }

package/src/lib/light_push/protocol_handler.ts

@@ -0,0 +1,192 @@
+import type { PeerId } from "@libp2p/interface";
+import type { IEncoder, IMessage, LightPushCoreResult } from "@waku/interfaces";
+import { LightPushError, LightPushStatusCode } from "@waku/interfaces";
+import { WakuMessage } from "@waku/proto";
+import { isMessageSizeUnderCap, Logger } from "@waku/utils";
+import { Uint8ArrayList } from "uint8arraylist";
+
+import { PushRpcV2 } from "./push_rpc.js";
+import { PushRpc } from "./push_rpc_v3.js";
+import { isRLNResponseError } from "./utils.js";
+
+export type VersionedPushRpc =
+  | ({ version: "v2" } & PushRpcV2)
+  | ({ version: "v3" } & PushRpc);
+
+export const CODECS = {
+  v2: "/vac/waku/lightpush/2.0.0-beta1",
+  v3: "/vac/waku/lightpush/3.0.0"
+} as const;
+
+const log = new Logger("light-push:protocol-handler");
+
+export class ProtocolHandler {
+  public static async preparePushMessage(
+    encoder: IEncoder,
+    message: IMessage,
+    protocol: string
+  ): Promise<{ rpc: VersionedPushRpc | null; error: LightPushError | null }> {
+    try {
+      if (!message.payload || message.payload.length === 0) {
+        log.error("Failed to send waku light push: payload is empty");
+        return { rpc: null, error: LightPushError.EMPTY_PAYLOAD };
+      }
+
+      if (!(await isMessageSizeUnderCap(encoder, message))) {
+        log.error("Failed to send waku light push: message is bigger than 1MB");
+        return { rpc: null, error: LightPushError.SIZE_TOO_BIG };
+      }
+
+      const protoMessage = await encoder.toProtoObj(message);
+      if (!protoMessage) {
+        log.error("Failed to encode to protoMessage, aborting push");
+        return { rpc: null, error: LightPushError.ENCODE_FAILED };
+      }
+
+      // Select version implementation
+      if (protocol === CODECS.v3) {
+        log.info("Creating v3 RPC message");
+        return {
+          rpc: createV3Rpc(protoMessage, encoder.pubsubTopic),
+          error: null
+        };
+      }
+
+      // Default to v2
+      log.info("Creating v2 RPC message");
+      return {
+        rpc: createV2Rpc(protoMessage, encoder.pubsubTopic),
+        error: null
+      };
+    } catch (err) {
+      log.error("Failed to prepare push message", err);
+      return { rpc: null, error: LightPushError.GENERIC_FAIL };
+    }
+  }
+
+  /**
+   * Decode and evaluate a LightPush response according to the protocol version
+   */
+  public static handleResponse(
+    bytes: Uint8ArrayList,
+    protocol: string,
+    peerId: PeerId
+  ): LightPushCoreResult {
+    if (protocol === CODECS.v3) {
+      return ProtocolHandler.handleV3Response(bytes, peerId);
+    }
+    return ProtocolHandler.handleV2Response(bytes, peerId);
+  }
+
+  private static handleV3Response(
+    bytes: Uint8ArrayList,
+    peerId: PeerId
+  ): LightPushCoreResult {
+    try {
+      const decodedRpcV3 = PushRpc.decodeResponse(bytes);
+      const statusCode = decodedRpcV3.statusCode;
+      const statusDesc = decodedRpcV3.statusDesc;
+
+      if (statusCode !== LightPushStatusCode.SUCCESS) {
+        const error = LightPushError.REMOTE_PEER_REJECTED;
+        log.error(
+          `Remote peer rejected with v3 status code ${statusCode}: ${statusDesc}`
+        );
+        return {
+          success: null,
+          failure: {
+            error,
+            peerId: peerId
+          }
+        };
+      }
+
+      if (decodedRpcV3.relayPeerCount !== undefined) {
+        log.info(`Message relayed to ${decodedRpcV3.relayPeerCount} peers`);
+      }
+
+      return { success: peerId, failure: null };
+    } catch (err) {
+      return {
+        success: null,
+        failure: {
+          error: LightPushError.DECODE_FAILED,
+          peerId: peerId
+        }
+      };
+    }
+  }
+
+  private static handleV2Response(
+    bytes: Uint8ArrayList,
+    peerId: PeerId
+  ): LightPushCoreResult {
+    let response: import("@waku/proto").PushResponse | undefined;
+    try {
+      const decodedRpc = PushRpcV2.decode(bytes);
+      response = decodedRpc.response;
+    } catch (err) {
+      return {
+        success: null,
+        failure: {
+          error: LightPushError.DECODE_FAILED,
+          peerId: peerId
+        }
+      };
+    }
+
+    if (!response) {
+      return {
+        success: null,
+        failure: {
+          error: LightPushError.NO_RESPONSE,
+          peerId: peerId
+        }
+      };
+    }
+
+    if (isRLNResponseError(response.info)) {
+      log.error("Remote peer fault: RLN generation");
+      return {
+        success: null,
+        failure: {
+          error: LightPushError.RLN_PROOF_GENERATION,
+          peerId: peerId
+        }
+      };
+    }
+
+    if (!response.isSuccess) {
+      log.error("Remote peer rejected the message: ", response.info);
+      return {
+        success: null,
+        failure: {
+          error: LightPushError.REMOTE_PEER_REJECTED,
+          peerId: peerId
+        }
+      };
+    }
+
+    return { success: peerId, failure: null };
+  }
+}
+
+function createV2Rpc(
+  message: WakuMessage,
+  pubsubTopic: string
+): VersionedPushRpc {
+  const v2Rpc = PushRpcV2.createRequest(message, pubsubTopic);
+  return Object.assign(v2Rpc, { version: "v2" as const });
+}
+
+function createV3Rpc(
+  message: WakuMessage,
+  pubsubTopic: string
+): VersionedPushRpc {
+  if (!message.timestamp) {
+    message.timestamp = BigInt(Date.now()) * BigInt(1_000_000);
+  }
+
+  const v3Rpc = PushRpc.createRequest(message, pubsubTopic);
+  return Object.assign(v3Rpc, { version: "v3" as const });
+}

package/src/lib/light_push/push_rpc.ts

@@ -2,14 +2,14 @@ import { proto_lightpush as proto } from "@waku/proto";
 import type { Uint8ArrayList } from "uint8arraylist";
 import { v4 as uuid } from "uuid";
 
-export class PushRpc {
+export class PushRpcV2 {
   public constructor(public proto: proto.PushRpc) {}
 
   public static createRequest(
     message: proto.WakuMessage,
     pubsubTopic: string
-  ): PushRpc {
-    return new PushRpc({
+  ): PushRpcV2 {
+    return new PushRpcV2({
       requestId: uuid(),
       request: {
         message: message,
@@ -19,9 +19,9 @@ export class PushRpc {
     });
   }
 
-  public static decode(bytes: Uint8ArrayList): PushRpc {
+  public static decode(bytes: Uint8ArrayList): PushRpcV2 {
     const res = proto.PushRpc.decode(bytes);
-    return new PushRpc(res);
+    return new PushRpcV2(res);
   }
 
   public encode(): Uint8Array {

package/src/lib/light_push/push_rpc_v3.ts

@@ -0,0 +1,162 @@
+import { proto_lightpush as proto } from "@waku/proto";
+import type { Uint8ArrayList } from "uint8arraylist";
+import { v4 as uuid } from "uuid";
+
+/**
+ * LightPush v3 protocol RPC handler.
+ * Implements the v3 message format with correct field numbers:
+ * - requestId: 1
+ * - pubsubTopic: 20
+ * - message: 21
+ */
+export class PushRpc {
+  public constructor(
+    public proto: proto.LightPushRequestV3 | proto.LightPushResponseV3
+  ) {}
+
+  /**
+   * Create a v3 request message with proper field numbering
+   */
+  public static createRequest(
+    message: proto.WakuMessage,
+    pubsubTopic: string
+  ): PushRpc {
+    return new PushRpc({
+      requestId: uuid(),
+      pubsubTopic: pubsubTopic,
+      message: message
+    });
+  }
+
+  /**
+   * Create a v3 response message with status code handling
+   */
+  public static createResponse(
+    requestId: string,
+    statusCode: number,
+    statusDesc?: string,
+    relayPeerCount?: number
+  ): PushRpc {
+    return new PushRpc({
+      requestId,
+      statusCode,
+      statusDesc,
+      relayPeerCount
+    });
+  }
+
+  /**
+   * Decode v3 request message
+   */
+  public static decodeRequest(bytes: Uint8ArrayList): PushRpc {
+    const res = proto.LightPushRequestV3.decode(bytes);
+    return new PushRpc(res);
+  }
+
+  /**
+   * Decode v3 response message
+   */
+  public static decodeResponse(bytes: Uint8ArrayList): PushRpc {
+    const res = proto.LightPushResponseV3.decode(bytes);
+    return new PushRpc(res);
+  }
+
+  /**
+   * Encode message to bytes
+   */
+  public encode(): Uint8Array {
+    if (this.isRequest()) {
+      return proto.LightPushRequestV3.encode(
+        this.proto as proto.LightPushRequestV3
+      );
+    } else {
+      return proto.LightPushResponseV3.encode(
+        this.proto as proto.LightPushResponseV3
+      );
+    }
+  }
+
+  /**
+   * Get request data (if this is a request message)
+   */
+  public get request(): proto.LightPushRequestV3 | undefined {
+    return this.isRequest()
+      ? (this.proto as proto.LightPushRequestV3)
+      : undefined;
+  }
+
+  /**
+   * Get response data (if this is a response message)
+   */
+  public get response(): proto.LightPushResponseV3 | undefined {
+    return this.isResponse()
+      ? (this.proto as proto.LightPushResponseV3)
+      : undefined;
+  }
+
+  /**
+   * Get the request ID
+   */
+  public get requestId(): string {
+    return this.proto.requestId;
+  }
+
+  /**
+   * Get the pubsub topic (only available in requests)
+   */
+  public get pubsubTopic(): string | undefined {
+    return this.isRequest()
+      ? (this.proto as proto.LightPushRequestV3).pubsubTopic
+      : undefined;
+  }
+
+  /**
+   * Get the message (only available in requests)
+   */
+  public get message(): proto.WakuMessage | undefined {
+    return this.isRequest()
+      ? (this.proto as proto.LightPushRequestV3).message
+      : undefined;
+  }
+
+  /**
+   * Get the status code (only available in responses)
+   */
+  public get statusCode(): number | undefined {
+    return this.isResponse()
+      ? (this.proto as proto.LightPushResponseV3).statusCode
+      : undefined;
+  }
+
+  /**
+   * Get the status description (only available in responses)
+   */
+  public get statusDesc(): string | undefined {
+    return this.isResponse()
+      ? (this.proto as proto.LightPushResponseV3).statusDesc
+      : undefined;
+  }
+
+  /**
+   * Get the relay peer count (only available in responses)
+   */
+  public get relayPeerCount(): number | undefined {
+    return this.isResponse()
+      ? (this.proto as proto.LightPushResponseV3).relayPeerCount
+      : undefined;
+  }
+
+  /**
+   * Check if this is a request message
+   */
+  private isRequest(): boolean {
+    return "pubsubTopic" in this.proto && "message" in this.proto;
+  }
+
+  /**
+   * Check if this is a response message
+   */
+  private isResponse(): boolean {
+    return "statusCode" in this.proto;
+  }
+}

package/src/lib/metadata/metadata.ts

@@ -27,7 +27,7 @@ class Metadata implements IMetadata {
   private readonly libp2pComponents: Libp2pComponents;
   protected handshakesConfirmed: Map<PeerIdStr, ShardInfo> = new Map();
 
-  public readonly multicodec = MetadataCodec;
+  public readonly multicodec = [MetadataCodec];
 
   public constructor(
     public clusterId: ClusterId,

package/src/lib/store/store.ts

@@ -29,7 +29,7 @@ export const StoreCodec = "/vac/waku/store-query/3.0.0";
 export class StoreCore {
   private readonly streamManager: StreamManager;
 
-  public readonly multicodec = StoreCodec;
+  public readonly multicodec = [StoreCodec];
 
   public constructor(libp2p: Libp2p) {
     this.streamManager = new StreamManager(StoreCodec, libp2p.components);

package/src/lib/stream_manager/stream_manager.ts

@@ -13,7 +13,7 @@ export class StreamManager {
   private streamPool: Map<string, Promise<void>> = new Map();
 
   public constructor(
-    private multicodec: string,
+    public multicodec: string,
     private readonly libp2p: Libp2pComponents
   ) {
     this.log = new Logger(`stream-manager:${multicodec}`);