@waku/rln 0.1.5-861a776.0 → 0.1.5-a824fff.0

package/bundle/node_modules/@ethersproject/abi/lib.esm/coders/abstract-coder.js

@@ -1,148 +0,0 @@
-import { arrayify, hexlify, hexConcat, concat } from '../../../bytes/lib.esm/index.js';
-import { defineReadOnly } from '../../../properties/lib.esm/index.js';
-import { Logger } from '../../../logger/lib.esm/index.js';
-import { version } from '../_version.js';
-import { BigNumber } from '../../../bignumber/lib.esm/bignumber.js';
-
-const logger = new Logger(version);
-function checkResultErrors(result) {
-    // Find the first error (if any)
-    const errors = [];
-    const checkErrors = function (path, object) {
-        if (!Array.isArray(object)) {
-            return;
-        }
-        for (let key in object) {
-            const childPath = path.slice();
-            childPath.push(key);
-            try {
-                checkErrors(childPath, object[key]);
-            }
-            catch (error) {
-                errors.push({ path: childPath, error: error });
-            }
-        }
-    };
-    checkErrors([], result);
-    return errors;
-}
-class Coder {
-    constructor(name, type, localName, dynamic) {
-        // @TODO: defineReadOnly these
-        this.name = name;
-        this.type = type;
-        this.localName = localName;
-        this.dynamic = dynamic;
-    }
-    _throwError(message, value) {
-        logger.throwArgumentError(message, this.localName, value);
-    }
-}
-class Writer {
-    constructor(wordSize) {
-        defineReadOnly(this, "wordSize", wordSize || 32);
-        this._data = [];
-        this._dataLength = 0;
-        this._padding = new Uint8Array(wordSize);
-    }
-    get data() {
-        return hexConcat(this._data);
-    }
-    get length() { return this._dataLength; }
-    _writeData(data) {
-        this._data.push(data);
-        this._dataLength += data.length;
-        return data.length;
-    }
-    appendWriter(writer) {
-        return this._writeData(concat(writer._data));
-    }
-    // Arrayish items; padded on the right to wordSize
-    writeBytes(value) {
-        let bytes = arrayify(value);
-        const paddingOffset = bytes.length % this.wordSize;
-        if (paddingOffset) {
-            bytes = concat([bytes, this._padding.slice(paddingOffset)]);
-        }
-        return this._writeData(bytes);
-    }
-    _getValue(value) {
-        let bytes = arrayify(BigNumber.from(value));
-        if (bytes.length > this.wordSize) {
-            logger.throwError("value out-of-bounds", Logger.errors.BUFFER_OVERRUN, {
-                length: this.wordSize,
-                offset: bytes.length
-            });
-        }
-        if (bytes.length % this.wordSize) {
-            bytes = concat([this._padding.slice(bytes.length % this.wordSize), bytes]);
-        }
-        return bytes;
-    }
-    // BigNumberish items; padded on the left to wordSize
-    writeValue(value) {
-        return this._writeData(this._getValue(value));
-    }
-    writeUpdatableValue() {
-        const offset = this._data.length;
-        this._data.push(this._padding);
-        this._dataLength += this.wordSize;
-        return (value) => {
-            this._data[offset] = this._getValue(value);
-        };
-    }
-}
-class Reader {
-    constructor(data, wordSize, coerceFunc, allowLoose) {
-        defineReadOnly(this, "_data", arrayify(data));
-        defineReadOnly(this, "wordSize", wordSize || 32);
-        defineReadOnly(this, "_coerceFunc", coerceFunc);
-        defineReadOnly(this, "allowLoose", allowLoose);
-        this._offset = 0;
-    }
-    get data() { return hexlify(this._data); }
-    get consumed() { return this._offset; }
-    // The default Coerce function
-    static coerce(name, value) {
-        let match = name.match("^u?int([0-9]+)$");
-        if (match && parseInt(match[1]) <= 48) {
-            value = value.toNumber();
-        }
-        return value;
-    }
-    coerce(name, value) {
-        if (this._coerceFunc) {
-            return this._coerceFunc(name, value);
-        }
-        return Reader.coerce(name, value);
-    }
-    _peekBytes(offset, length, loose) {
-        let alignedLength = Math.ceil(length / this.wordSize) * this.wordSize;
-        if (this._offset + alignedLength > this._data.length) {
-            if (this.allowLoose && loose && this._offset + length <= this._data.length) {
-                alignedLength = length;
-            }
-            else {
-                logger.throwError("data out-of-bounds", Logger.errors.BUFFER_OVERRUN, {
-                    length: this._data.length,
-                    offset: this._offset + alignedLength
-                });
-            }
-        }
-        return this._data.slice(this._offset, this._offset + alignedLength);
-    }
-    subReader(offset) {
-        return new Reader(this._data.slice(this._offset + offset), this.wordSize, this._coerceFunc, this.allowLoose);
-    }
-    readBytes(length, loose) {
-        let bytes = this._peekBytes(0, length, !!loose);
-        this._offset += bytes.length;
-        // @TODO: Make sure the length..end bytes are all 0?
-        return bytes.slice(0, length);
-    }
-    readValue() {
-        return BigNumber.from(this.readBytes(this.wordSize));
-    }
-}
-
-export { Coder, Reader, Writer, checkResultErrors };

package/bundle/node_modules/@ethersproject/abi/lib.esm/coders/address.js

@@ -1,26 +0,0 @@
-import { getAddress } from '../../../address/lib.esm/index.js';
-import { hexZeroPad } from '../../../bytes/lib.esm/index.js';
-import { Coder } from './abstract-coder.js';
-
-class AddressCoder extends Coder {
-    constructor(localName) {
-        super("address", "address", localName, false);
-    }
-    defaultValue() {
-        return "0x0000000000000000000000000000000000000000";
-    }
-    encode(writer, value) {
-        try {
-            value = getAddress(value);
-        }
-        catch (error) {
-            this._throwError(error.message, value);
-        }
-        return writer.writeValue(value);
-    }
-    decode(reader) {
-        return getAddress(hexZeroPad(reader.readValue().toHexString(), 20));
-    }
-}
-
-export { AddressCoder };

package/bundle/node_modules/@ethersproject/abi/lib.esm/coders/anonymous.js

@@ -1,20 +0,0 @@
-import { Coder } from './abstract-coder.js';
-
-// Clones the functionality of an existing Coder, but without a localName
-class AnonymousCoder extends Coder {
-    constructor(coder) {
-        super(coder.name, coder.type, undefined, coder.dynamic);
-        this.coder = coder;
-    }
-    defaultValue() {
-        return this.coder.defaultValue();
-    }
-    encode(writer, value) {
-        return this.coder.encode(writer, value);
-    }
-    decode(reader) {
-        return this.coder.decode(reader);
-    }
-}
-
-export { AnonymousCoder };

package/bundle/node_modules/@ethersproject/abi/lib.esm/coders/array.js

@@ -1,210 +0,0 @@
-import { Logger } from '../../../logger/lib.esm/index.js';
-import { version } from '../_version.js';
-import { Coder, Writer } from './abstract-coder.js';
-import { AnonymousCoder } from './anonymous.js';
-
-const logger = new Logger(version);
-function pack(writer, coders, values) {
-    let arrayValues = null;
-    if (Array.isArray(values)) {
-        arrayValues = values;
-    }
-    else if (values && typeof (values) === "object") {
-        let unique = {};
-        arrayValues = coders.map((coder) => {
-            const name = coder.localName;
-            if (!name) {
-                logger.throwError("cannot encode object for signature with missing names", Logger.errors.INVALID_ARGUMENT, {
-                    argument: "values",
-                    coder: coder,
-                    value: values
-                });
-            }
-            if (unique[name]) {
-                logger.throwError("cannot encode object for signature with duplicate names", Logger.errors.INVALID_ARGUMENT, {
-                    argument: "values",
-                    coder: coder,
-                    value: values
-                });
-            }
-            unique[name] = true;
-            return values[name];
-        });
-    }
-    else {
-        logger.throwArgumentError("invalid tuple value", "tuple", values);
-    }
-    if (coders.length !== arrayValues.length) {
-        logger.throwArgumentError("types/value length mismatch", "tuple", values);
-    }
-    let staticWriter = new Writer(writer.wordSize);
-    let dynamicWriter = new Writer(writer.wordSize);
-    let updateFuncs = [];
-    coders.forEach((coder, index) => {
-        let value = arrayValues[index];
-        if (coder.dynamic) {
-            // Get current dynamic offset (for the future pointer)
-            let dynamicOffset = dynamicWriter.length;
-            // Encode the dynamic value into the dynamicWriter
-            coder.encode(dynamicWriter, value);
-            // Prepare to populate the correct offset once we are done
-            let updateFunc = staticWriter.writeUpdatableValue();
-            updateFuncs.push((baseOffset) => {
-                updateFunc(baseOffset + dynamicOffset);
-            });
-        }
-        else {
-            coder.encode(staticWriter, value);
-        }
-    });
-    // Backfill all the dynamic offsets, now that we know the static length
-    updateFuncs.forEach((func) => { func(staticWriter.length); });
-    let length = writer.appendWriter(staticWriter);
-    length += writer.appendWriter(dynamicWriter);
-    return length;
-}
-function unpack(reader, coders) {
-    let values = [];
-    // A reader anchored to this base
-    let baseReader = reader.subReader(0);
-    coders.forEach((coder) => {
-        let value = null;
-        if (coder.dynamic) {
-            let offset = reader.readValue();
-            let offsetReader = baseReader.subReader(offset.toNumber());
-            try {
-                value = coder.decode(offsetReader);
-            }
-            catch (error) {
-                // Cannot recover from this
-                if (error.code === Logger.errors.BUFFER_OVERRUN) {
-                    throw error;
-                }
-                value = error;
-                value.baseType = coder.name;
-                value.name = coder.localName;
-                value.type = coder.type;
-            }
-        }
-        else {
-            try {
-                value = coder.decode(reader);
-            }
-            catch (error) {
-                // Cannot recover from this
-                if (error.code === Logger.errors.BUFFER_OVERRUN) {
-                    throw error;
-                }
-                value = error;
-                value.baseType = coder.name;
-                value.name = coder.localName;
-                value.type = coder.type;
-            }
-        }
-        if (value != undefined) {
-            values.push(value);
-        }
-    });
-    // We only output named properties for uniquely named coders
-    const uniqueNames = coders.reduce((accum, coder) => {
-        const name = coder.localName;
-        if (name) {
-            if (!accum[name]) {
-                accum[name] = 0;
-            }
-            accum[name]++;
-        }
-        return accum;
-    }, {});
-    // Add any named parameters (i.e. tuples)
-    coders.forEach((coder, index) => {
-        let name = coder.localName;
-        if (!name || uniqueNames[name] !== 1) {
-            return;
-        }
-        if (name === "length") {
-            name = "_length";
-        }
-        if (values[name] != null) {
-            return;
-        }
-        const value = values[index];
-        if (value instanceof Error) {
-            Object.defineProperty(values, name, {
-                enumerable: true,
-                get: () => { throw value; }
-            });
-        }
-        else {
-            values[name] = value;
-        }
-    });
-    for (let i = 0; i < values.length; i++) {
-        const value = values[i];
-        if (value instanceof Error) {
-            Object.defineProperty(values, i, {
-                enumerable: true,
-                get: () => { throw value; }
-            });
-        }
-    }
-    return Object.freeze(values);
-}
-class ArrayCoder extends Coder {
-    constructor(coder, length, localName) {
-        const type = (coder.type + "[" + (length >= 0 ? length : "") + "]");
-        const dynamic = (length === -1 || coder.dynamic);
-        super("array", type, localName, dynamic);
-        this.coder = coder;
-        this.length = length;
-    }
-    defaultValue() {
-        // Verifies the child coder is valid (even if the array is dynamic or 0-length)
-        const defaultChild = this.coder.defaultValue();
-        const result = [];
-        for (let i = 0; i < this.length; i++) {
-            result.push(defaultChild);
-        }
-        return result;
-    }
-    encode(writer, value) {
-        if (!Array.isArray(value)) {
-            this._throwError("expected array value", value);
-        }
-        let count = this.length;
-        if (count === -1) {
-            count = value.length;
-            writer.writeValue(value.length);
-        }
-        logger.checkArgumentCount(value.length, count, "coder array" + (this.localName ? (" " + this.localName) : ""));
-        let coders = [];
-        for (let i = 0; i < value.length; i++) {
-            coders.push(this.coder);
-        }
-        return pack(writer, coders, value);
-    }
-    decode(reader) {
-        let count = this.length;
-        if (count === -1) {
-            count = reader.readValue().toNumber();
-            // Check that there is *roughly* enough data to ensure
-            // stray random data is not being read as a length. Each
-            // slot requires at least 32 bytes for their value (or 32
-            // bytes as a link to the data). This could use a much
-            // tighter bound, but we are erroring on the side of safety.
-            if (count * 32 > reader._data.length) {
-                logger.throwError("insufficient data length", Logger.errors.BUFFER_OVERRUN, {
-                    length: reader._data.length,
-                    count: count
-                });
-            }
-        }
-        let coders = [];
-        for (let i = 0; i < count; i++) {
-            coders.push(new AnonymousCoder(this.coder));
-        }
-        return reader.coerce(this.name, unpack(reader, coders));
-    }
-}
-
-export { ArrayCoder, pack, unpack };

package/bundle/node_modules/@ethersproject/abi/lib.esm/coders/boolean.js

@@ -1,18 +0,0 @@
-import { Coder } from './abstract-coder.js';
-
-class BooleanCoder extends Coder {
-    constructor(localName) {
-        super("bool", "bool", localName, false);
-    }
-    defaultValue() {
-        return false;
-    }
-    encode(writer, value) {
-        return writer.writeValue(value ? 1 : 0);
-    }
-    decode(reader) {
-        return reader.coerce(this.type, !reader.readValue().isZero());
-    }
-}
-
-export { BooleanCoder };

package/bundle/node_modules/@ethersproject/abi/lib.esm/coders/bytes.js

@@ -1,30 +0,0 @@
-import { hexlify, arrayify } from '../../../bytes/lib.esm/index.js';
-import { Coder } from './abstract-coder.js';
-
-class DynamicBytesCoder extends Coder {
-    constructor(type, localName) {
-        super(type, type, localName, true);
-    }
-    defaultValue() {
-        return "0x";
-    }
-    encode(writer, value) {
-        value = arrayify(value);
-        let length = writer.writeValue(value.length);
-        length += writer.writeBytes(value);
-        return length;
-    }
-    decode(reader) {
-        return reader.readBytes(reader.readValue().toNumber(), true);
-    }
-}
-class BytesCoder extends DynamicBytesCoder {
-    constructor(localName) {
-        super("bytes", localName);
-    }
-    decode(reader) {
-        return reader.coerce(this.name, hexlify(super.decode(reader)));
-    }
-}
-
-export { BytesCoder, DynamicBytesCoder };

package/bundle/node_modules/@ethersproject/abi/lib.esm/coders/fixed-bytes.js

@@ -1,26 +0,0 @@
-import { arrayify, hexlify } from '../../../bytes/lib.esm/index.js';
-import { Coder } from './abstract-coder.js';
-
-// @TODO: Merge this with bytes
-class FixedBytesCoder extends Coder {
-    constructor(size, localName) {
-        let name = "bytes" + String(size);
-        super(name, name, localName, false);
-        this.size = size;
-    }
-    defaultValue() {
-        return ("0x0000000000000000000000000000000000000000000000000000000000000000").substring(0, 2 + this.size * 2);
-    }
-    encode(writer, value) {
-        let data = arrayify(value);
-        if (data.length !== this.size) {
-            this._throwError("incorrect data length", value);
-        }
-        return writer.writeBytes(data);
-    }
-    decode(reader) {
-        return reader.coerce(this.name, hexlify(reader.readBytes(this.size)));
-    }
-}
-
-export { FixedBytesCoder };

package/bundle/node_modules/@ethersproject/abi/lib.esm/coders/null.js

@@ -1,22 +0,0 @@
-import { Coder } from './abstract-coder.js';
-
-class NullCoder extends Coder {
-    constructor(localName) {
-        super("null", "", localName, false);
-    }
-    defaultValue() {
-        return null;
-    }
-    encode(writer, value) {
-        if (value != null) {
-            this._throwError("not null", value);
-        }
-        return writer.writeBytes([]);
-    }
-    decode(reader) {
-        reader.readBytes(0);
-        return reader.coerce(this.name, null);
-    }
-}
-
-export { NullCoder };

package/bundle/node_modules/@ethersproject/abi/lib.esm/coders/number.js

@@ -1,43 +0,0 @@
-import { Coder } from './abstract-coder.js';
-import { BigNumber } from '../../../bignumber/lib.esm/bignumber.js';
-import { MaxUint256, One, NegativeOne, Zero } from '../../../constants/lib.esm/bignumbers.js';
-
-class NumberCoder extends Coder {
-    constructor(size, signed, localName) {
-        const name = ((signed ? "int" : "uint") + (size * 8));
-        super(name, name, localName, false);
-        this.size = size;
-        this.signed = signed;
-    }
-    defaultValue() {
-        return 0;
-    }
-    encode(writer, value) {
-        let v = BigNumber.from(value);
-        // Check bounds are safe for encoding
-        let maxUintValue = MaxUint256.mask(writer.wordSize * 8);
-        if (this.signed) {
-            let bounds = maxUintValue.mask(this.size * 8 - 1);
-            if (v.gt(bounds) || v.lt(bounds.add(One).mul(NegativeOne))) {
-                this._throwError("value out-of-bounds", value);
-            }
-        }
-        else if (v.lt(Zero) || v.gt(maxUintValue.mask(this.size * 8))) {
-            this._throwError("value out-of-bounds", value);
-        }
-        v = v.toTwos(this.size * 8).mask(this.size * 8);
-        if (this.signed) {
-            v = v.fromTwos(this.size * 8).toTwos(8 * writer.wordSize);
-        }
-        return writer.writeValue(v);
-    }
-    decode(reader) {
-        let value = reader.readValue().mask(this.size * 8);
-        if (this.signed) {
-            value = value.fromTwos(this.size * 8);
-        }
-        return reader.coerce(this.name, value);
-    }
-}
-
-export { NumberCoder };

package/bundle/node_modules/@ethersproject/abi/lib.esm/coders/string.js

@@ -1,19 +0,0 @@
-import { toUtf8Bytes, toUtf8String } from '../../../strings/lib.esm/utf8.js';
-import { DynamicBytesCoder } from './bytes.js';
-
-class StringCoder extends DynamicBytesCoder {
-    constructor(localName) {
-        super("string", localName);
-    }
-    defaultValue() {
-        return "";
-    }
-    encode(writer, value) {
-        return super.encode(writer, toUtf8Bytes(value));
-    }
-    decode(reader) {
-        return toUtf8String(super.decode(reader));
-    }
-}
-
-export { StringCoder };

package/bundle/node_modules/@ethersproject/abi/lib.esm/coders/tuple.js

@@ -1,58 +0,0 @@
-import { Coder } from './abstract-coder.js';
-import { pack, unpack } from './array.js';
-
-class TupleCoder extends Coder {
-    constructor(coders, localName) {
-        let dynamic = false;
-        const types = [];
-        coders.forEach((coder) => {
-            if (coder.dynamic) {
-                dynamic = true;
-            }
-            types.push(coder.type);
-        });
-        const type = ("tuple(" + types.join(",") + ")");
-        super("tuple", type, localName, dynamic);
-        this.coders = coders;
-    }
-    defaultValue() {
-        const values = [];
-        this.coders.forEach((coder) => {
-            values.push(coder.defaultValue());
-        });
-        // We only output named properties for uniquely named coders
-        const uniqueNames = this.coders.reduce((accum, coder) => {
-            const name = coder.localName;
-            if (name) {
-                if (!accum[name]) {
-                    accum[name] = 0;
-                }
-                accum[name]++;
-            }
-            return accum;
-        }, {});
-        // Add named values
-        this.coders.forEach((coder, index) => {
-            let name = coder.localName;
-            if (!name || uniqueNames[name] !== 1) {
-                return;
-            }
-            if (name === "length") {
-                name = "_length";
-            }
-            if (values[name] != null) {
-                return;
-            }
-            values[name] = values[index];
-        });
-        return Object.freeze(values);
-    }
-    encode(writer, value) {
-        return pack(writer, this.coders, value);
-    }
-    decode(reader) {
-        return reader.coerce(this.name, unpack(reader, this.coders));
-    }
-}
-
-export { TupleCoder };