@waku/core 0.0.1

package/dist/proto/store.d.ts

@@ -0,0 +1,104 @@
+import type { Uint8ArrayList } from "uint8arraylist";
+import type { Codec } from "protons-runtime";
+export interface Index {
+    digest?: Uint8Array;
+    receivedTime?: bigint;
+    senderTime?: bigint;
+    pubsubTopic?: string;
+}
+export declare namespace Index {
+    const codec: () => Codec<Index>;
+    const encode: (obj: Index) => Uint8Array;
+    const decode: (buf: Uint8Array | Uint8ArrayList) => Index;
+}
+export interface PagingInfo {
+    pageSize?: bigint;
+    cursor?: Index;
+    direction?: PagingInfo.Direction;
+}
+export declare namespace PagingInfo {
+    enum Direction {
+        DIRECTION_BACKWARD_UNSPECIFIED = "DIRECTION_BACKWARD_UNSPECIFIED",
+        DIRECTION_FORWARD = "DIRECTION_FORWARD"
+    }
+    namespace Direction {
+        const codec: () => Codec<Direction>;
+    }
+    const codec: () => Codec<PagingInfo>;
+    const encode: (obj: PagingInfo) => Uint8Array;
+    const decode: (buf: Uint8Array | Uint8ArrayList) => PagingInfo;
+}
+export interface ContentFilter {
+    contentTopic?: string;
+}
+export declare namespace ContentFilter {
+    const codec: () => Codec<ContentFilter>;
+    const encode: (obj: ContentFilter) => Uint8Array;
+    const decode: (buf: Uint8Array | Uint8ArrayList) => ContentFilter;
+}
+export interface HistoryQuery {
+    pubSubTopic?: string;
+    contentFilters: ContentFilter[];
+    pagingInfo?: PagingInfo;
+    startTime?: bigint;
+    endTime?: bigint;
+}
+export declare namespace HistoryQuery {
+    const codec: () => Codec<HistoryQuery>;
+    const encode: (obj: HistoryQuery) => Uint8Array;
+    const decode: (buf: Uint8Array | Uint8ArrayList) => HistoryQuery;
+}
+export interface HistoryResponse {
+    messages: WakuMessage[];
+    pagingInfo?: PagingInfo;
+    error?: HistoryResponse.HistoryError;
+}
+export declare namespace HistoryResponse {
+    enum HistoryError {
+        ERROR_NONE_UNSPECIFIED = "ERROR_NONE_UNSPECIFIED",
+        ERROR_INVALID_CURSOR = "ERROR_INVALID_CURSOR"
+    }
+    namespace HistoryError {
+        const codec: () => Codec<HistoryError>;
+    }
+    const codec: () => Codec<HistoryResponse>;
+    const encode: (obj: HistoryResponse) => Uint8Array;
+    const decode: (buf: Uint8Array | Uint8ArrayList) => HistoryResponse;
+}
+export interface HistoryRPC {
+    requestId?: string;
+    query?: HistoryQuery;
+    response?: HistoryResponse;
+}
+export declare namespace HistoryRPC {
+    const codec: () => Codec<HistoryRPC>;
+    const encode: (obj: HistoryRPC) => Uint8Array;
+    const decode: (buf: Uint8Array | Uint8ArrayList) => HistoryRPC;
+}
+export interface RateLimitProof {
+    proof: Uint8Array;
+    merkleRoot: Uint8Array;
+    epoch: Uint8Array;
+    shareX: Uint8Array;
+    shareY: Uint8Array;
+    nullifier: Uint8Array;
+    rlnIdentifier: Uint8Array;
+}
+export declare namespace RateLimitProof {
+    const codec: () => Codec<RateLimitProof>;
+    const encode: (obj: RateLimitProof) => Uint8Array;
+    const decode: (buf: Uint8Array | Uint8ArrayList) => RateLimitProof;
+}
+export interface WakuMessage {
+    payload?: Uint8Array;
+    contentTopic?: string;
+    version?: number;
+    timestampDeprecated?: number;
+    timestamp?: bigint;
+    rateLimitProof?: RateLimitProof;
+}
+export declare namespace WakuMessage {
+    const codec: () => Codec<WakuMessage>;
+    const encode: (obj: WakuMessage) => Uint8Array;
+    const decode: (buf: Uint8Array | Uint8ArrayList) => WakuMessage;
+}

package/dist/proto/store.js

@@ -0,0 +1,602 @@
+/* eslint-disable import/export */
+/* eslint-disable @typescript-eslint/no-namespace */
+import { encodeMessage, decodeMessage, message, enumeration, } from "protons-runtime";
+export var Index;
+(function (Index) {
+    let _codec;
+    Index.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.digest != null) {
+                    writer.uint32(10);
+                    writer.bytes(obj.digest);
+                }
+                if (obj.receivedTime != null) {
+                    writer.uint32(16);
+                    writer.sint64(obj.receivedTime);
+                }
+                if (obj.senderTime != null) {
+                    writer.uint32(24);
+                    writer.sint64(obj.senderTime);
+                }
+                if (obj.pubsubTopic != null) {
+                    writer.uint32(34);
+                    writer.string(obj.pubsubTopic);
+                }
+                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.digest = reader.bytes();
+                            break;
+                        case 2:
+                            obj.receivedTime = reader.sint64();
+                            break;
+                        case 3:
+                            obj.senderTime = reader.sint64();
+                            break;
+                        case 4:
+                            obj.pubsubTopic = reader.string();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    Index.encode = (obj) => {
+        return encodeMessage(obj, Index.codec());
+    };
+    Index.decode = (buf) => {
+        return decodeMessage(buf, Index.codec());
+    };
+})(Index || (Index = {}));
+export var PagingInfo;
+(function (PagingInfo) {
+    let Direction;
+    (function (Direction) {
+        Direction["DIRECTION_BACKWARD_UNSPECIFIED"] = "DIRECTION_BACKWARD_UNSPECIFIED";
+        Direction["DIRECTION_FORWARD"] = "DIRECTION_FORWARD";
+    })(Direction = PagingInfo.Direction || (PagingInfo.Direction = {}));
+    let __DirectionValues;
+    (function (__DirectionValues) {
+        __DirectionValues[__DirectionValues["DIRECTION_BACKWARD_UNSPECIFIED"] = 0] = "DIRECTION_BACKWARD_UNSPECIFIED";
+        __DirectionValues[__DirectionValues["DIRECTION_FORWARD"] = 1] = "DIRECTION_FORWARD";
+    })(__DirectionValues || (__DirectionValues = {}));
+    (function (Direction) {
+        Direction.codec = () => {
+            return enumeration(__DirectionValues);
+        };
+    })(Direction = PagingInfo.Direction || (PagingInfo.Direction = {}));
+    let _codec;
+    PagingInfo.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.pageSize != null) {
+                    writer.uint32(8);
+                    writer.uint64(obj.pageSize);
+                }
+                if (obj.cursor != null) {
+                    writer.uint32(18);
+                    Index.codec().encode(obj.cursor, writer);
+                }
+                if (obj.direction != null) {
+                    writer.uint32(24);
+                    PagingInfo.Direction.codec().encode(obj.direction, 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.pageSize = reader.uint64();
+                            break;
+                        case 2:
+                            obj.cursor = Index.codec().decode(reader, reader.uint32());
+                            break;
+                        case 3:
+                            obj.direction = PagingInfo.Direction.codec().decode(reader);
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    PagingInfo.encode = (obj) => {
+        return encodeMessage(obj, PagingInfo.codec());
+    };
+    PagingInfo.decode = (buf) => {
+        return decodeMessage(buf, PagingInfo.codec());
+    };
+})(PagingInfo || (PagingInfo = {}));
+export var ContentFilter;
+(function (ContentFilter) {
+    let _codec;
+    ContentFilter.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.contentTopic != null) {
+                    writer.uint32(10);
+                    writer.string(obj.contentTopic);
+                }
+                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.contentTopic = reader.string();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    ContentFilter.encode = (obj) => {
+        return encodeMessage(obj, ContentFilter.codec());
+    };
+    ContentFilter.decode = (buf) => {
+        return decodeMessage(buf, ContentFilter.codec());
+    };
+})(ContentFilter || (ContentFilter = {}));
+export var HistoryQuery;
+(function (HistoryQuery) {
+    let _codec;
+    HistoryQuery.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.pubSubTopic != null) {
+                    writer.uint32(18);
+                    writer.string(obj.pubSubTopic);
+                }
+                if (obj.contentFilters != null) {
+                    for (const value of obj.contentFilters) {
+                        writer.uint32(26);
+                        ContentFilter.codec().encode(value, writer);
+                    }
+                }
+                else {
+                    throw new Error('Protocol error: required field "contentFilters" was not found in object');
+                }
+                if (obj.pagingInfo != null) {
+                    writer.uint32(34);
+                    PagingInfo.codec().encode(obj.pagingInfo, writer);
+                }
+                if (obj.startTime != null) {
+                    writer.uint32(40);
+                    writer.sint64(obj.startTime);
+                }
+                if (obj.endTime != null) {
+                    writer.uint32(48);
+                    writer.sint64(obj.endTime);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    contentFilters: [],
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 2:
+                            obj.pubSubTopic = reader.string();
+                            break;
+                        case 3:
+                            obj.contentFilters.push(ContentFilter.codec().decode(reader, reader.uint32()));
+                            break;
+                        case 4:
+                            obj.pagingInfo = PagingInfo.codec().decode(reader, reader.uint32());
+                            break;
+                        case 5:
+                            obj.startTime = reader.sint64();
+                            break;
+                        case 6:
+                            obj.endTime = reader.sint64();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    HistoryQuery.encode = (obj) => {
+        return encodeMessage(obj, HistoryQuery.codec());
+    };
+    HistoryQuery.decode = (buf) => {
+        return decodeMessage(buf, HistoryQuery.codec());
+    };
+})(HistoryQuery || (HistoryQuery = {}));
+export var HistoryResponse;
+(function (HistoryResponse) {
+    let HistoryError;
+    (function (HistoryError) {
+        HistoryError["ERROR_NONE_UNSPECIFIED"] = "ERROR_NONE_UNSPECIFIED";
+        HistoryError["ERROR_INVALID_CURSOR"] = "ERROR_INVALID_CURSOR";
+    })(HistoryError = HistoryResponse.HistoryError || (HistoryResponse.HistoryError = {}));
+    let __HistoryErrorValues;
+    (function (__HistoryErrorValues) {
+        __HistoryErrorValues[__HistoryErrorValues["ERROR_NONE_UNSPECIFIED"] = 0] = "ERROR_NONE_UNSPECIFIED";
+        __HistoryErrorValues[__HistoryErrorValues["ERROR_INVALID_CURSOR"] = 1] = "ERROR_INVALID_CURSOR";
+    })(__HistoryErrorValues || (__HistoryErrorValues = {}));
+    (function (HistoryError) {
+        HistoryError.codec = () => {
+            return enumeration(__HistoryErrorValues);
+        };
+    })(HistoryError = HistoryResponse.HistoryError || (HistoryResponse.HistoryError = {}));
+    let _codec;
+    HistoryResponse.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.messages != null) {
+                    for (const value of obj.messages) {
+                        writer.uint32(18);
+                        WakuMessage.codec().encode(value, writer);
+                    }
+                }
+                else {
+                    throw new Error('Protocol error: required field "messages" was not found in object');
+                }
+                if (obj.pagingInfo != null) {
+                    writer.uint32(26);
+                    PagingInfo.codec().encode(obj.pagingInfo, writer);
+                }
+                if (obj.error != null) {
+                    writer.uint32(32);
+                    HistoryResponse.HistoryError.codec().encode(obj.error, writer);
+                }
+                if (opts.lengthDelimited !== false) {
+                    writer.ldelim();
+                }
+            }, (reader, length) => {
+                const obj = {
+                    messages: [],
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 2:
+                            obj.messages.push(WakuMessage.codec().decode(reader, reader.uint32()));
+                            break;
+                        case 3:
+                            obj.pagingInfo = PagingInfo.codec().decode(reader, reader.uint32());
+                            break;
+                        case 4:
+                            obj.error = HistoryResponse.HistoryError.codec().decode(reader);
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    HistoryResponse.encode = (obj) => {
+        return encodeMessage(obj, HistoryResponse.codec());
+    };
+    HistoryResponse.decode = (buf) => {
+        return decodeMessage(buf, HistoryResponse.codec());
+    };
+})(HistoryResponse || (HistoryResponse = {}));
+export var HistoryRPC;
+(function (HistoryRPC) {
+    let _codec;
+    HistoryRPC.codec = () => {
+        if (_codec == null) {
+            _codec = message((obj, writer, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    writer.fork();
+                }
+                if (obj.requestId != null) {
+                    writer.uint32(10);
+                    writer.string(obj.requestId);
+                }
+                if (obj.query != null) {
+                    writer.uint32(18);
+                    HistoryQuery.codec().encode(obj.query, writer);
+                }
+                if (obj.response != null) {
+                    writer.uint32(26);
+                    HistoryResponse.codec().encode(obj.response, 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.requestId = reader.string();
+                            break;
+                        case 2:
+                            obj.query = HistoryQuery.codec().decode(reader, reader.uint32());
+                            break;
+                        case 3:
+                            obj.response = HistoryResponse.codec().decode(reader, reader.uint32());
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    HistoryRPC.encode = (obj) => {
+        return encodeMessage(obj, HistoryRPC.codec());
+    };
+    HistoryRPC.decode = (buf) => {
+        return decodeMessage(buf, HistoryRPC.codec());
+    };
+})(HistoryRPC || (HistoryRPC = {}));
+export var RateLimitProof;
+(function (RateLimitProof) {
+    let _codec;
+    RateLimitProof.codec = () => {
+        if (_codec == null) {
+            _codec = message((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 = {}));
+export var WakuMessage;
+(function (WakuMessage) {
+    let _codec;
+    WakuMessage.codec = () => {
+        if (_codec == null) {
+            _codec = message((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 = {}));
+//# sourceMappingURL=store.js.map