Class WakuNode

constructor

• new WakuNode(
      options: CreateNodeOptions,
      libp2p: Libp2p,
      protocolsEnabled: ProtocolsEnabled,
      relay?: IRelay,
  ): WakuNode

  Parameters

  • options: CreateNodeOptions
  • libp2p: Libp2p
  • protocolsEnabled: ProtocolsEnabled
  • Optionalrelay: IRelay

  Returns WakuNode

Readonlyevents

waku.events.addEventListener(WakuEvent.Connection, (event) => {
  console.log(event.detail); // true if connected, false if disconnected
});
Copy

Optionalfilter

libp2p

OptionallightPush

Optionalrelay

Optionalstore

health

• get health(): HealthStatus

  The health status can be one of three states:

  • Unhealthy: No peer connections
  • MinimallyHealthy: At least 1 peer supporting both Filter and LightPush protocols
  • SufficientlyHealthy: At least 2 peers supporting both Filter and LightPush protocols

  Returns HealthStatus

  Example

  console.log(waku.health); // 'Unhealthy'
  Copy

peerId

• get peerId(): PeerId

  Returns a unique identifier for a node on the network.

  Returns PeerId

  Example

  console.log(waku.peerId); // 12D3KooWNmk9yXHfHJ4rUduRqD1TCTHkNFMPF9WP2dqWpZDL4aUb
  Copy

protocols

• get protocols(): string[]

  Returns a list of supported protocols.

  Returns string[]

  Example

  console.log(waku.protocols); // ['/ipfs/id/1.0.0', '/ipfs/ping/1.0.0', '/vac/waku/filter-push/2.0.0-beta1', '/vac/waku/metadata/1.0.0']
  Copy

createDecoder

• createDecoder(params: CreateDecoderParams): IDecoder<IDecodedMessage>

  Creates a decoder for Waku messages on a specific content topic.

  A decoder is used to decode messages from the Waku network format. The decoder automatically handles shard configuration based on the Waku node's network settings.

  Parameters

  • params: CreateDecoderParams

    Configuration for the decoder

  Returns IDecoder<IDecodedMessage>

  A decoder instance configured for the specified content topic

  Throws

  If the shard configuration is incompatible with the node's network settings

  Example

  // Create a decoder with default network shard settings
  const decoder = waku.createDecoder({
    contentTopic: "/my-app/1/chat/proto"
  });
  
  // Create a decoder with custom shard settings
  const customDecoder = waku.createDecoder({
    contentTopic: "/my-app/1/chat/proto",
    shardInfo: {
      clusterId: 1,
      shard: 5
    }
  });
  Copy

createEncoder

• createEncoder(params: CreateEncoderParams): IEncoder

  Creates an encoder for Waku messages on a specific content topic.

  An encoder is used to encode messages into the Waku network format. The encoder automatically handles shard configuration based on the Waku node's network settings.

  Parameters

  • params: CreateEncoderParams

    Configuration for the encoder including content topic and optionally shard information and ephemeral flag

  Returns IEncoder

  An encoder instance configured for the specified content topic

  Throws

  If the shard configuration is incompatible with the node's network settings

  Example

  // Create a basic encoder with default network shard settings
  const encoder = waku.createEncoder({
    contentTopic: "/my-app/1/chat/proto"
  });
  
  // Create an ephemeral encoder (messages won't be stored by store nodes)
  const ephemeralEncoder = waku.createEncoder({
    contentTopic: "/my-app/1/notifications/proto",
    ephemeral: true,
    shardInfo: {
      clusterId: 2,
      shardsUnderCluster: 16
    }
  });
  Copy

dial

• dial(peer: PeerId | MultiaddrInput, protocols?: Protocols[]): Promise<Stream>

  Dials to the provided peer

  Parameters

  • peer: PeerId | MultiaddrInput

    information to use for dialing
  • Optionalprotocols: Protocols[]

    array of Waku protocols to be used for dialing. If no provided - will be derived from mounted protocols.

  Returns Promise<Stream>

  Promise that will resolve to a Stream to a dialed peer and will reject if the connection fails

  Example

  await waku.dial(remotePeerId, [Protocols.LightPush]);
  
  waku.isConnected() === true;
  Copy

getConnectedPeers

• getConnectedPeers(): Promise<Peer[]>

  Returns Promise<Peer[]>

  an array of all connected peers

hangUp

• hangUp(peer: PeerId | MultiaddrInput): Promise<boolean>

  Hang up a connection to a peer

  Parameters

  • peer: PeerId | MultiaddrInput

    information to use for hanging up

  Returns Promise<boolean>

  Promise that will resolve to true if the connection is hung up, false otherwise

isConnected

• isConnected(): boolean

  Returns boolean

  true if the node has working connection and false otherwise

isStarted

• isStarted(): boolean

  Returns boolean

  true if the node was started and false otherwise

start

• start(): Promise<void>

  Starts all services and components related to functionality of Waku node.

  Returns Promise<void>

  Promise that will resolve when started.

  Example

  await waku.start();
  
  waku.isStarted() === true;
  Copy

stop

• stop(): Promise<void>

  Stops all recurring processes and services that are needed for functionality of Waku node.

  Returns Promise<void>

  Promise that resolves when stopped.

  Example

  await waku.stop();
  
  waku.isStarted === false;
  Copy

waitForPeers

• waitForPeers(protocols?: Protocols[], timeoutMs?: number): Promise<void>

  Resolves when Waku successfully gains connection to a remote peers that fits provided requirements. Must be used after attempting to connect to nodes, using IWaku.dial or if was bootstrapped by using IPeerExchange or DnsDiscoveryComponents.

  Parameters

  • Optionalprotocols: Protocols[]

    Protocols that need to be enabled by remote peers
  • OptionaltimeoutMs: number

    Timeout value in milliseconds after which promise rejects

  Returns Promise<void>

  Promise that resolves if all desired protocols are fulfilled by at least one remote peer, rejects if the timeoutMs is reached

  Throws

  If passing a protocol that is not mounted or Waku node is not started

  Example

  try {
   // let's wait for at least one LightPush node and timeout in 1 second
   await waku.waitForPeers([Protocols.LightPush], 1000);
  } catch(e) {
   waku.isConnected() === false;
   console.error("Failed to connect due to", e);
  }
  
  waku.isConnected() === true;
  Copy