@waku/core 0.0.30-e49e728.0 → 0.0.31-04bd518.0

package/src/lib/message/version_0.ts

@@ -20,28 +20,28 @@ export const Version = 0;
 export { proto };
 
 export class DecodedMessage implements IDecodedMessage {
-  constructor(
+  public constructor(
     public pubsubTopic: string,
     protected proto: proto.WakuMessage
   ) {}
 
-  get ephemeral(): boolean {
+  public get ephemeral(): boolean {
     return Boolean(this.proto.ephemeral);
   }
 
-  get payload(): Uint8Array {
+  public get payload(): Uint8Array {
     return this.proto.payload;
   }
 
-  get contentTopic(): string {
+  public get contentTopic(): string {
     return this.proto.contentTopic;
   }
 
-  get _rawTimestamp(): bigint | undefined {
+  public get _rawTimestamp(): bigint | undefined {
     return this.proto.timestamp;
   }
 
-  get timestamp(): Date | undefined {
+  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.
     try {
@@ -56,23 +56,23 @@ export class DecodedMessage implements IDecodedMessage {
     }
   }
 
-  get meta(): Uint8Array | undefined {
+  public get meta(): Uint8Array | undefined {
     return this.proto.meta;
   }
 
-  get version(): number {
+  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;
   }
 
-  get rateLimitProof(): IRateLimitProof | undefined {
+  public get rateLimitProof(): IRateLimitProof | undefined {
     return this.proto.rateLimitProof;
   }
 }
 
 export class Encoder implements IEncoder {
-  constructor(
+  public constructor(
     public contentTopic: string,
     public ephemeral: boolean = false,
     public pubsubTopic: PubsubTopic,
@@ -83,11 +83,11 @@ export class Encoder implements IEncoder {
     }
   }
 
-  async toWire(message: IMessage): Promise<Uint8Array> {
+  public async toWire(message: IMessage): Promise<Uint8Array> {
     return proto.WakuMessage.encode(await this.toProtoObj(message));
   }
 
-  async toProtoObj(message: IMessage): Promise<IProtoMessage> {
+  public async toProtoObj(message: IMessage): Promise<IProtoMessage> {
     const timestamp = message.timestamp ?? new Date();
 
     const protoMessage = {
@@ -133,7 +133,7 @@ export function createEncoder({
 }
 
 export class Decoder implements IDecoder<DecodedMessage> {
-  constructor(
+  public constructor(
     public pubsubTopic: PubsubTopic,
     public contentTopic: string
   ) {
@@ -142,7 +142,9 @@ export class Decoder implements IDecoder<DecodedMessage> {
     }
   }
 
-  fromWireToProtoObj(bytes: Uint8Array): Promise<IProtoMessage | undefined> {
+  public fromWireToProtoObj(
+    bytes: Uint8Array
+  ): Promise<IProtoMessage | undefined> {
     const protoMessage = proto.WakuMessage.decode(bytes);
     return Promise.resolve({
       payload: protoMessage.payload,
@@ -155,7 +157,7 @@ export class Decoder implements IDecoder<DecodedMessage> {
     });
   }
 
-  async fromProtoObj(
+  public async fromProtoObj(
     pubsubTopic: string,
     proto: IProtoMessage
   ): Promise<DecodedMessage | undefined> {

package/src/lib/metadata/index.ts

@@ -23,9 +23,9 @@ export const MetadataCodec = "/vac/waku/metadata/1.0.0";
 
 class Metadata extends BaseProtocol implements IMetadata {
   private libp2pComponents: Libp2pComponents;
-  handshakesConfirmed: Map<PeerIdStr, ShardInfo> = new Map();
+  protected handshakesConfirmed: Map<PeerIdStr, ShardInfo> = new Map();
 
-  constructor(
+  public constructor(
     public shardInfo: ShardInfo,
     libp2p: Libp2pComponents
   ) {
@@ -41,40 +41,10 @@ class Metadata extends BaseProtocol implements IMetadata {
     });
   }
 
-  /**
-   * Handle an incoming metadata request
-   */
-  private async onRequest(streamData: IncomingStreamData): Promise<void> {
-    try {
-      const { stream, connection } = streamData;
-      const encodedShardInfo = proto_metadata.WakuMetadataResponse.encode(
-        this.shardInfo
-      );
-
-      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);
-    }
-  }
-
   /**
    * Make a metadata query to a peer
    */
-  async query(peerId: PeerId): Promise<MetadataQueryResult> {
+  public async query(peerId: PeerId): Promise<MetadataQueryResult> {
     const request = proto_metadata.WakuMetadataRequest.encode(this.shardInfo);
 
     const peer = await this.peerStore.get(peerId);
@@ -135,6 +105,36 @@ class Metadata extends BaseProtocol implements IMetadata {
     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(
+        this.shardInfo
+      );
+
+      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 {

package/src/lib/store/history_rpc.ts

@@ -22,18 +22,18 @@ export interface Params {
 export class HistoryRpc {
   private constructor(public readonly proto: proto.HistoryRpc) {}
 
-  get query(): proto.HistoryQuery | undefined {
+  public get query(): proto.HistoryQuery | undefined {
     return this.proto.query;
   }
 
-  get response(): proto.HistoryResponse | undefined {
+  public get response(): proto.HistoryResponse | undefined {
     return this.proto.response;
   }
 
   /**
    * Create History Query.
    */
-  static createQuery(params: Params): HistoryRpc {
+  public static createQuery(params: Params): HistoryRpc {
     const contentFilters = params.contentTopics.map((contentTopic) => {
       return { contentTopic };
     });
@@ -69,12 +69,12 @@ export class HistoryRpc {
     });
   }
 
-  decode(bytes: Uint8ArrayList): HistoryRpc {
+  public decode(bytes: Uint8ArrayList): HistoryRpc {
     const res = proto.HistoryRpc.decode(bytes);
     return new HistoryRpc(res);
   }
 
-  encode(): Uint8Array {
+  public encode(): Uint8Array {
     return proto.HistoryRpc.encode(this.proto);
   }
 }

package/src/lib/store/index.ts

@@ -68,11 +68,11 @@ export interface QueryOptions {
  * The Waku Store protocol can be used to retrieved historical messages.
  */
 export class StoreCore extends BaseProtocol implements IStoreCore {
-  constructor(libp2p: Libp2p, options?: ProtocolCreateOptions) {
+  public constructor(libp2p: Libp2p, options?: ProtocolCreateOptions) {
     super(StoreCodec, libp2p.components, log, options!.pubsubTopics!, options);
   }
 
-  async *queryPerPage<T extends IDecodedMessage>(
+  public async *queryPerPage<T extends IDecodedMessage>(
     queryOpts: Params,
     decoders: Map<string, IDecoder<T>>,
     peer: Peer

package/src/lib/stream_manager/index.ts

@@ -0,0 +1 @@
+export { StreamManager } from "./stream_manager.js";

package/src/lib/{stream_manager.ts → stream_manager/stream_manager.ts}

@@ -2,7 +2,8 @@ import type { PeerUpdate, Stream } from "@libp2p/interface";
 import type { Peer, PeerId } from "@libp2p/interface";
 import { Libp2p } from "@waku/interfaces";
 import { Logger } from "@waku/utils";
-import { selectConnection } from "@waku/utils/libp2p";
+
+import { selectConnection } from "./utils.js";
 
 const CONNECTION_TIMEOUT = 5_000;
 const RETRY_BACKOFF_BASE = 1_000;
@@ -12,7 +13,7 @@ export class StreamManager {
   private readonly streamPool: Map<string, Promise<Stream | void>>;
   private readonly log: Logger;
 
-  constructor(
+  public constructor(
     public multicodec: string,
     public getConnections: Libp2p["getConnections"],
     public addEventListener: Libp2p["addEventListener"]

package/src/lib/stream_manager/utils.ts

@@ -0,0 +1,22 @@
+import type { Connection } from "@libp2p/interface";
+
+export function selectConnection(
+  connections: Connection[]
+): Connection | undefined {
+  if (!connections.length) return;
+  if (connections.length === 1) return connections[0];
+
+  let latestConnection: Connection | undefined;
+
+  connections.forEach((connection) => {
+    if (connection.status === "open") {
+      if (!latestConnection) {
+        latestConnection = connection;
+      } else if (connection.timeline.open > latestConnection.timeline.open) {
+        latestConnection = connection;
+      }
+    }
+  });
+
+  return latestConnection;
+}