@waku/rln 0.0.1 → 0.0.2-00f2e75.0

package/bundle/node_modules/protons-runtime/dist/src/utils/writer.js

@@ -0,0 +1,438 @@
+import { encodeUint8Array, encodingLength } from '../../../../uint8-varint/dist/src/index.js';
+import { allocUnsafe } from '../../../../uint8arrays/dist/src/alloc.js';
+import { fromString } from '../../../../uint8arrays/dist/src/from-string.js';
+import { writeFloatLE, writeDoubleLE } from './float.js';
+import { LongBits } from './longbits.js';
+import pool from './pool.js';
+import { length, write } from './utf8.js';
+
+/**
+ * Constructs a new writer operation instance.
+ *
+ * @classdesc Scheduled writer operation
+ */
+class Op {
+    /**
+     * Function to call
+     */
+    fn;
+    /**
+     * Value byte length
+     */
+    len;
+    /**
+     * Next operation
+     */
+    next;
+    /**
+     * Value to write
+     */
+    val;
+    constructor(fn, len, val) {
+        this.fn = fn;
+        this.len = len;
+        this.next = undefined;
+        this.val = val; // type varies
+    }
+}
+/* istanbul ignore next */
+function noop() { } // eslint-disable-line no-empty-function
+/**
+ * Constructs a new writer state instance
+ */
+class State {
+    /**
+     * Current head
+     */
+    head;
+    /**
+     * Current tail
+     */
+    tail;
+    /**
+     * Current buffer length
+     */
+    len;
+    /**
+     * Next state
+     */
+    next;
+    constructor(writer) {
+        this.head = writer.head;
+        this.tail = writer.tail;
+        this.len = writer.len;
+        this.next = writer.states;
+    }
+}
+const bufferPool = pool();
+/**
+ * Allocates a buffer of the specified size
+ */
+function alloc(size) {
+    if (globalThis.Buffer != null) {
+        return allocUnsafe(size);
+    }
+    return bufferPool(size);
+}
+/**
+ * When a value is written, the writer calculates its byte length and puts it into a linked
+ * list of operations to perform when finish() is called. This both allows us to allocate
+ * buffers of the exact required size and reduces the amount of work we have to do compared
+ * to first calculating over objects and then encoding over objects. In our case, the encoding
+ * part is just a linked list walk calling operations with already prepared values.
+ */
+class Uint8ArrayWriter {
+    /**
+     * Current length
+     */
+    len;
+    /**
+     * Operations head
+     */
+    head;
+    /**
+     * Operations tail
+     */
+    tail;
+    /**
+     * Linked forked states
+     */
+    states;
+    constructor() {
+        this.len = 0;
+        this.head = new Op(noop, 0, 0);
+        this.tail = this.head;
+        this.states = null;
+    }
+    /**
+     * Pushes a new operation to the queue
+     */
+    _push(fn, len, val) {
+        this.tail = this.tail.next = new Op(fn, len, val);
+        this.len += len;
+        return this;
+    }
+    /**
+     * Writes an unsigned 32 bit value as a varint
+     */
+    uint32(value) {
+        // here, the call to this.push has been inlined and a varint specific Op subclass is used.
+        // uint32 is by far the most frequently used operation and benefits significantly from this.
+        this.len += (this.tail = this.tail.next = new VarintOp((value = value >>> 0) <
+            128
+            ? 1
+            : value < 16384
+                ? 2
+                : value < 2097152
+                    ? 3
+                    : value < 268435456
+                        ? 4
+                        : 5, value)).len;
+        return this;
+    }
+    /**
+     * Writes a signed 32 bit value as a varint`
+     */
+    int32(value) {
+        return value < 0
+            ? this._push(writeVarint64, 10, LongBits.fromNumber(value)) // 10 bytes per spec
+            : this.uint32(value);
+    }
+    /**
+     * Writes a 32 bit value as a varint, zig-zag encoded
+     */
+    sint32(value) {
+        return this.uint32((value << 1 ^ value >> 31) >>> 0);
+    }
+    /**
+     * Writes an unsigned 64 bit value as a varint
+     */
+    uint64(value) {
+        const bits = LongBits.fromBigInt(value);
+        return this._push(writeVarint64, bits.length(), bits);
+    }
+    /**
+     * Writes an unsigned 64 bit value as a varint
+     */
+    uint64Number(value) {
+        return this._push(encodeUint8Array, encodingLength(value), value);
+    }
+    /**
+     * Writes an unsigned 64 bit value as a varint
+     */
+    uint64String(value) {
+        return this.uint64(BigInt(value));
+    }
+    /**
+     * Writes a signed 64 bit value as a varint
+     */
+    int64(value) {
+        return this.uint64(value);
+    }
+    /**
+     * Writes a signed 64 bit value as a varint
+     */
+    int64Number(value) {
+        return this.uint64Number(value);
+    }
+    /**
+     * Writes a signed 64 bit value as a varint
+     */
+    int64String(value) {
+        return this.uint64String(value);
+    }
+    /**
+     * Writes a signed 64 bit value as a varint, zig-zag encoded
+     */
+    sint64(value) {
+        const bits = LongBits.fromBigInt(value).zzEncode();
+        return this._push(writeVarint64, bits.length(), bits);
+    }
+    /**
+     * Writes a signed 64 bit value as a varint, zig-zag encoded
+     */
+    sint64Number(value) {
+        const bits = LongBits.fromNumber(value).zzEncode();
+        return this._push(writeVarint64, bits.length(), bits);
+    }
+    /**
+     * Writes a signed 64 bit value as a varint, zig-zag encoded
+     */
+    sint64String(value) {
+        return this.sint64(BigInt(value));
+    }
+    /**
+     * Writes a boolish value as a varint
+     */
+    bool(value) {
+        return this._push(writeByte, 1, value ? 1 : 0);
+    }
+    /**
+     * Writes an unsigned 32 bit value as fixed 32 bits
+     */
+    fixed32(value) {
+        return this._push(writeFixed32, 4, value >>> 0);
+    }
+    /**
+     * Writes a signed 32 bit value as fixed 32 bits
+     */
+    sfixed32(value) {
+        return this.fixed32(value);
+    }
+    /**
+     * Writes an unsigned 64 bit value as fixed 64 bits
+     */
+    fixed64(value) {
+        const bits = LongBits.fromBigInt(value);
+        return this._push(writeFixed32, 4, bits.lo)._push(writeFixed32, 4, bits.hi);
+    }
+    /**
+     * Writes an unsigned 64 bit value as fixed 64 bits
+     */
+    fixed64Number(value) {
+        const bits = LongBits.fromNumber(value);
+        return this._push(writeFixed32, 4, bits.lo)._push(writeFixed32, 4, bits.hi);
+    }
+    /**
+     * Writes an unsigned 64 bit value as fixed 64 bits
+     */
+    fixed64String(value) {
+        return this.fixed64(BigInt(value));
+    }
+    /**
+     * Writes a signed 64 bit value as fixed 64 bits
+     */
+    sfixed64(value) {
+        return this.fixed64(value);
+    }
+    /**
+     * Writes a signed 64 bit value as fixed 64 bits
+     */
+    sfixed64Number(value) {
+        return this.fixed64Number(value);
+    }
+    /**
+     * Writes a signed 64 bit value as fixed 64 bits
+     */
+    sfixed64String(value) {
+        return this.fixed64String(value);
+    }
+    /**
+     * Writes a float (32 bit)
+     */
+    float(value) {
+        return this._push(writeFloatLE, 4, value);
+    }
+    /**
+     * Writes a double (64 bit float).
+     *
+     * @function
+     * @param {number} value - Value to write
+     * @returns {Writer} `this`
+     */
+    double(value) {
+        return this._push(writeDoubleLE, 8, value);
+    }
+    /**
+     * Writes a sequence of bytes
+     */
+    bytes(value) {
+        const len = value.length >>> 0;
+        if (len === 0) {
+            return this._push(writeByte, 1, 0);
+        }
+        return this.uint32(len)._push(writeBytes, len, value);
+    }
+    /**
+     * Writes a string
+     */
+    string(value) {
+        const len = length(value);
+        return len !== 0
+            ? this.uint32(len)._push(write, len, value)
+            : this._push(writeByte, 1, 0);
+    }
+    /**
+     * Forks this writer's state by pushing it to a stack.
+     * Calling {@link Writer#reset|reset} or {@link Writer#ldelim|ldelim} resets the writer to the previous state.
+     */
+    fork() {
+        this.states = new State(this);
+        this.head = this.tail = new Op(noop, 0, 0);
+        this.len = 0;
+        return this;
+    }
+    /**
+     * Resets this instance to the last state
+     */
+    reset() {
+        if (this.states != null) {
+            this.head = this.states.head;
+            this.tail = this.states.tail;
+            this.len = this.states.len;
+            this.states = this.states.next;
+        }
+        else {
+            this.head = this.tail = new Op(noop, 0, 0);
+            this.len = 0;
+        }
+        return this;
+    }
+    /**
+     * Resets to the last state and appends the fork state's current write length as a varint followed by its operations.
+     */
+    ldelim() {
+        const head = this.head;
+        const tail = this.tail;
+        const len = this.len;
+        this.reset().uint32(len);
+        if (len !== 0) {
+            this.tail.next = head.next; // skip noop
+            this.tail = tail;
+            this.len += len;
+        }
+        return this;
+    }
+    /**
+     * Finishes the write operation
+     */
+    finish() {
+        let head = this.head.next; // skip noop
+        const buf = alloc(this.len);
+        let pos = 0;
+        while (head != null) {
+            head.fn(head.val, buf, pos);
+            pos += head.len;
+            head = head.next;
+        }
+        // this.head = this.tail = null;
+        return buf;
+    }
+}
+function writeByte(val, buf, pos) {
+    buf[pos] = val & 255;
+}
+function writeVarint32(val, buf, pos) {
+    while (val > 127) {
+        buf[pos++] = val & 127 | 128;
+        val >>>= 7;
+    }
+    buf[pos] = val;
+}
+/**
+ * Constructs a new varint writer operation instance.
+ *
+ * @classdesc Scheduled varint writer operation
+ */
+class VarintOp extends Op {
+    next;
+    constructor(len, val) {
+        super(writeVarint32, len, val);
+        this.next = undefined;
+    }
+}
+function writeVarint64(val, buf, pos) {
+    while (val.hi !== 0) {
+        buf[pos++] = val.lo & 127 | 128;
+        val.lo = (val.lo >>> 7 | val.hi << 25) >>> 0;
+        val.hi >>>= 7;
+    }
+    while (val.lo > 127) {
+        buf[pos++] = val.lo & 127 | 128;
+        val.lo = val.lo >>> 7;
+    }
+    buf[pos++] = val.lo;
+}
+function writeFixed32(val, buf, pos) {
+    buf[pos] = val & 255;
+    buf[pos + 1] = val >>> 8 & 255;
+    buf[pos + 2] = val >>> 16 & 255;
+    buf[pos + 3] = val >>> 24;
+}
+function writeBytes(val, buf, pos) {
+    buf.set(val, pos);
+}
+if (globalThis.Buffer != null) {
+    Uint8ArrayWriter.prototype.bytes = function (value) {
+        const len = value.length >>> 0;
+        this.uint32(len);
+        if (len > 0) {
+            this._push(writeBytesBuffer, len, value);
+        }
+        return this;
+    };
+    Uint8ArrayWriter.prototype.string = function (value) {
+        const len = globalThis.Buffer.byteLength(value);
+        this.uint32(len);
+        if (len > 0) {
+            this._push(writeStringBuffer, len, value);
+        }
+        return this;
+    };
+}
+function writeBytesBuffer(val, buf, pos) {
+    buf.set(val, pos); // faster than copy (requires node >= 4 where Buffers extend Uint8Array and set is properly inherited)
+    // also works for plain array values
+}
+function writeStringBuffer(val, buf, pos) {
+    if (val.length < 40) {
+        // plain js is faster for short strings (probably due to redundant assertions)
+        write(val, buf, pos);
+        // @ts-expect-error buf isn't a Uint8Array?
+    }
+    else if (buf.utf8Write != null) {
+        // @ts-expect-error buf isn't a Uint8Array?
+        buf.utf8Write(val, pos);
+    }
+    else {
+        buf.set(fromString(val), pos);
+    }
+}
+/**
+ * Creates a new writer
+ */
+function createWriter() {
+    return new Uint8ArrayWriter();
+}
+
+export { createWriter };

package/bundle/node_modules/uint8-varint/dist/src/index.js

@@ -0,0 +1,124 @@
+/* eslint-disable no-fallthrough */
+const N1 = Math.pow(2, 7);
+const N2 = Math.pow(2, 14);
+const N3 = Math.pow(2, 21);
+const N4 = Math.pow(2, 28);
+const N5 = Math.pow(2, 35);
+const N6 = Math.pow(2, 42);
+const N7 = Math.pow(2, 49);
+/** Most significant bit of a byte */
+const MSB = 0x80;
+/** Rest of the bits in a byte */
+const REST = 0x7f;
+function encodingLength(value) {
+    if (value < N1) {
+        return 1;
+    }
+    if (value < N2) {
+        return 2;
+    }
+    if (value < N3) {
+        return 3;
+    }
+    if (value < N4) {
+        return 4;
+    }
+    if (value < N5) {
+        return 5;
+    }
+    if (value < N6) {
+        return 6;
+    }
+    if (value < N7) {
+        return 7;
+    }
+    if (Number.MAX_SAFE_INTEGER != null && value > Number.MAX_SAFE_INTEGER) {
+        throw new RangeError('Could not encode varint');
+    }
+    return 8;
+}
+function encodeUint8Array(value, buf, offset = 0) {
+    switch (encodingLength(value)) {
+        case 8: {
+            buf[offset++] = (value & 0xFF) | MSB;
+            value /= 128;
+        }
+        case 7: {
+            buf[offset++] = (value & 0xFF) | MSB;
+            value /= 128;
+        }
+        case 6: {
+            buf[offset++] = (value & 0xFF) | MSB;
+            value /= 128;
+        }
+        case 5: {
+            buf[offset++] = (value & 0xFF) | MSB;
+            value /= 128;
+        }
+        case 4: {
+            buf[offset++] = (value & 0xFF) | MSB;
+            value >>>= 7;
+        }
+        case 3: {
+            buf[offset++] = (value & 0xFF) | MSB;
+            value >>>= 7;
+        }
+        case 2: {
+            buf[offset++] = (value & 0xFF) | MSB;
+            value >>>= 7;
+        }
+        case 1: {
+            buf[offset++] = (value & 0xFF);
+            value >>>= 7;
+            break;
+        }
+        default: throw new Error('unreachable');
+    }
+    return buf;
+}
+function decodeUint8Array(buf, offset) {
+    let b = buf[offset];
+    let res = 0;
+    res += b & REST;
+    if (b < MSB) {
+        return res;
+    }
+    b = buf[offset + 1];
+    res += (b & REST) << 7;
+    if (b < MSB) {
+        return res;
+    }
+    b = buf[offset + 2];
+    res += (b & REST) << 14;
+    if (b < MSB) {
+        return res;
+    }
+    b = buf[offset + 3];
+    res += (b & REST) << 21;
+    if (b < MSB) {
+        return res;
+    }
+    b = buf[offset + 4];
+    res += (b & REST) * N4;
+    if (b < MSB) {
+        return res;
+    }
+    b = buf[offset + 5];
+    res += (b & REST) * N5;
+    if (b < MSB) {
+        return res;
+    }
+    b = buf[offset + 6];
+    res += (b & REST) * N6;
+    if (b < MSB) {
+        return res;
+    }
+    b = buf[offset + 7];
+    res += (b & REST) * N7;
+    if (b < MSB) {
+        return res;
+    }
+    throw new RangeError('Could not decode varint');
+}
+
+export { decodeUint8Array, encodeUint8Array, encodingLength };

package/bundle/node_modules/uint8arrays/dist/src/alloc.js

@@ -0,0 +1,17 @@
+/**
+ * Returns a `Uint8Array` of the requested size. Referenced memory will
+ * be initialized to 0.
+ */
+function alloc(size = 0) {
+    return new Uint8Array(size);
+}
+/**
+ * Where possible returns a Uint8Array of the requested size that references
+ * uninitialized memory. Only use if you are certain you will immediately
+ * overwrite every value in the returned `Uint8Array`.
+ */
+function allocUnsafe(size = 0) {
+    return new Uint8Array(size);
+}
+
+export { alloc, allocUnsafe };

package/bundle/node_modules/uint8arrays/dist/src/from-string.js

@@ -0,0 +1,19 @@
+import BASES from './util/bases.js';
+
+/**
+ * Create a `Uint8Array` from the passed string
+ *
+ * Supports `utf8`, `utf-8`, `hex`, and any encoding supported by the multiformats module.
+ *
+ * Also `ascii` which is similar to node's 'binary' encoding.
+ */
+function fromString(string, encoding = 'utf8') {
+    const base = BASES[encoding];
+    if (base == null) {
+        throw new Error(`Unsupported encoding "${encoding}"`);
+    }
+    // add multibase prefix
+    return base.decoder.decode(`${base.prefix}${string}`); // eslint-disable-line @typescript-eslint/restrict-template-expressions
+}
+
+export { fromString };

package/bundle/node_modules/uint8arrays/dist/src/util/bases.js

@@ -0,0 +1,49 @@
+import { bases } from '../../../../multiformats/dist/src/basics.js';
+import { allocUnsafe } from '../alloc.js';
+
+function createCodec(name, prefix, encode, decode) {
+    return {
+        name,
+        prefix,
+        encoder: {
+            name,
+            prefix,
+            encode
+        },
+        decoder: {
+            decode
+        }
+    };
+}
+const string = createCodec('utf8', 'u', (buf) => {
+    const decoder = new TextDecoder('utf8');
+    return 'u' + decoder.decode(buf);
+}, (str) => {
+    const encoder = new TextEncoder();
+    return encoder.encode(str.substring(1));
+});
+const ascii = createCodec('ascii', 'a', (buf) => {
+    let string = 'a';
+    for (let i = 0; i < buf.length; i++) {
+        string += String.fromCharCode(buf[i]);
+    }
+    return string;
+}, (str) => {
+    str = str.substring(1);
+    const buf = allocUnsafe(str.length);
+    for (let i = 0; i < str.length; i++) {
+        buf[i] = str.charCodeAt(i);
+    }
+    return buf;
+});
+const BASES = {
+    utf8: string,
+    'utf-8': string,
+    hex: bases.base16,
+    latin1: ascii,
+    ascii,
+    binary: ascii,
+    ...bases
+};
+
+export { BASES as default };

package/bundle/packages/core/dist/lib/connection_manager/connection_manager.js

@@ -0,0 +1,21 @@
+import '../../../../../node_modules/@multiformats/multiaddr/dist/src/multiaddr.js';
+import '../../../../../node_modules/@multiformats/multiaddr/dist/src/protocols-table.js';
+import '../../../../../node_modules/@multiformats/multiaddr/dist/src/convert.js';
+import '../../../../interfaces/dist/protocols.js';
+import '../../../../interfaces/dist/connection_manager.js';
+import '../../../../interfaces/dist/health_indicator.js';
+import '../../../../../node_modules/multiformats/dist/src/bases/base10.js';
+import '../../../../../node_modules/multiformats/dist/src/bases/base16.js';
+import '../../../../../node_modules/multiformats/dist/src/bases/base2.js';
+import '../../../../../node_modules/multiformats/dist/src/bases/base256emoji.js';
+import '../../../../../node_modules/multiformats/dist/src/bases/base32.js';
+import '../../../../../node_modules/multiformats/dist/src/bases/base36.js';
+import '../../../../../node_modules/multiformats/dist/src/bases/base58.js';
+import '../../../../../node_modules/multiformats/dist/src/bases/base64.js';
+import '../../../../../node_modules/multiformats/dist/src/bases/base8.js';
+import '../../../../../node_modules/multiformats/dist/src/bases/identity.js';
+import '../../../../../node_modules/multiformats/dist/src/codecs/json.js';
+import { Logger } from '../../../../utils/dist/logger/index.js';
+import './keep_alive_manager.js';
+
+new Logger("connection-manager");

package/bundle/packages/core/dist/lib/connection_manager/keep_alive_manager.js

@@ -0,0 +1,18 @@
+import '../../../../interfaces/dist/protocols.js';
+import '../../../../interfaces/dist/connection_manager.js';
+import '../../../../interfaces/dist/health_indicator.js';
+import '../../../../../node_modules/multiformats/dist/src/bases/base10.js';
+import '../../../../../node_modules/multiformats/dist/src/bases/base16.js';
+import '../../../../../node_modules/multiformats/dist/src/bases/base2.js';
+import '../../../../../node_modules/multiformats/dist/src/bases/base256emoji.js';
+import '../../../../../node_modules/multiformats/dist/src/bases/base32.js';
+import '../../../../../node_modules/multiformats/dist/src/bases/base36.js';
+import '../../../../../node_modules/multiformats/dist/src/bases/base58.js';
+import '../../../../../node_modules/multiformats/dist/src/bases/base64.js';
+import '../../../../../node_modules/multiformats/dist/src/bases/base8.js';
+import '../../../../../node_modules/multiformats/dist/src/bases/identity.js';
+import '../../../../../node_modules/multiformats/dist/src/codecs/json.js';
+import { Logger } from '../../../../utils/dist/logger/index.js';
+import '../message/version_0.js';
+
+new Logger("keep-alive");