@waku/core 0.0.34-c41b319.0 → 0.0.34-c43cec2.0

package/src/lib/filter/filter.ts

@@ -1,315 +0,0 @@
-import type { PeerId, Stream } from "@libp2p/interface";
-import type { IncomingStreamData } from "@libp2p/interface-internal";
-import {
-  type ContentTopic,
-  type CoreProtocolResult,
-  type IBaseProtocolCore,
-  type Libp2p,
-  ProtocolError,
-  type PubsubTopic
-} from "@waku/interfaces";
-import { WakuMessage } from "@waku/proto";
-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 {
-  FilterPushRpc,
-  FilterSubscribeResponse,
-  FilterSubscribeRpc
-} from "./filter_rpc.js";
-
-const log = new Logger("filter:v2");
-
-export const FilterCodecs = {
-  SUBSCRIBE: "/vac/waku/filter-subscribe/2.0.0-beta1",
-  PUSH: "/vac/waku/filter-push/2.0.0-beta1"
-};
-
-export class FilterCore extends BaseProtocol implements IBaseProtocolCore {
-  public constructor(
-    private handleIncomingMessage: (
-      pubsubTopic: PubsubTopic,
-      wakuMessage: WakuMessage,
-      peerIdStr: string
-    ) => Promise<void>,
-    public readonly pubsubTopics: PubsubTopic[],
-    libp2p: Libp2p
-  ) {
-    super(FilterCodecs.SUBSCRIBE, libp2p.components, pubsubTopics);
-
-    libp2p
-      .handle(FilterCodecs.PUSH, this.onRequest.bind(this), {
-        maxInboundStreams: 100
-      })
-      .catch((e) => {
-        log.error("Failed to register ", FilterCodecs.PUSH, e);
-      });
-  }
-
-  public async subscribe(
-    pubsubTopic: PubsubTopic,
-    peerId: PeerId,
-    contentTopics: ContentTopic[]
-  ): Promise<CoreProtocolResult> {
-    const stream = await this.getStream(peerId);
-
-    const request = FilterSubscribeRpc.createSubscribeRequest(
-      pubsubTopic,
-      contentTopics
-    );
-
-    let res: Uint8ArrayList[] | undefined;
-    try {
-      res = await pipe(
-        [request.encode()],
-        lp.encode,
-        stream,
-        lp.decode,
-        async (source) => await all(source)
-      );
-    } catch (error) {
-      log.error("Failed to send subscribe request", error);
-      return {
-        success: null,
-        failure: {
-          error: ProtocolError.GENERIC_FAIL,
-          peerId: peerId
-        }
-      };
-    }
-
-    const { statusCode, requestId, statusDesc } =
-      FilterSubscribeResponse.decode(res[0].slice());
-
-    if (statusCode < 200 || statusCode >= 300) {
-      log.error(
-        `Filter subscribe request ${requestId} failed with status code ${statusCode}: ${statusDesc}`
-      );
-      return {
-        failure: {
-          error: ProtocolError.REMOTE_PEER_REJECTED,
-          peerId: peerId
-        },
-        success: null
-      };
-    }
-
-    return {
-      failure: null,
-      success: peerId
-    };
-  }
-
-  public async unsubscribe(
-    pubsubTopic: PubsubTopic,
-    peerId: PeerId,
-    contentTopics: ContentTopic[]
-  ): Promise<CoreProtocolResult> {
-    let stream: Stream | undefined;
-    try {
-      stream = await this.getStream(peerId);
-    } catch (error) {
-      log.error(
-        `Failed to get a stream for remote peer${peerId.toString()}`,
-        error
-      );
-      return {
-        success: null,
-        failure: {
-          error: ProtocolError.NO_STREAM_AVAILABLE,
-          peerId: peerId
-        }
-      };
-    }
-
-    const unsubscribeRequest = FilterSubscribeRpc.createUnsubscribeRequest(
-      pubsubTopic,
-      contentTopics
-    );
-
-    try {
-      await pipe([unsubscribeRequest.encode()], lp.encode, stream.sink);
-    } catch (error) {
-      log.error("Failed to send unsubscribe request", error);
-      return {
-        success: null,
-        failure: {
-          error: ProtocolError.GENERIC_FAIL,
-          peerId: peerId
-        }
-      };
-    }
-
-    return {
-      success: peerId,
-      failure: null
-    };
-  }
-
-  public async unsubscribeAll(
-    pubsubTopic: PubsubTopic,
-    peerId: PeerId
-  ): Promise<CoreProtocolResult> {
-    const stream = await this.getStream(peerId);
-
-    const request = FilterSubscribeRpc.createUnsubscribeAllRequest(pubsubTopic);
-
-    const res = await pipe(
-      [request.encode()],
-      lp.encode,
-      stream,
-      lp.decode,
-      async (source) => await all(source)
-    );
-
-    if (!res || !res.length) {
-      return {
-        failure: {
-          error: ProtocolError.NO_RESPONSE,
-          peerId: peerId
-        },
-        success: null
-      };
-    }
-
-    const { statusCode, requestId, statusDesc } =
-      FilterSubscribeResponse.decode(res[0].slice());
-
-    if (statusCode < 200 || statusCode >= 300) {
-      log.error(
-        `Filter unsubscribe all request ${requestId} failed with status code ${statusCode}: ${statusDesc}`
-      );
-      return {
-        failure: {
-          error: ProtocolError.REMOTE_PEER_REJECTED,
-          peerId: peerId
-        },
-        success: null
-      };
-    }
-
-    return {
-      failure: null,
-      success: peerId
-    };
-  }
-
-  public async ping(peerId: PeerId): Promise<CoreProtocolResult> {
-    let stream: Stream | undefined;
-    try {
-      stream = await this.getStream(peerId);
-    } catch (error) {
-      log.error(
-        `Failed to get a stream for remote peer${peerId.toString()}`,
-        error
-      );
-      return {
-        success: null,
-        failure: {
-          error: ProtocolError.NO_STREAM_AVAILABLE,
-          peerId: peerId
-        }
-      };
-    }
-
-    const request = FilterSubscribeRpc.createSubscriberPingRequest();
-
-    let res: Uint8ArrayList[] | undefined;
-    try {
-      res = await pipe(
-        [request.encode()],
-        lp.encode,
-        stream,
-        lp.decode,
-        async (source) => await all(source)
-      );
-    } catch (error) {
-      log.error("Failed to send ping request", error);
-      return {
-        success: null,
-        failure: {
-          error: ProtocolError.GENERIC_FAIL,
-          peerId: peerId
-        }
-      };
-    }
-
-    if (!res || !res.length) {
-      return {
-        success: null,
-        failure: {
-          error: ProtocolError.NO_RESPONSE,
-          peerId: peerId
-        }
-      };
-    }
-
-    const { statusCode, requestId, statusDesc } =
-      FilterSubscribeResponse.decode(res[0].slice());
-
-    if (statusCode < 200 || statusCode >= 300) {
-      log.error(
-        `Filter ping request ${requestId} failed with status code ${statusCode}: ${statusDesc}`
-      );
-      return {
-        success: null,
-        failure: {
-          error: ProtocolError.REMOTE_PEER_REJECTED,
-          peerId: peerId
-        }
-      };
-    }
-    return {
-      success: peerId,
-      failure: null
-    };
-  }
-
-  private onRequest(streamData: IncomingStreamData): void {
-    const { connection, stream } = streamData;
-    const { remotePeer } = connection;
-    log.info(`Received message from ${remotePeer.toString()}`);
-    try {
-      pipe(stream, lp.decode, async (source) => {
-        for await (const bytes of source) {
-          const response = FilterPushRpc.decode(bytes.slice());
-
-          const { pubsubTopic, wakuMessage } = response;
-
-          if (!wakuMessage) {
-            log.error("Received empty message");
-            return;
-          }
-
-          if (!pubsubTopic) {
-            log.error("Pubsub topic missing from push message");
-            return;
-          }
-
-          await this.handleIncomingMessage(
-            pubsubTopic,
-            wakuMessage,
-            connection.remotePeer.toString()
-          );
-        }
-      }).then(
-        () => {
-          log.info("Receiving pipe closed.");
-        },
-        async (e) => {
-          log.error(
-            `Error with receiving pipe on peer:${connection.remotePeer.toString()} -- stream:${stream.id} -- protocol:${stream.protocol}: `,
-            e
-          );
-        }
-      );
-    } catch (e) {
-      log.error("Error decoding message", e);
-    }
-  }
-}

package/src/lib/light_push/light_push.ts

@@ -1,188 +0,0 @@
-import type { PeerId, Stream } from "@libp2p/interface";
-import {
-  type CoreProtocolResult,
-  type IBaseProtocolCore,
-  type IEncoder,
-  type IMessage,
-  type Libp2p,
-  ProtocolError,
-  PubsubTopic,
-  type ThisOrThat
-} 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";
-import { pipe } from "it-pipe";
-import { Uint8ArrayList } from "uint8arraylist";
-
-import { BaseProtocol } from "../base_protocol.js";
-
-import { PushRpc } from "./push_rpc.js";
-import { isRLNResponseError, matchRLNErrorMessage } 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>;
-
-/**
- * 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[],
-    libp2p: Libp2p
-  ) {
-    super(LightPushCodec, 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 = 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
-      };
-    }
-  }
-
-  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.GENERIC_FAIL,
-          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)) {
-      const rlnErrorCase = matchRLNErrorMessage(response.info!);
-      log.error("Remote peer rejected the message: ", rlnErrorCase);
-      return {
-        success: null,
-        failure: {
-          error: rlnErrorCase,
-          peerId: peerId
-        }
-      };
-    }
-
-    if (!response.isSuccess) {
-      log.error("Remote peer rejected the message: ", response.info);
-      return {
-        success: null,
-        failure: {
-          error: ProtocolError.REMOTE_PEER_REJECTED,
-          peerId: peerId
-        }
-      };
-    }
-
-    return { success: peerId, failure: null };
-  }
-}

package/src/lib/metadata/metadata.ts

@@ -1,182 +0,0 @@
-import type { PeerId } from "@libp2p/interface";
-import { IncomingStreamData } from "@libp2p/interface";
-import {
-  type IMetadata,
-  type Libp2pComponents,
-  type MetadataQueryResult,
-  type PeerIdStr,
-  ProtocolError,
-  PubsubTopic,
-  type ShardInfo
-} from "@waku/interfaces";
-import { proto_metadata } from "@waku/proto";
-import { encodeRelayShard, Logger, pubsubTopicsToShardInfo } 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";
-
-const log = new Logger("metadata");
-
-export const MetadataCodec = "/vac/waku/metadata/1.0.0";
-
-class Metadata extends BaseProtocol implements IMetadata {
-  private libp2pComponents: Libp2pComponents;
-  protected handshakesConfirmed: Map<PeerIdStr, ShardInfo> = new Map();
-
-  public constructor(
-    public pubsubTopics: PubsubTopic[],
-    libp2p: Libp2pComponents
-  ) {
-    super(MetadataCodec, libp2p.components, pubsubTopics);
-    this.libp2pComponents = libp2p;
-    void libp2p.registrar.handle(MetadataCodec, (streamData) => {
-      void this.onRequest(streamData);
-    });
-  }
-
-  /**
-   * Make a metadata query to a peer
-   */
-  public async query(peerId: PeerId): Promise<MetadataQueryResult> {
-    const request = proto_metadata.WakuMetadataRequest.encode(
-      pubsubTopicsToShardInfo(this.pubsubTopics)
-    );
-
-    const peer = await this.libp2pComponents.peerStore.get(peerId);
-    if (!peer) {
-      return {
-        shardInfo: null,
-        error: ProtocolError.NO_PEER_AVAILABLE
-      };
-    }
-
-    let stream;
-    try {
-      stream = await this.getStream(peerId);
-    } catch (error) {
-      log.error("Failed to get stream", error);
-      return {
-        shardInfo: null,
-        error: ProtocolError.NO_STREAM_AVAILABLE
-      };
-    }
-
-    const encodedResponse = await pipe(
-      [request],
-      lp.encode,
-      stream,
-      lp.decode,
-      async (source) => await all(source)
-    );
-
-    const { error, shardInfo } = this.decodeMetadataResponse(encodedResponse);
-
-    if (error) {
-      return {
-        shardInfo: null,
-        error
-      };
-    }
-
-    await this.savePeerShardInfo(peerId, shardInfo);
-
-    return {
-      shardInfo,
-      error: null
-    };
-  }
-
-  public async confirmOrAttemptHandshake(
-    peerId: PeerId
-  ): Promise<MetadataQueryResult> {
-    const shardInfo = this.handshakesConfirmed.get(peerId.toString());
-    if (shardInfo) {
-      return {
-        shardInfo,
-        error: null
-      };
-    }
-
-    return await this.query(peerId);
-  }
-
-  /**
-   * Handle an incoming metadata request
-   */
-  private async onRequest(streamData: IncomingStreamData): Promise<void> {
-    try {
-      const { stream, connection } = streamData;
-      const encodedShardInfo = proto_metadata.WakuMetadataResponse.encode(
-        pubsubTopicsToShardInfo(this.pubsubTopics)
-      );
-
-      const encodedResponse = await pipe(
-        [encodedShardInfo],
-        lp.encode,
-        stream,
-        lp.decode,
-        async (source) => await all(source)
-      );
-
-      const { error, shardInfo } = this.decodeMetadataResponse(encodedResponse);
-
-      if (error) {
-        return;
-      }
-
-      await this.savePeerShardInfo(connection.remotePeer, shardInfo);
-    } catch (error) {
-      log.error("Error handling metadata request", error);
-    }
-  }
-
-  private decodeMetadataResponse(
-    encodedResponse: Uint8ArrayList[]
-  ): MetadataQueryResult {
-    const bytes = new Uint8ArrayList();
-
-    encodedResponse.forEach((chunk) => {
-      bytes.append(chunk);
-    });
-    const response = proto_metadata.WakuMetadataResponse.decode(
-      bytes
-    ) as ShardInfo;
-
-    if (!response) {
-      log.error("Error decoding metadata response");
-      return {
-        shardInfo: null,
-        error: ProtocolError.DECODE_FAILED
-      };
-    }
-
-    return {
-      shardInfo: response,
-      error: null
-    };
-  }
-
-  private async savePeerShardInfo(
-    peerId: PeerId,
-    shardInfo: ShardInfo
-  ): Promise<void> {
-    // add or update the shardInfo to peer store
-    await this.libp2pComponents.peerStore.merge(peerId, {
-      metadata: {
-        shardInfo: encodeRelayShard(shardInfo)
-      }
-    });
-
-    this.handshakesConfirmed.set(peerId.toString(), shardInfo);
-  }
-}
-
-export function wakuMetadata(
-  pubsubTopics: PubsubTopic[]
-): (components: Libp2pComponents) => IMetadata {
-  return (components: Libp2pComponents) =>
-    new Metadata(pubsubTopics, components);
-}