@waku/rln 0.1.3 → 0.1.4-d27db21.0

package/bundle/packages/proto/dist/generated/metadata.js

@@ -0,0 +1,130 @@
+import { MaxLengthError } from '../../../../node_modules/protons-runtime/dist/src/index.js';
+import { message } from '../../../../node_modules/protons-runtime/dist/src/codecs/message.js';
+import { encodeMessage } from '../../../../node_modules/protons-runtime/dist/src/encode.js';
+import { decodeMessage } from '../../../../node_modules/protons-runtime/dist/src/decode.js';
+
+/* eslint-disable import/export */
+/* eslint-disable complexity */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
+/* eslint-disable @typescript-eslint/no-empty-interface */
+var WakuMetadataRequest;
+(function (WakuMetadataRequest) {
+    let _codec;
+    WakuMetadataRequest.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.clusterId != null) {
+                    w.uint32(8);
+                    w.uint32(obj.clusterId);
+                }
+                if (obj.shards != null) {
+                    for (const value of obj.shards) {
+                        w.uint32(16);
+                        w.uint32(value);
+                    }
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length, opts = {}) => {
+                const obj = {
+                    shards: []
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1: {
+                            obj.clusterId = reader.uint32();
+                            break;
+                        }
+                        case 2: {
+                            if (opts.limits?.shards != null && obj.shards.length === opts.limits.shards) {
+                                throw new MaxLengthError('Decode error - map field "shards" had too many elements');
+                            }
+                            obj.shards.push(reader.uint32());
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    WakuMetadataRequest.encode = (obj) => {
+        return encodeMessage(obj, WakuMetadataRequest.codec());
+    };
+    WakuMetadataRequest.decode = (buf, opts) => {
+        return decodeMessage(buf, WakuMetadataRequest.codec(), opts);
+    };
+})(WakuMetadataRequest || (WakuMetadataRequest = {}));
+var WakuMetadataResponse;
+(function (WakuMetadataResponse) {
+    let _codec;
+    WakuMetadataResponse.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.clusterId != null) {
+                    w.uint32(8);
+                    w.uint32(obj.clusterId);
+                }
+                if (obj.shards != null) {
+                    for (const value of obj.shards) {
+                        w.uint32(16);
+                        w.uint32(value);
+                    }
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length, opts = {}) => {
+                const obj = {
+                    shards: []
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1: {
+                            obj.clusterId = reader.uint32();
+                            break;
+                        }
+                        case 2: {
+                            if (opts.limits?.shards != null && obj.shards.length === opts.limits.shards) {
+                                throw new MaxLengthError('Decode error - map field "shards" had too many elements');
+                            }
+                            obj.shards.push(reader.uint32());
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    WakuMetadataResponse.encode = (obj) => {
+        return encodeMessage(obj, WakuMetadataResponse.codec());
+    };
+    WakuMetadataResponse.decode = (buf, opts) => {
+        return decodeMessage(buf, WakuMetadataResponse.codec(), opts);
+    };
+})(WakuMetadataResponse || (WakuMetadataResponse = {}));
+
+export { WakuMetadataRequest, WakuMetadataResponse };

package/bundle/packages/proto/dist/generated/peer_exchange.js

@@ -0,0 +1,209 @@
+import { MaxLengthError } from '../../../../node_modules/protons-runtime/dist/src/index.js';
+import { message } from '../../../../node_modules/protons-runtime/dist/src/codecs/message.js';
+import { encodeMessage } from '../../../../node_modules/protons-runtime/dist/src/encode.js';
+import { decodeMessage } from '../../../../node_modules/protons-runtime/dist/src/decode.js';
+
+/* eslint-disable import/export */
+/* eslint-disable complexity */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
+/* eslint-disable @typescript-eslint/no-empty-interface */
+var PeerInfo;
+(function (PeerInfo) {
+    let _codec;
+    PeerInfo.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.enr != null) {
+                    w.uint32(10);
+                    w.bytes(obj.enr);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length, opts = {}) => {
+                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.enr = reader.bytes();
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    PeerInfo.encode = (obj) => {
+        return encodeMessage(obj, PeerInfo.codec());
+    };
+    PeerInfo.decode = (buf, opts) => {
+        return decodeMessage(buf, PeerInfo.codec(), opts);
+    };
+})(PeerInfo || (PeerInfo = {}));
+var PeerExchangeQuery;
+(function (PeerExchangeQuery) {
+    let _codec;
+    PeerExchangeQuery.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.numPeers != null) {
+                    w.uint32(8);
+                    w.uint64(obj.numPeers);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length, opts = {}) => {
+                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.numPeers = reader.uint64();
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    PeerExchangeQuery.encode = (obj) => {
+        return encodeMessage(obj, PeerExchangeQuery.codec());
+    };
+    PeerExchangeQuery.decode = (buf, opts) => {
+        return decodeMessage(buf, PeerExchangeQuery.codec(), opts);
+    };
+})(PeerExchangeQuery || (PeerExchangeQuery = {}));
+var PeerExchangeResponse;
+(function (PeerExchangeResponse) {
+    let _codec;
+    PeerExchangeResponse.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.peerInfos != null) {
+                    for (const value of obj.peerInfos) {
+                        w.uint32(10);
+                        PeerInfo.codec().encode(value, w);
+                    }
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length, opts = {}) => {
+                const obj = {
+                    peerInfos: []
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1: {
+                            if (opts.limits?.peerInfos != null && obj.peerInfos.length === opts.limits.peerInfos) {
+                                throw new MaxLengthError('Decode error - map field "peerInfos" had too many elements');
+                            }
+                            obj.peerInfos.push(PeerInfo.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.peerInfos$
+                            }));
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    PeerExchangeResponse.encode = (obj) => {
+        return encodeMessage(obj, PeerExchangeResponse.codec());
+    };
+    PeerExchangeResponse.decode = (buf, opts) => {
+        return decodeMessage(buf, PeerExchangeResponse.codec(), opts);
+    };
+})(PeerExchangeResponse || (PeerExchangeResponse = {}));
+var PeerExchangeRPC;
+(function (PeerExchangeRPC) {
+    let _codec;
+    PeerExchangeRPC.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.query != null) {
+                    w.uint32(10);
+                    PeerExchangeQuery.codec().encode(obj.query, w);
+                }
+                if (obj.response != null) {
+                    w.uint32(18);
+                    PeerExchangeResponse.codec().encode(obj.response, w);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length, opts = {}) => {
+                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.query = PeerExchangeQuery.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.query
+                            });
+                            break;
+                        }
+                        case 2: {
+                            obj.response = PeerExchangeResponse.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.response
+                            });
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    PeerExchangeRPC.encode = (obj) => {
+        return encodeMessage(obj, PeerExchangeRPC.codec());
+    };
+    PeerExchangeRPC.decode = (buf, opts) => {
+        return decodeMessage(buf, PeerExchangeRPC.codec(), opts);
+    };
+})(PeerExchangeRPC || (PeerExchangeRPC = {}));
+
+export { PeerExchangeQuery, PeerExchangeRPC, PeerExchangeResponse, PeerInfo };

package/bundle/packages/proto/dist/generated/sds_message.js

@@ -0,0 +1,105 @@
+import { MaxLengthError } from '../../../../node_modules/protons-runtime/dist/src/index.js';
+import { message } from '../../../../node_modules/protons-runtime/dist/src/codecs/message.js';
+import { encodeMessage } from '../../../../node_modules/protons-runtime/dist/src/encode.js';
+import { decodeMessage } from '../../../../node_modules/protons-runtime/dist/src/decode.js';
+
+/* eslint-disable import/export */
+/* eslint-disable complexity */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
+/* eslint-disable @typescript-eslint/no-empty-interface */
+var SdsMessage;
+(function (SdsMessage) {
+    let _codec;
+    SdsMessage.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if ((obj.messageId != null && obj.messageId !== '')) {
+                    w.uint32(18);
+                    w.string(obj.messageId);
+                }
+                if ((obj.channelId != null && obj.channelId !== '')) {
+                    w.uint32(26);
+                    w.string(obj.channelId);
+                }
+                if (obj.lamportTimestamp != null) {
+                    w.uint32(80);
+                    w.int32(obj.lamportTimestamp);
+                }
+                if (obj.causalHistory != null) {
+                    for (const value of obj.causalHistory) {
+                        w.uint32(90);
+                        w.string(value);
+                    }
+                }
+                if (obj.bloomFilter != null) {
+                    w.uint32(98);
+                    w.bytes(obj.bloomFilter);
+                }
+                if (obj.content != null) {
+                    w.uint32(162);
+                    w.bytes(obj.content);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length, opts = {}) => {
+                const obj = {
+                    messageId: '',
+                    channelId: '',
+                    causalHistory: []
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 2: {
+                            obj.messageId = reader.string();
+                            break;
+                        }
+                        case 3: {
+                            obj.channelId = reader.string();
+                            break;
+                        }
+                        case 10: {
+                            obj.lamportTimestamp = reader.int32();
+                            break;
+                        }
+                        case 11: {
+                            if (opts.limits?.causalHistory != null && obj.causalHistory.length === opts.limits.causalHistory) {
+                                throw new MaxLengthError('Decode error - map field "causalHistory" had too many elements');
+                            }
+                            obj.causalHistory.push(reader.string());
+                            break;
+                        }
+                        case 12: {
+                            obj.bloomFilter = reader.bytes();
+                            break;
+                        }
+                        case 20: {
+                            obj.content = reader.bytes();
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    SdsMessage.encode = (obj) => {
+        return encodeMessage(obj, SdsMessage.codec());
+    };
+    SdsMessage.decode = (buf, opts) => {
+        return decodeMessage(buf, SdsMessage.codec(), opts);
+    };
+})(SdsMessage || (SdsMessage = {}));
+
+export { SdsMessage };