@waku/enr 0.0.16 → 0.0.18

package/src/raw_enr.ts

@@ -1,13 +1,20 @@
 import type { Multiaddr } from "@multiformats/multiaddr";
 import {
   convertToBytes,
-  convertToString,
+  convertToString
 } from "@multiformats/multiaddr/convert";
-import type { ENRKey, ENRValue, SequenceNumber, Waku2 } from "@waku/interfaces";
+import type {
+  ENRKey,
+  ENRValue,
+  SequenceNumber,
+  ShardInfo,
+  Waku2
+} from "@waku/interfaces";
 import { bytesToUtf8 } from "@waku/utils/bytes";
 
 import { ERR_INVALID_ID } from "./constants.js";
 import { decodeMultiaddrs, encodeMultiaddrs } from "./multiaddrs_codec.js";
+import { decodeRelayShard } from "./relay_shard_codec.js";
 import { decodeWaku2, encodeWaku2 } from "./waku2_codec.js";
 
 export class RawEnr extends Map<ENRKey, ENRValue> {
@@ -45,6 +52,18 @@ export class RawEnr extends Map<ENRKey, ENRValue> {
     }
   }
 
+  get rs(): ShardInfo | undefined {
+    const rs = this.get("rs");
+    if (!rs) return undefined;
+    return decodeRelayShard(rs);
+  }
+
+  get rsv(): ShardInfo | undefined {
+    const rsv = this.get("rsv");
+    if (!rsv) return undefined;
+    return decodeRelayShard(rsv);
+  }
+
   get ip(): string | undefined {
     return getStringValue(this, "ip", "ip4");
   }

package/src/relay_shard_codec.ts

@@ -0,0 +1,60 @@
+import type { ShardInfo } from "@waku/interfaces";
+
+export const decodeRelayShard = (bytes: Uint8Array): ShardInfo => {
+  // explicitly converting to Uint8Array to avoid Buffer
+  // https://github.com/libp2p/js-libp2p/issues/2146
+  bytes = new Uint8Array(bytes);
+
+  if (bytes.length < 3) throw new Error("Insufficient data");
+
+  const view = new DataView(bytes.buffer);
+  const cluster = view.getUint16(0);
+
+  const indexList = [];
+
+  if (bytes.length === 130) {
+    // rsv format (Bit Vector)
+    for (let i = 0; i < 1024; i++) {
+      const byteIndex = Math.floor(i / 8) + 2; // Adjusted for the 2-byte cluster field
+      const bitIndex = 7 - (i % 8);
+      if (view.getUint8(byteIndex) & (1 << bitIndex)) {
+        indexList.push(i);
+      }
+    }
+  } else {
+    // rs format (Index List)
+    const numIndices = view.getUint8(2);
+    for (let i = 0, offset = 3; i < numIndices; i++, offset += 2) {
+      if (offset + 1 >= bytes.length) throw new Error("Unexpected end of data");
+      indexList.push(view.getUint16(offset));
+    }
+  }
+
+  return { cluster, indexList };
+};
+
+export const encodeRelayShard = (shardInfo: ShardInfo): Uint8Array => {
+  const { cluster, indexList } = shardInfo;
+  const totalLength = indexList.length >= 64 ? 130 : 3 + 2 * indexList.length;
+  const buffer = new ArrayBuffer(totalLength);
+  const view = new DataView(buffer);
+
+  view.setUint16(0, cluster);
+
+  if (indexList.length >= 64) {
+    // rsv format (Bit Vector)
+    for (const index of indexList) {
+      const byteIndex = Math.floor(index / 8) + 2; // Adjusted for the 2-byte cluster field
+      const bitIndex = 7 - (index % 8);
+      view.setUint8(byteIndex, view.getUint8(byteIndex) | (1 << bitIndex));
+    }
+  } else {
+    // rs format (Index List)
+    view.setUint8(2, indexList.length);
+    for (let i = 0, offset = 3; i < indexList.length; i++, offset += 2) {
+      view.setUint16(offset, indexList[i]);
+    }
+  }
+
+  return new Uint8Array(buffer);
+};

package/src/v4.ts

@@ -8,7 +8,7 @@ export async function sign(
   msg: Uint8Array
 ): Promise<Uint8Array> {
   return secp.sign(keccak256(msg), privKey, {
-    der: false,
+    der: false
   });
 }
 

package/src/waku2_codec.ts

@@ -19,7 +19,7 @@ export function decodeWaku2(byte: number): Waku2 {
     relay: false,
     store: false,
     filter: false,
-    lightPush: false,
+    lightPush: false
   };
 
   if (byte % 2) waku2.relay = true;