@waku/rln 0.1.8-e224c05.0 → 0.1.8-e800af3.0

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

@@ -0,0 +1,172 @@
+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 */
+/* eslint-disable import/consistent-type-specifier-style */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+var HistoryEntry;
+(function (HistoryEntry) {
+    let _codec;
+    HistoryEntry.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if ((obj.messageId != null && obj.messageId !== '')) {
+                    w.uint32(10);
+                    w.string(obj.messageId);
+                }
+                if (obj.retrievalHint != null) {
+                    w.uint32(18);
+                    w.bytes(obj.retrievalHint);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length, opts = {}) => {
+                const obj = {
+                    messageId: ''
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1: {
+                            obj.messageId = reader.string();
+                            break;
+                        }
+                        case 2: {
+                            obj.retrievalHint = reader.bytes();
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    HistoryEntry.encode = (obj) => {
+        return encodeMessage(obj, HistoryEntry.codec());
+    };
+    HistoryEntry.decode = (buf, opts) => {
+        return decodeMessage(buf, HistoryEntry.codec(), opts);
+    };
+})(HistoryEntry || (HistoryEntry = {}));
+var SdsMessage;
+(function (SdsMessage) {
+    let _codec;
+    SdsMessage.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if ((obj.senderId != null && obj.senderId !== '')) {
+                    w.uint32(10);
+                    w.string(obj.senderId);
+                }
+                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);
+                        HistoryEntry.codec().encode(value, w);
+                    }
+                }
+                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 = {
+                    senderId: '',
+                    messageId: '',
+                    channelId: '',
+                    causalHistory: []
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1: {
+                            obj.senderId = reader.string();
+                            break;
+                        }
+                        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(HistoryEntry.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.causalHistory$
+                            }));
+                            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 { HistoryEntry, SdsMessage };

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

@@ -0,0 +1,492 @@
+import { MaxLengthError } from '../../../../node_modules/protons-runtime/dist/src/index.js';
+import { alloc } from '../../../../node_modules/uint8arrays/dist/src/alloc.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 */
+/* eslint-disable import/consistent-type-specifier-style */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+var WakuMessageKeyValue;
+(function (WakuMessageKeyValue) {
+    let _codec;
+    WakuMessageKeyValue.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if (obj.messageHash != null) {
+                    w.uint32(10);
+                    w.bytes(obj.messageHash);
+                }
+                if (obj.message != null) {
+                    w.uint32(18);
+                    WakuMessage.codec().encode(obj.message, w);
+                }
+                if (obj.pubsubTopic != null) {
+                    w.uint32(26);
+                    w.string(obj.pubsubTopic);
+                }
+                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.messageHash = reader.bytes();
+                            break;
+                        }
+                        case 2: {
+                            obj.message = WakuMessage.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.message
+                            });
+                            break;
+                        }
+                        case 3: {
+                            obj.pubsubTopic = reader.string();
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    WakuMessageKeyValue.encode = (obj) => {
+        return encodeMessage(obj, WakuMessageKeyValue.codec());
+    };
+    WakuMessageKeyValue.decode = (buf, opts) => {
+        return decodeMessage(buf, WakuMessageKeyValue.codec(), opts);
+    };
+})(WakuMessageKeyValue || (WakuMessageKeyValue = {}));
+var StoreQueryRequest$1;
+(function (StoreQueryRequest) {
+    let _codec;
+    StoreQueryRequest.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if ((obj.requestId != null && obj.requestId !== '')) {
+                    w.uint32(10);
+                    w.string(obj.requestId);
+                }
+                if ((obj.includeData != null && obj.includeData !== false)) {
+                    w.uint32(16);
+                    w.bool(obj.includeData);
+                }
+                if (obj.pubsubTopic != null) {
+                    w.uint32(82);
+                    w.string(obj.pubsubTopic);
+                }
+                if (obj.contentTopics != null) {
+                    for (const value of obj.contentTopics) {
+                        w.uint32(90);
+                        w.string(value);
+                    }
+                }
+                if (obj.timeStart != null) {
+                    w.uint32(96);
+                    w.sint64(obj.timeStart);
+                }
+                if (obj.timeEnd != null) {
+                    w.uint32(104);
+                    w.sint64(obj.timeEnd);
+                }
+                if (obj.messageHashes != null) {
+                    for (const value of obj.messageHashes) {
+                        w.uint32(162);
+                        w.bytes(value);
+                    }
+                }
+                if (obj.paginationCursor != null) {
+                    w.uint32(410);
+                    w.bytes(obj.paginationCursor);
+                }
+                if ((obj.paginationForward != null && obj.paginationForward !== false)) {
+                    w.uint32(416);
+                    w.bool(obj.paginationForward);
+                }
+                if (obj.paginationLimit != null) {
+                    w.uint32(424);
+                    w.uint64(obj.paginationLimit);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length, opts = {}) => {
+                const obj = {
+                    requestId: '',
+                    includeData: false,
+                    contentTopics: [],
+                    messageHashes: [],
+                    paginationForward: false
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1: {
+                            obj.requestId = reader.string();
+                            break;
+                        }
+                        case 2: {
+                            obj.includeData = reader.bool();
+                            break;
+                        }
+                        case 10: {
+                            obj.pubsubTopic = reader.string();
+                            break;
+                        }
+                        case 11: {
+                            if (opts.limits?.contentTopics != null && obj.contentTopics.length === opts.limits.contentTopics) {
+                                throw new MaxLengthError('Decode error - map field "contentTopics" had too many elements');
+                            }
+                            obj.contentTopics.push(reader.string());
+                            break;
+                        }
+                        case 12: {
+                            obj.timeStart = reader.sint64();
+                            break;
+                        }
+                        case 13: {
+                            obj.timeEnd = reader.sint64();
+                            break;
+                        }
+                        case 20: {
+                            if (opts.limits?.messageHashes != null && obj.messageHashes.length === opts.limits.messageHashes) {
+                                throw new MaxLengthError('Decode error - map field "messageHashes" had too many elements');
+                            }
+                            obj.messageHashes.push(reader.bytes());
+                            break;
+                        }
+                        case 51: {
+                            obj.paginationCursor = reader.bytes();
+                            break;
+                        }
+                        case 52: {
+                            obj.paginationForward = reader.bool();
+                            break;
+                        }
+                        case 53: {
+                            obj.paginationLimit = reader.uint64();
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    StoreQueryRequest.encode = (obj) => {
+        return encodeMessage(obj, StoreQueryRequest.codec());
+    };
+    StoreQueryRequest.decode = (buf, opts) => {
+        return decodeMessage(buf, StoreQueryRequest.codec(), opts);
+    };
+})(StoreQueryRequest$1 || (StoreQueryRequest$1 = {}));
+var StoreQueryResponse$1;
+(function (StoreQueryResponse) {
+    let _codec;
+    StoreQueryResponse.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if ((obj.requestId != null && obj.requestId !== '')) {
+                    w.uint32(10);
+                    w.string(obj.requestId);
+                }
+                if (obj.statusCode != null) {
+                    w.uint32(80);
+                    w.uint32(obj.statusCode);
+                }
+                if (obj.statusDesc != null) {
+                    w.uint32(90);
+                    w.string(obj.statusDesc);
+                }
+                if (obj.messages != null) {
+                    for (const value of obj.messages) {
+                        w.uint32(162);
+                        WakuMessageKeyValue.codec().encode(value, w);
+                    }
+                }
+                if (obj.paginationCursor != null) {
+                    w.uint32(410);
+                    w.bytes(obj.paginationCursor);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length, opts = {}) => {
+                const obj = {
+                    requestId: '',
+                    messages: []
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1: {
+                            obj.requestId = reader.string();
+                            break;
+                        }
+                        case 10: {
+                            obj.statusCode = reader.uint32();
+                            break;
+                        }
+                        case 11: {
+                            obj.statusDesc = reader.string();
+                            break;
+                        }
+                        case 20: {
+                            if (opts.limits?.messages != null && obj.messages.length === opts.limits.messages) {
+                                throw new MaxLengthError('Decode error - map field "messages" had too many elements');
+                            }
+                            obj.messages.push(WakuMessageKeyValue.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.messages$
+                            }));
+                            break;
+                        }
+                        case 51: {
+                            obj.paginationCursor = reader.bytes();
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    StoreQueryResponse.encode = (obj) => {
+        return encodeMessage(obj, StoreQueryResponse.codec());
+    };
+    StoreQueryResponse.decode = (buf, opts) => {
+        return decodeMessage(buf, StoreQueryResponse.codec(), opts);
+    };
+})(StoreQueryResponse$1 || (StoreQueryResponse$1 = {}));
+var RateLimitProof;
+(function (RateLimitProof) {
+    let _codec;
+    RateLimitProof.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if ((obj.proof != null && obj.proof.byteLength > 0)) {
+                    w.uint32(10);
+                    w.bytes(obj.proof);
+                }
+                if ((obj.merkleRoot != null && obj.merkleRoot.byteLength > 0)) {
+                    w.uint32(18);
+                    w.bytes(obj.merkleRoot);
+                }
+                if ((obj.epoch != null && obj.epoch.byteLength > 0)) {
+                    w.uint32(26);
+                    w.bytes(obj.epoch);
+                }
+                if ((obj.shareX != null && obj.shareX.byteLength > 0)) {
+                    w.uint32(34);
+                    w.bytes(obj.shareX);
+                }
+                if ((obj.shareY != null && obj.shareY.byteLength > 0)) {
+                    w.uint32(42);
+                    w.bytes(obj.shareY);
+                }
+                if ((obj.nullifier != null && obj.nullifier.byteLength > 0)) {
+                    w.uint32(50);
+                    w.bytes(obj.nullifier);
+                }
+                if ((obj.rlnIdentifier != null && obj.rlnIdentifier.byteLength > 0)) {
+                    w.uint32(58);
+                    w.bytes(obj.rlnIdentifier);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length, opts = {}) => {
+                const obj = {
+                    proof: alloc(0),
+                    merkleRoot: alloc(0),
+                    epoch: alloc(0),
+                    shareX: alloc(0),
+                    shareY: alloc(0),
+                    nullifier: alloc(0),
+                    rlnIdentifier: alloc(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;
+                        }
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    RateLimitProof.encode = (obj) => {
+        return encodeMessage(obj, RateLimitProof.codec());
+    };
+    RateLimitProof.decode = (buf, opts) => {
+        return decodeMessage(buf, RateLimitProof.codec(), opts);
+    };
+})(RateLimitProof || (RateLimitProof = {}));
+var WakuMessage;
+(function (WakuMessage) {
+    let _codec;
+    WakuMessage.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if ((obj.payload != null && obj.payload.byteLength > 0)) {
+                    w.uint32(10);
+                    w.bytes(obj.payload);
+                }
+                if ((obj.contentTopic != null && obj.contentTopic !== '')) {
+                    w.uint32(18);
+                    w.string(obj.contentTopic);
+                }
+                if (obj.version != null) {
+                    w.uint32(24);
+                    w.uint32(obj.version);
+                }
+                if (obj.timestamp != null) {
+                    w.uint32(80);
+                    w.sint64(obj.timestamp);
+                }
+                if (obj.meta != null) {
+                    w.uint32(90);
+                    w.bytes(obj.meta);
+                }
+                if (obj.rateLimitProof != null) {
+                    w.uint32(170);
+                    RateLimitProof.codec().encode(obj.rateLimitProof, w);
+                }
+                if (obj.ephemeral != null) {
+                    w.uint32(248);
+                    w.bool(obj.ephemeral);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length, opts = {}) => {
+                const obj = {
+                    payload: alloc(0),
+                    contentTopic: ''
+                };
+                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 10: {
+                            obj.timestamp = reader.sint64();
+                            break;
+                        }
+                        case 11: {
+                            obj.meta = reader.bytes();
+                            break;
+                        }
+                        case 21: {
+                            obj.rateLimitProof = RateLimitProof.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.rateLimitProof
+                            });
+                            break;
+                        }
+                        case 31: {
+                            obj.ephemeral = reader.bool();
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    WakuMessage.encode = (obj) => {
+        return encodeMessage(obj, WakuMessage.codec());
+    };
+    WakuMessage.decode = (buf, opts) => {
+        return decodeMessage(buf, WakuMessage.codec(), opts);
+    };
+})(WakuMessage || (WakuMessage = {}));
+
+export { RateLimitProof, StoreQueryRequest$1 as StoreQueryRequest, StoreQueryResponse$1 as StoreQueryResponse, WakuMessage, WakuMessageKeyValue };