@waku/rln 0.1.3 → 0.1.4-d27db21.0

package/bundle/node_modules/@ethersproject/abi/lib.esm/_version.js

@@ -0,0 +1,3 @@
+const version = "abi/5.7.0";
+
+export { version };

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

@@ -0,0 +1,96 @@
+import { arrayify } 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 { Reader, Writer } from './coders/abstract-coder.js';
+import { AddressCoder } from './coders/address.js';
+import { ArrayCoder } from './coders/array.js';
+import { BooleanCoder } from './coders/boolean.js';
+import { BytesCoder } from './coders/bytes.js';
+import { FixedBytesCoder } from './coders/fixed-bytes.js';
+import { NullCoder } from './coders/null.js';
+import { NumberCoder } from './coders/number.js';
+import { StringCoder } from './coders/string.js';
+import { TupleCoder } from './coders/tuple.js';
+import { ParamType } from './fragments.js';
+
+const logger = new Logger(version);
+const paramTypeBytes = new RegExp(/^bytes([0-9]*)$/);
+const paramTypeNumber = new RegExp(/^(u?int)([0-9]*)$/);
+class AbiCoder {
+    constructor(coerceFunc) {
+        defineReadOnly(this, "coerceFunc", coerceFunc || null);
+    }
+    _getCoder(param) {
+        switch (param.baseType) {
+            case "address":
+                return new AddressCoder(param.name);
+            case "bool":
+                return new BooleanCoder(param.name);
+            case "string":
+                return new StringCoder(param.name);
+            case "bytes":
+                return new BytesCoder(param.name);
+            case "array":
+                return new ArrayCoder(this._getCoder(param.arrayChildren), param.arrayLength, param.name);
+            case "tuple":
+                return new TupleCoder((param.components || []).map((component) => {
+                    return this._getCoder(component);
+                }), param.name);
+            case "":
+                return new NullCoder(param.name);
+        }
+        // u?int[0-9]*
+        let match = param.type.match(paramTypeNumber);
+        if (match) {
+            let size = parseInt(match[2] || "256");
+            if (size === 0 || size > 256 || (size % 8) !== 0) {
+                logger.throwArgumentError("invalid " + match[1] + " bit length", "param", param);
+            }
+            return new NumberCoder(size / 8, (match[1] === "int"), param.name);
+        }
+        // bytes[0-9]+
+        match = param.type.match(paramTypeBytes);
+        if (match) {
+            let size = parseInt(match[1]);
+            if (size === 0 || size > 32) {
+                logger.throwArgumentError("invalid bytes length", "param", param);
+            }
+            return new FixedBytesCoder(size, param.name);
+        }
+        return logger.throwArgumentError("invalid type", "type", param.type);
+    }
+    _getWordSize() { return 32; }
+    _getReader(data, allowLoose) {
+        return new Reader(data, this._getWordSize(), this.coerceFunc, allowLoose);
+    }
+    _getWriter() {
+        return new Writer(this._getWordSize());
+    }
+    getDefaultValue(types) {
+        const coders = types.map((type) => this._getCoder(ParamType.from(type)));
+        const coder = new TupleCoder(coders, "_");
+        return coder.defaultValue();
+    }
+    encode(types, values) {
+        if (types.length !== values.length) {
+            logger.throwError("types/values length mismatch", Logger.errors.INVALID_ARGUMENT, {
+                count: { types: types.length, values: values.length },
+                value: { types: types, values: values }
+            });
+        }
+        const coders = types.map((type) => this._getCoder(ParamType.from(type)));
+        const coder = (new TupleCoder(coders, "_"));
+        const writer = this._getWriter();
+        coder.encode(writer, values);
+        return writer.data;
+    }
+    decode(types, data, loose) {
+        const coders = types.map((type) => this._getCoder(ParamType.from(type)));
+        const coder = new TupleCoder(coders, "_");
+        return coder.decode(this._getReader(arrayify(data), loose));
+    }
+}
+const defaultAbiCoder = new AbiCoder();
+
+export { AbiCoder, defaultAbiCoder };

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

@@ -0,0 +1,148 @@
+import { hexConcat, concat, arrayify, hexlify } 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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,210 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,19 @@
+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 };