@waku/core 0.0.1

package/bundle/version_0-e6fe440c.js

@@ -0,0 +1,317 @@
+import { d as debug } from './browser-1e1a2f27.js';
+import { m as message$1, e as encodeMessage, d as decodeMessage } from './message-e2db79d7.js';
+
+/* eslint-disable import/export */
+var RateLimitProof;
+(function (RateLimitProof) {
+    let _codec;
+    RateLimitProof.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.proof != null) {
+                    writer.uint32(10);
+                    writer.bytes(obj.proof);
+                }
+                else {
+                    throw new Error('Protocol error: required field "proof" was not found in object');
+                }
+                if (obj.merkleRoot != null) {
+                    writer.uint32(18);
+                    writer.bytes(obj.merkleRoot);
+                }
+                else {
+                    throw new Error('Protocol error: required field "merkleRoot" was not found in object');
+                }
+                if (obj.epoch != null) {
+                    writer.uint32(26);
+                    writer.bytes(obj.epoch);
+                }
+                else {
+                    throw new Error('Protocol error: required field "epoch" was not found in object');
+                }
+                if (obj.shareX != null) {
+                    writer.uint32(34);
+                    writer.bytes(obj.shareX);
+                }
+                else {
+                    throw new Error('Protocol error: required field "shareX" was not found in object');
+                }
+                if (obj.shareY != null) {
+                    writer.uint32(42);
+                    writer.bytes(obj.shareY);
+                }
+                else {
+                    throw new Error('Protocol error: required field "shareY" was not found in object');
+                }
+                if (obj.nullifier != null) {
+                    writer.uint32(50);
+                    writer.bytes(obj.nullifier);
+                }
+                else {
+                    throw new Error('Protocol error: required field "nullifier" was not found in object');
+                }
+                if (obj.rlnIdentifier != null) {
+                    writer.uint32(58);
+                    writer.bytes(obj.rlnIdentifier);
+                }
+                else {
+                    throw new Error('Protocol error: required field "rlnIdentifier" was not found in object');
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    proof: new Uint8Array(0),
+                    merkleRoot: new Uint8Array(0),
+                    epoch: new Uint8Array(0),
+                    shareX: new Uint8Array(0),
+                    shareY: new Uint8Array(0),
+                    nullifier: new Uint8Array(0),
+                    rlnIdentifier: new Uint8Array(0),
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.proof = reader.bytes();
+                            break;
+                        case 2:
+                            obj.merkleRoot = reader.bytes();
+                            break;
+                        case 3:
+                            obj.epoch = reader.bytes();
+                            break;
+                        case 4:
+                            obj.shareX = reader.bytes();
+                            break;
+                        case 5:
+                            obj.shareY = reader.bytes();
+                            break;
+                        case 6:
+                            obj.nullifier = reader.bytes();
+                            break;
+                        case 7:
+                            obj.rlnIdentifier = reader.bytes();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                if (obj.proof == null) {
+                    throw new Error('Protocol error: value for required field "proof" was not found in protobuf');
+                }
+                if (obj.merkleRoot == null) {
+                    throw new Error('Protocol error: value for required field "merkleRoot" was not found in protobuf');
+                }
+                if (obj.epoch == null) {
+                    throw new Error('Protocol error: value for required field "epoch" was not found in protobuf');
+                }
+                if (obj.shareX == null) {
+                    throw new Error('Protocol error: value for required field "shareX" was not found in protobuf');
+                }
+                if (obj.shareY == null) {
+                    throw new Error('Protocol error: value for required field "shareY" was not found in protobuf');
+                }
+                if (obj.nullifier == null) {
+                    throw new Error('Protocol error: value for required field "nullifier" was not found in protobuf');
+                }
+                if (obj.rlnIdentifier == null) {
+                    throw new Error('Protocol error: value for required field "rlnIdentifier" was not found in protobuf');
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    RateLimitProof.encode = (obj) => {
+        return encodeMessage(obj, RateLimitProof.codec());
+    };
+    RateLimitProof.decode = (buf) => {
+        return decodeMessage(buf, RateLimitProof.codec());
+    };
+})(RateLimitProof || (RateLimitProof = {}));
+var WakuMessage;
+(function (WakuMessage) {
+    let _codec;
+    WakuMessage.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.payload != null) {
+                    writer.uint32(10);
+                    writer.bytes(obj.payload);
+                }
+                if (obj.contentTopic != null) {
+                    writer.uint32(18);
+                    writer.string(obj.contentTopic);
+                }
+                if (obj.version != null) {
+                    writer.uint32(24);
+                    writer.uint32(obj.version);
+                }
+                if (obj.timestampDeprecated != null) {
+                    writer.uint32(33);
+                    writer.double(obj.timestampDeprecated);
+                }
+                if (obj.timestamp != null) {
+                    writer.uint32(80);
+                    writer.sint64(obj.timestamp);
+                }
+                if (obj.rateLimitProof != null) {
+                    writer.uint32(170);
+                    RateLimitProof.codec().encode(obj.rateLimitProof, writer);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {};
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            obj.payload = reader.bytes();
+                            break;
+                        case 2:
+                            obj.contentTopic = reader.string();
+                            break;
+                        case 3:
+                            obj.version = reader.uint32();
+                            break;
+                        case 4:
+                            obj.timestampDeprecated = reader.double();
+                            break;
+                        case 10:
+                            obj.timestamp = reader.sint64();
+                            break;
+                        case 21:
+                            obj.rateLimitProof = RateLimitProof.codec().decode(reader, reader.uint32());
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    WakuMessage.encode = (obj) => {
+        return encodeMessage(obj, WakuMessage.codec());
+    };
+    WakuMessage.decode = (buf) => {
+        return decodeMessage(buf, WakuMessage.codec());
+    };
+})(WakuMessage || (WakuMessage = {}));
+
+var message = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    get RateLimitProof () { return RateLimitProof; },
+    get WakuMessage () { return WakuMessage; }
+});
+
+const log = debug("waku:message:version-0");
+const OneMillion = BigInt(1000000);
+const Version = 0;
+class MessageV0 {
+    constructor(proto) {
+        this.proto = proto;
+    }
+    get _rawPayload() {
+        if (this.proto.payload) {
+            return new Uint8Array(this.proto.payload);
+        }
+        return;
+    }
+    get payload() {
+        return this._rawPayload;
+    }
+    get contentTopic() {
+        return this.proto.contentTopic;
+    }
+    get _rawTimestamp() {
+        return this.proto.timestamp;
+    }
+    get timestamp() {
+        // In the case we receive a value that is bigger than JS's max number,
+        // we catch the error and return undefined.
+        try {
+            if (this.proto.timestamp) {
+                // nanoseconds 10^-9 to milliseconds 10^-3
+                const timestamp = this.proto.timestamp / OneMillion;
+                return new Date(Number(timestamp));
+            }
+            if (this.proto.timestampDeprecated) {
+                return new Date(this.proto.timestampDeprecated * 1000);
+            }
+        }
+        catch (e) {
+            return;
+        }
+        return;
+    }
+    get version() {
+        // https://github.com/status-im/js-waku/issues/921
+        return this.proto.version ?? 0;
+    }
+    get rateLimitProof() {
+        return this.proto.rateLimitProof;
+    }
+}
+class EncoderV0 {
+    constructor(contentTopic) {
+        this.contentTopic = contentTopic;
+    }
+    async toWire(message$1) {
+        return WakuMessage.encode(await this.toProtoObj(message$1));
+    }
+    async toProtoObj(message) {
+        const timestamp = message.timestamp ?? new Date();
+        return {
+            payload: message.payload,
+            version: Version,
+            contentTopic: message.contentTopic ?? this.contentTopic,
+            timestamp: BigInt(timestamp.valueOf()) * OneMillion,
+            rateLimitProof: message.rateLimitProof,
+        };
+    }
+}
+class DecoderV0 {
+    constructor(contentTopic) {
+        this.contentTopic = contentTopic;
+    }
+    fromWireToProtoObj(bytes) {
+        const protoMessage = WakuMessage.decode(bytes);
+        log("Message decoded", protoMessage);
+        return Promise.resolve({
+            payload: protoMessage.payload ?? undefined,
+            contentTopic: protoMessage.contentTopic ?? undefined,
+            version: protoMessage.version ?? undefined,
+            timestamp: protoMessage.timestamp ?? undefined,
+            rateLimitProof: protoMessage.rateLimitProof ?? undefined,
+        });
+    }
+    async fromProtoObj(proto) {
+        // https://github.com/status-im/js-waku/issues/921
+        if (proto.version === undefined) {
+            proto.version = 0;
+        }
+        if (proto.version !== Version) {
+            log("Failed to decode due to incorrect version, expected:", Version, ", actual:", proto.version);
+            return Promise.resolve(undefined);
+        }
+        return new MessageV0(proto);
+    }
+}
+
+export { DecoderV0 as D, EncoderV0 as E, MessageV0 as M, Version as V, WakuMessage as W, message as m };

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+export { DefaultPubSubTopic } from "./lib/constants";
+export { generatePrivateKey, generateSymmetricKey, getPublicKey, } from "./lib/crypto";
+export * as enr from "./lib/enr";
+export * as utils from "./lib/utils";
+export * as proto_message from "./proto/message";
+export * as proto_topic_only_message from "./proto/topic_only_message";
+export * as waku from "./lib/waku";
+export { WakuNode } from "./lib/waku";
+export * as waku_filter from "./lib/waku_filter";
+export { WakuFilter } from "./lib/waku_filter";
+export * as waku_light_push from "./lib/waku_light_push";
+export { WakuLightPush, LightPushCodec, PushResponse, } from "./lib/waku_light_push";
+export * as waku_relay from "./lib/waku_relay";
+export { WakuRelay } from "./lib/waku_relay";
+export * as waku_store from "./lib/waku_store";
+export { PageDirection, WakuStore, StoreCodec } from "./lib/waku_store";

package/dist/index.js

@@ -0,0 +1,17 @@
+export { DefaultPubSubTopic } from "./lib/constants.js";
+export { generatePrivateKey, generateSymmetricKey, getPublicKey, } from "./lib/crypto.js";
+export * as enr from "./lib/enr/index.js";
+export * as utils from "./lib/utils.js";
+export * as proto_message from "./proto/message.js";
+export * as proto_topic_only_message from "./proto/topic_only_message.js";
+export * as waku from "./lib/waku.js";
+export { WakuNode } from "./lib/waku.js";
+export * as waku_filter from "./lib/waku_filter/index.js";
+export { WakuFilter } from "./lib/waku_filter/index.js";
+export * as waku_light_push from "./lib/waku_light_push/index.js";
+export { WakuLightPush, LightPushCodec, PushResponse, } from "./lib/waku_light_push/index.js";
+export * as waku_relay from "./lib/waku_relay/index.js";
+export { WakuRelay } from "./lib/waku_relay/index.js";
+export * as waku_store from "./lib/waku_store/index.js";
+export { PageDirection, WakuStore, StoreCodec } from "./lib/waku_store/index.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAErD,OAAO,EACL,kBAAkB,EAClB,oBAAoB,EACpB,YAAY,GACb,MAAM,cAAc,CAAC;AAEtB,OAAO,KAAK,GAAG,MAAM,WAAW,CAAC;AAEjC,OAAO,KAAK,KAAK,MAAM,aAAa,CAAC;AAErC,OAAO,KAAK,aAAa,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,wBAAwB,MAAM,4BAA4B,CAAC;AAEvE,OAAO,KAAK,IAAI,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC,OAAO,KAAK,WAAW,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAE/C,OAAO,KAAK,eAAe,MAAM,uBAAuB,CAAC;AACzD,OAAO,EACL,aAAa,EACb,cAAc,EACd,YAAY,GACb,MAAM,uBAAuB,CAAC;AAE/B,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7C,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/lib/constants.d.ts

@@ -0,0 +1,4 @@
+/**
+ * DefaultPubSubTopic is the default gossipsub topic to use for Waku.
+ */
+export declare const DefaultPubSubTopic = "/waku/2/default-waku/proto";

package/dist/lib/constants.js

@@ -0,0 +1,5 @@
+/**
+ * DefaultPubSubTopic is the default gossipsub topic to use for Waku.
+ */
+export const DefaultPubSubTopic = "/waku/2/default-waku/proto";
+//# sourceMappingURL=constants.js.map

package/dist/lib/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/lib/constants.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,4BAA4B,CAAC"}

package/dist/lib/crypto.d.ts

@@ -0,0 +1,34 @@
+import * as secp from "@noble/secp256k1";
+export declare function getSubtle(): SubtleCrypto;
+export declare const randomBytes: (bytesLength?: number | undefined) => Uint8Array;
+export declare const sha256: (...messages: Uint8Array[]) => Promise<Uint8Array>;
+/**
+ * Generate a new private key to be used for asymmetric encryption.
+ *
+ * Use {@link getPublicKey} to get the corresponding Public Key.
+ */
+export declare function generatePrivateKey(): Uint8Array;
+/**
+ * Generate a new symmetric key to be used for symmetric encryption.
+ */
+export declare function generateSymmetricKey(): Uint8Array;
+/**
+ * Return the public key for the given private key, to be used for asymmetric
+ * encryption.
+ */
+export declare const getPublicKey: typeof secp.getPublicKey;
+/**
+ * ECDSA Sign a message with the given private key.
+ *
+ *  @param message The message to sign, usually a hash.
+ *  @param privateKey The ECDSA private key to use to sign the message.
+ *
+ *  @returns The signature and the recovery id concatenated.
+ */
+export declare function sign(message: Uint8Array, privateKey: Uint8Array): Promise<Uint8Array>;
+export declare function keccak256(input: Uint8Array): Uint8Array;
+export declare function compressPublicKey(publicKey: Uint8Array): Uint8Array;
+/**
+ * Verify an ECDSA signature.
+ */
+export declare function verifySignature(signature: Uint8Array, message: Uint8Array | string, publicKey: Uint8Array): boolean;

package/dist/lib/crypto.js

@@ -0,0 +1,79 @@
+import nodeCrypto from "crypto";
+import * as secp from "@noble/secp256k1";
+import sha3 from "js-sha3";
+import { concat } from "./utils.js";
+import { Asymmetric, Symmetric } from "./waku_message/constants.js";
+const crypto = {
+    node: nodeCrypto,
+    web: typeof self === "object" && "crypto" in self ? self.crypto : undefined,
+};
+export function getSubtle() {
+    if (crypto.web) {
+        return crypto.web.subtle;
+    }
+    else if (crypto.node) {
+        return crypto.node.webcrypto.subtle;
+    }
+    else {
+        throw new Error("The environment doesn't have Crypto Subtle API (if in the browser, be sure to use to be in a secure context, ie, https)");
+    }
+}
+export const randomBytes = secp.utils.randomBytes;
+export const sha256 = secp.utils.sha256;
+/**
+ * Generate a new private key to be used for asymmetric encryption.
+ *
+ * Use {@link getPublicKey} to get the corresponding Public Key.
+ */
+export function generatePrivateKey() {
+    return randomBytes(Asymmetric.keySize);
+}
+/**
+ * Generate a new symmetric key to be used for symmetric encryption.
+ */
+export function generateSymmetricKey() {
+    return randomBytes(Symmetric.keySize);
+}
+/**
+ * Return the public key for the given private key, to be used for asymmetric
+ * encryption.
+ */
+export const getPublicKey = secp.getPublicKey;
+/**
+ * ECDSA Sign a message with the given private key.
+ *
+ *  @param message The message to sign, usually a hash.
+ *  @param privateKey The ECDSA private key to use to sign the message.
+ *
+ *  @returns The signature and the recovery id concatenated.
+ */
+export async function sign(message, privateKey) {
+    const [signature, recoveryId] = await secp.sign(message, privateKey, {
+        recovered: true,
+        der: false,
+    });
+    return concat([signature, new Uint8Array([recoveryId])], signature.length + 1);
+}
+export function keccak256(input) {
+    return new Uint8Array(sha3.keccak256.arrayBuffer(input));
+}
+export function compressPublicKey(publicKey) {
+    if (publicKey.length === 64) {
+        publicKey = concat([new Uint8Array([4]), publicKey], 65);
+    }
+    const point = secp.Point.fromHex(publicKey);
+    return point.toRawBytes(true);
+}
+/**
+ * Verify an ECDSA signature.
+ */
+export function verifySignature(signature, message, publicKey) {
+    try {
+        const _signature = secp.Signature.fromCompact(signature.slice(0, 64));
+        return secp.verify(_signature, message, publicKey);
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=crypto.js.map

package/dist/lib/crypto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.js","sourceRoot":"","sources":["../../src/lib/crypto.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,QAAQ,CAAC;AAEhC,OAAO,KAAK,IAAI,MAAM,kBAAkB,CAAC;AACzC,OAAO,IAAI,MAAM,SAAS,CAAC;AAE3B,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACjC,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAGjE,MAAM,MAAM,GAA8B;IACxC,IAAI,EAAE,UAAU;IAChB,GAAG,EAAE,OAAO,IAAI,KAAK,QAAQ,IAAI,QAAQ,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS;CAC5E,CAAC;AAEF,MAAM,UAAU,SAAS;IACvB,IAAI,MAAM,CAAC,GAAG,EAAE;QACd,OAAO,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC;KAC1B;SAAM,IAAI,MAAM,CAAC,IAAI,EAAE;QACtB,OAAO,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;KACrC;SAAM;QACL,MAAM,IAAI,KAAK,CACb,yHAAyH,CAC1H,CAAC;KACH;AACH,CAAC;AAED,MAAM,CAAC,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC;AAClD,MAAM,CAAC,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;AAExC;;;;GAIG;AACH,MAAM,UAAU,kBAAkB;IAChC,OAAO,WAAW,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;AACzC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,oBAAoB;IAClC,OAAO,WAAW,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;AACxC,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC;AAE9C;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,IAAI,CACxB,OAAmB,EACnB,UAAsB;IAEtB,MAAM,CAAC,SAAS,EAAE,UAAU,CAAC,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,UAAU,EAAE;QACnE,SAAS,EAAE,IAAI;QACf,GAAG,EAAE,KAAK;KACX,CAAC,CAAC;IACH,OAAO,MAAM,CACX,CAAC,SAAS,EAAE,IAAI,UAAU,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,EACzC,SAAS,CAAC,MAAM,GAAG,CAAC,CACrB,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,SAAS,CAAC,KAAiB;IACzC,OAAO,IAAI,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;AAC3D,CAAC;AAED,MAAM,UAAU,iBAAiB,CAAC,SAAqB;IACrD,IAAI,SAAS,CAAC,MAAM,KAAK,EAAE,EAAE;QAC3B,SAAS,GAAG,MAAM,CAAC,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,EAAE,CAAC,CAAC;KAC1D;IACD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IAC5C,OAAO,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;AAChC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,eAAe,CAC7B,SAAqB,EACrB,OAA4B,EAC5B,SAAqB;IAErB,IAAI;QACF,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;QACtE,OAAO,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC;KACpD;IAAC,MAAM;QACN,OAAO,KAAK,CAAC;KACd;AACH,CAAC"}

package/dist/lib/enr/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const MAX_RECORD_SIZE = 300;
+export declare const ERR_INVALID_ID = "Invalid record id";
+export declare const ERR_NO_SIGNATURE = "No valid signature found";
+export declare const MULTIADDR_LENGTH_SIZE = 2;

package/dist/lib/enr/constants.js

@@ -0,0 +1,8 @@
+// Maximum encoded size of an ENR
+export const MAX_RECORD_SIZE = 300;
+export const ERR_INVALID_ID = "Invalid record id";
+export const ERR_NO_SIGNATURE = "No valid signature found";
+// The maximum length of byte size of a multiaddr to encode in the `multiaddr` field
+// The size is a big endian 16-bit unsigned integer
+export const MULTIADDR_LENGTH_SIZE = 2;
+//# sourceMappingURL=constants.js.map

package/dist/lib/enr/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../src/lib/enr/constants.ts"],"names":[],"mappings":"AAAA,iCAAiC;AACjC,MAAM,CAAC,MAAM,eAAe,GAAG,GAAG,CAAC;AAEnC,MAAM,CAAC,MAAM,cAAc,GAAG,mBAAmB,CAAC;AAElD,MAAM,CAAC,MAAM,gBAAgB,GAAG,0BAA0B,CAAC;AAE3D,oFAAoF;AACpF,mDAAmD;AACnD,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAC"}

package/dist/lib/enr/enr.d.ts

@@ -0,0 +1,90 @@
+import type { PeerId } from "@libp2p/interface-peer-id";
+import { Multiaddr } from "@multiformats/multiaddr";
+import { IKeypair, KeypairType } from "./keypair";
+import { ENRKey, ENRValue, NodeId, SequenceNumber } from "./types";
+import { Waku2 } from "./waku2_codec";
+export declare class ENR extends Map<ENRKey, ENRValue> {
+    static readonly RECORD_PREFIX = "enr:";
+    seq: SequenceNumber;
+    signature: Uint8Array | null;
+    peerId?: PeerId;
+    private constructor();
+    static create(kvs?: Record<ENRKey, ENRValue>, seq?: SequenceNumber, signature?: Uint8Array | null): Promise<ENR>;
+    static createV4(publicKey: Uint8Array, kvs?: Record<ENRKey, ENRValue>): Promise<ENR>;
+    static createFromPeerId(peerId: PeerId, kvs?: Record<ENRKey, ENRValue>): Promise<ENR>;
+    static decodeFromValues(decoded: Uint8Array[]): Promise<ENR>;
+    static decode(encoded: Uint8Array): Promise<ENR>;
+    static decodeTxt(encoded: string): Promise<ENR>;
+    set(k: ENRKey, v: ENRValue): this;
+    get id(): string;
+    get keypairType(): KeypairType;
+    get publicKey(): Uint8Array | undefined;
+    get keypair(): IKeypair | undefined;
+    get nodeId(): NodeId | undefined;
+    get ip(): string | undefined;
+    set ip(ip: string | undefined);
+    get tcp(): number | undefined;
+    set tcp(port: number | undefined);
+    get udp(): number | undefined;
+    set udp(port: number | undefined);
+    get ip6(): string | undefined;
+    set ip6(ip: string | undefined);
+    get tcp6(): number | undefined;
+    set tcp6(port: number | undefined);
+    get udp6(): number | undefined;
+    set udp6(port: number | undefined);
+    /**
+     * Get the `multiaddrs` field from ENR.
+     *
+     * This field is used to store multiaddresses that cannot be stored with the current ENR pre-defined keys.
+     * These can be a multiaddresses that include encapsulation (e.g. wss) or do not use `ip4` nor `ip6` for the host
+     * address (e.g. `dns4`, `dnsaddr`, etc)..
+     *
+     * If the peer information only contains information that can be represented with the ENR pre-defined keys
+     * (ip, tcp, etc) then the usage of { @link getLocationMultiaddr } should be preferred.
+     *
+     * The multiaddresses stored in this field are expected to be location multiaddresses, ie, peer id less.
+     */
+    get multiaddrs(): Multiaddr[] | undefined;
+    /**
+     * Set the `multiaddrs` field on the ENR.
+     *
+     * This field is used to store multiaddresses that cannot be stored with the current ENR pre-defined keys.
+     * These can be a multiaddresses that include encapsulation (e.g. wss) or do not use `ip4` nor `ip6` for the host
+     * address (e.g. `dns4`, `dnsaddr`, etc)..
+     *
+     * If the peer information only contains information that can be represented with the ENR pre-defined keys
+     * (ip, tcp, etc) then the usage of { @link setLocationMultiaddr } should be preferred.
+     * The multiaddresses stored in this field must be location multiaddresses,
+     * ie, without a peer id.
+     */
+    set multiaddrs(multiaddrs: Multiaddr[] | undefined);
+    getLocationMultiaddr(protocol: "udp" | "udp4" | "udp6" | "tcp" | "tcp4" | "tcp6"): Multiaddr | undefined;
+    setLocationMultiaddr(multiaddr: Multiaddr): void;
+    /**
+     * Returns the full multiaddr from the ENR fields matching the provided
+     * `protocol` parameter.
+     * To return full multiaddrs from the `multiaddrs` ENR field,
+     * use { @link ENR.getFullMultiaddrs }.
+     *
+     * @param protocol
+     */
+    getFullMultiaddr(protocol: "udp" | "udp4" | "udp6" | "tcp" | "tcp4" | "tcp6"): Multiaddr | undefined;
+    /**
+     * Returns the full multiaddrs from the `multiaddrs` ENR field.
+     */
+    getFullMultiaddrs(): Multiaddr[];
+    /**
+     * Get the `waku2` field from ENR.
+     */
+    get waku2(): Waku2 | undefined;
+    /**
+     * Set the `waku2` field on the ENR.
+     */
+    set waku2(waku2: Waku2 | undefined);
+    verify(data: Uint8Array, signature: Uint8Array): boolean;
+    sign(data: Uint8Array, privateKey: Uint8Array): Promise<Uint8Array>;
+    encodeToValues(privateKey?: Uint8Array): Promise<(ENRKey | ENRValue | number[])[]>;
+    encode(privateKey?: Uint8Array): Promise<Uint8Array>;
+    encodeTxt(privateKey?: Uint8Array): Promise<string>;
+}