@waku/rln 0.1.4 → 0.1.5-164df63.0

package/bundle/node_modules/@ethersproject/logger/lib.esm/index.js

@@ -1,352 +0,0 @@
-import { version } from './_version.js';
-
-let _permanentCensorErrors = false;
-let _censorErrors = false;
-const LogLevels = { debug: 1, "default": 2, info: 2, warning: 3, error: 4, off: 5 };
-let _logLevel = LogLevels["default"];
-let _globalLogger = null;
-function _checkNormalize() {
-    try {
-        const missing = [];
-        // Make sure all forms of normalization are supported
-        ["NFD", "NFC", "NFKD", "NFKC"].forEach((form) => {
-            try {
-                if ("test".normalize(form) !== "test") {
-                    throw new Error("bad normalize");
-                }
-                ;
-            }
-            catch (error) {
-                missing.push(form);
-            }
-        });
-        if (missing.length) {
-            throw new Error("missing " + missing.join(", "));
-        }
-        if (String.fromCharCode(0xe9).normalize("NFD") !== String.fromCharCode(0x65, 0x0301)) {
-            throw new Error("broken implementation");
-        }
-    }
-    catch (error) {
-        return error.message;
-    }
-    return null;
-}
-const _normalizeError = _checkNormalize();
-var LogLevel;
-(function (LogLevel) {
-    LogLevel["DEBUG"] = "DEBUG";
-    LogLevel["INFO"] = "INFO";
-    LogLevel["WARNING"] = "WARNING";
-    LogLevel["ERROR"] = "ERROR";
-    LogLevel["OFF"] = "OFF";
-})(LogLevel || (LogLevel = {}));
-var ErrorCode;
-(function (ErrorCode) {
-    ///////////////////
-    // Generic Errors
-    // Unknown Error
-    ErrorCode["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
-    // Not Implemented
-    ErrorCode["NOT_IMPLEMENTED"] = "NOT_IMPLEMENTED";
-    // Unsupported Operation
-    //   - operation
-    ErrorCode["UNSUPPORTED_OPERATION"] = "UNSUPPORTED_OPERATION";
-    // Network Error (i.e. Ethereum Network, such as an invalid chain ID)
-    //   - event ("noNetwork" is not re-thrown in provider.ready; otherwise thrown)
-    ErrorCode["NETWORK_ERROR"] = "NETWORK_ERROR";
-    // Some sort of bad response from the server
-    ErrorCode["SERVER_ERROR"] = "SERVER_ERROR";
-    // Timeout
-    ErrorCode["TIMEOUT"] = "TIMEOUT";
-    ///////////////////
-    // Operational  Errors
-    // Buffer Overrun
-    ErrorCode["BUFFER_OVERRUN"] = "BUFFER_OVERRUN";
-    // Numeric Fault
-    //   - operation: the operation being executed
-    //   - fault: the reason this faulted
-    ErrorCode["NUMERIC_FAULT"] = "NUMERIC_FAULT";
-    ///////////////////
-    // Argument Errors
-    // Missing new operator to an object
-    //  - name: The name of the class
-    ErrorCode["MISSING_NEW"] = "MISSING_NEW";
-    // Invalid argument (e.g. value is incompatible with type) to a function:
-    //   - argument: The argument name that was invalid
-    //   - value: The value of the argument
-    ErrorCode["INVALID_ARGUMENT"] = "INVALID_ARGUMENT";
-    // Missing argument to a function:
-    //   - count: The number of arguments received
-    //   - expectedCount: The number of arguments expected
-    ErrorCode["MISSING_ARGUMENT"] = "MISSING_ARGUMENT";
-    // Too many arguments
-    //   - count: The number of arguments received
-    //   - expectedCount: The number of arguments expected
-    ErrorCode["UNEXPECTED_ARGUMENT"] = "UNEXPECTED_ARGUMENT";
-    ///////////////////
-    // Blockchain Errors
-    // Call exception
-    //  - transaction: the transaction
-    //  - address?: the contract address
-    //  - args?: The arguments passed into the function
-    //  - method?: The Solidity method signature
-    //  - errorSignature?: The EIP848 error signature
-    //  - errorArgs?: The EIP848 error parameters
-    //  - reason: The reason (only for EIP848 "Error(string)")
-    ErrorCode["CALL_EXCEPTION"] = "CALL_EXCEPTION";
-    // Insufficient funds (< value + gasLimit * gasPrice)
-    //   - transaction: the transaction attempted
-    ErrorCode["INSUFFICIENT_FUNDS"] = "INSUFFICIENT_FUNDS";
-    // Nonce has already been used
-    //   - transaction: the transaction attempted
-    ErrorCode["NONCE_EXPIRED"] = "NONCE_EXPIRED";
-    // The replacement fee for the transaction is too low
-    //   - transaction: the transaction attempted
-    ErrorCode["REPLACEMENT_UNDERPRICED"] = "REPLACEMENT_UNDERPRICED";
-    // The gas limit could not be estimated
-    //   - transaction: the transaction passed to estimateGas
-    ErrorCode["UNPREDICTABLE_GAS_LIMIT"] = "UNPREDICTABLE_GAS_LIMIT";
-    // The transaction was replaced by one with a higher gas price
-    //   - reason: "cancelled", "replaced" or "repriced"
-    //   - cancelled: true if reason == "cancelled" or reason == "replaced")
-    //   - hash: original transaction hash
-    //   - replacement: the full TransactionsResponse for the replacement
-    //   - receipt: the receipt of the replacement
-    ErrorCode["TRANSACTION_REPLACED"] = "TRANSACTION_REPLACED";
-    ///////////////////
-    // Interaction Errors
-    // The user rejected the action, such as signing a message or sending
-    // a transaction
-    ErrorCode["ACTION_REJECTED"] = "ACTION_REJECTED";
-})(ErrorCode || (ErrorCode = {}));
-const HEX = "0123456789abcdef";
-class Logger {
-    constructor(version) {
-        Object.defineProperty(this, "version", {
-            enumerable: true,
-            value: version,
-            writable: false
-        });
-    }
-    _log(logLevel, args) {
-        const level = logLevel.toLowerCase();
-        if (LogLevels[level] == null) {
-            this.throwArgumentError("invalid log level name", "logLevel", logLevel);
-        }
-        if (_logLevel > LogLevels[level]) {
-            return;
-        }
-        console.log.apply(console, args);
-    }
-    debug(...args) {
-        this._log(Logger.levels.DEBUG, args);
-    }
-    info(...args) {
-        this._log(Logger.levels.INFO, args);
-    }
-    warn(...args) {
-        this._log(Logger.levels.WARNING, args);
-    }
-    makeError(message, code, params) {
-        // Errors are being censored
-        if (_censorErrors) {
-            return this.makeError("censored error", code, {});
-        }
-        if (!code) {
-            code = Logger.errors.UNKNOWN_ERROR;
-        }
-        if (!params) {
-            params = {};
-        }
-        const messageDetails = [];
-        Object.keys(params).forEach((key) => {
-            const value = params[key];
-            try {
-                if (value instanceof Uint8Array) {
-                    let hex = "";
-                    for (let i = 0; i < value.length; i++) {
-                        hex += HEX[value[i] >> 4];
-                        hex += HEX[value[i] & 0x0f];
-                    }
-                    messageDetails.push(key + "=Uint8Array(0x" + hex + ")");
-                }
-                else {
-                    messageDetails.push(key + "=" + JSON.stringify(value));
-                }
-            }
-            catch (error) {
-                messageDetails.push(key + "=" + JSON.stringify(params[key].toString()));
-            }
-        });
-        messageDetails.push(`code=${code}`);
-        messageDetails.push(`version=${this.version}`);
-        const reason = message;
-        let url = "";
-        switch (code) {
-            case ErrorCode.NUMERIC_FAULT: {
-                url = "NUMERIC_FAULT";
-                const fault = message;
-                switch (fault) {
-                    case "overflow":
-                    case "underflow":
-                    case "division-by-zero":
-                        url += "-" + fault;
-                        break;
-                    case "negative-power":
-                    case "negative-width":
-                        url += "-unsupported";
-                        break;
-                    case "unbound-bitwise-result":
-                        url += "-unbound-result";
-                        break;
-                }
-                break;
-            }
-            case ErrorCode.CALL_EXCEPTION:
-            case ErrorCode.INSUFFICIENT_FUNDS:
-            case ErrorCode.MISSING_NEW:
-            case ErrorCode.NONCE_EXPIRED:
-            case ErrorCode.REPLACEMENT_UNDERPRICED:
-            case ErrorCode.TRANSACTION_REPLACED:
-            case ErrorCode.UNPREDICTABLE_GAS_LIMIT:
-                url = code;
-                break;
-        }
-        if (url) {
-            message += " [ See: https:/\/links.ethers.org/v5-errors-" + url + " ]";
-        }
-        if (messageDetails.length) {
-            message += " (" + messageDetails.join(", ") + ")";
-        }
-        // @TODO: Any??
-        const error = new Error(message);
-        error.reason = reason;
-        error.code = code;
-        Object.keys(params).forEach(function (key) {
-            error[key] = params[key];
-        });
-        return error;
-    }
-    throwError(message, code, params) {
-        throw this.makeError(message, code, params);
-    }
-    throwArgumentError(message, name, value) {
-        return this.throwError(message, Logger.errors.INVALID_ARGUMENT, {
-            argument: name,
-            value: value
-        });
-    }
-    assert(condition, message, code, params) {
-        if (!!condition) {
-            return;
-        }
-        this.throwError(message, code, params);
-    }
-    assertArgument(condition, message, name, value) {
-        if (!!condition) {
-            return;
-        }
-        this.throwArgumentError(message, name, value);
-    }
-    checkNormalize(message) {
-        if (_normalizeError) {
-            this.throwError("platform missing String.prototype.normalize", Logger.errors.UNSUPPORTED_OPERATION, {
-                operation: "String.prototype.normalize", form: _normalizeError
-            });
-        }
-    }
-    checkSafeUint53(value, message) {
-        if (typeof (value) !== "number") {
-            return;
-        }
-        if (message == null) {
-            message = "value not safe";
-        }
-        if (value < 0 || value >= 0x1fffffffffffff) {
-            this.throwError(message, Logger.errors.NUMERIC_FAULT, {
-                operation: "checkSafeInteger",
-                fault: "out-of-safe-range",
-                value: value
-            });
-        }
-        if (value % 1) {
-            this.throwError(message, Logger.errors.NUMERIC_FAULT, {
-                operation: "checkSafeInteger",
-                fault: "non-integer",
-                value: value
-            });
-        }
-    }
-    checkArgumentCount(count, expectedCount, message) {
-        if (message) {
-            message = ": " + message;
-        }
-        else {
-            message = "";
-        }
-        if (count < expectedCount) {
-            this.throwError("missing argument" + message, Logger.errors.MISSING_ARGUMENT, {
-                count: count,
-                expectedCount: expectedCount
-            });
-        }
-        if (count > expectedCount) {
-            this.throwError("too many arguments" + message, Logger.errors.UNEXPECTED_ARGUMENT, {
-                count: count,
-                expectedCount: expectedCount
-            });
-        }
-    }
-    checkNew(target, kind) {
-        if (target === Object || target == null) {
-            this.throwError("missing new", Logger.errors.MISSING_NEW, { name: kind.name });
-        }
-    }
-    checkAbstract(target, kind) {
-        if (target === kind) {
-            this.throwError("cannot instantiate abstract class " + JSON.stringify(kind.name) + " directly; use a sub-class", Logger.errors.UNSUPPORTED_OPERATION, { name: target.name, operation: "new" });
-        }
-        else if (target === Object || target == null) {
-            this.throwError("missing new", Logger.errors.MISSING_NEW, { name: kind.name });
-        }
-    }
-    static globalLogger() {
-        if (!_globalLogger) {
-            _globalLogger = new Logger(version);
-        }
-        return _globalLogger;
-    }
-    static setCensorship(censorship, permanent) {
-        if (!censorship && permanent) {
-            this.globalLogger().throwError("cannot permanently disable censorship", Logger.errors.UNSUPPORTED_OPERATION, {
-                operation: "setCensorship"
-            });
-        }
-        if (_permanentCensorErrors) {
-            if (!censorship) {
-                return;
-            }
-            this.globalLogger().throwError("error censorship permanent", Logger.errors.UNSUPPORTED_OPERATION, {
-                operation: "setCensorship"
-            });
-        }
-        _censorErrors = !!censorship;
-        _permanentCensorErrors = !!permanent;
-    }
-    static setLogLevel(logLevel) {
-        const level = LogLevels[logLevel.toLowerCase()];
-        if (level == null) {
-            Logger.globalLogger().warn("invalid log level - " + logLevel);
-            return;
-        }
-        _logLevel = level;
-    }
-    static from(version) {
-        return new Logger(version);
-    }
-}
-Logger.errors = ErrorCode;
-Logger.levels = LogLevel;
-
-export { ErrorCode, LogLevel, Logger };

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

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

package/bundle/node_modules/@ethersproject/networks/lib.esm/index.js

@@ -1,266 +0,0 @@
-import { Logger } from '../../logger/lib.esm/index.js';
-import { version } from './_version.js';
-
-const logger = new Logger(version);
-function isRenetworkable(value) {
-    return (value && typeof (value.renetwork) === "function");
-}
-function ethDefaultProvider(network) {
-    const func = function (providers, options) {
-        if (options == null) {
-            options = {};
-        }
-        const providerList = [];
-        if (providers.InfuraProvider && options.infura !== "-") {
-            try {
-                providerList.push(new providers.InfuraProvider(network, options.infura));
-            }
-            catch (error) { }
-        }
-        if (providers.EtherscanProvider && options.etherscan !== "-") {
-            try {
-                providerList.push(new providers.EtherscanProvider(network, options.etherscan));
-            }
-            catch (error) { }
-        }
-        if (providers.AlchemyProvider && options.alchemy !== "-") {
-            try {
-                providerList.push(new providers.AlchemyProvider(network, options.alchemy));
-            }
-            catch (error) { }
-        }
-        if (providers.PocketProvider && options.pocket !== "-") {
-            // These networks are currently faulty on Pocket as their
-            // network does not handle the Berlin hardfork, which is
-            // live on these ones.
-            // @TODO: This goes away once Pocket has upgraded their nodes
-            const skip = ["goerli", "ropsten", "rinkeby", "sepolia"];
-            try {
-                const provider = new providers.PocketProvider(network, options.pocket);
-                if (provider.network && skip.indexOf(provider.network.name) === -1) {
-                    providerList.push(provider);
-                }
-            }
-            catch (error) { }
-        }
-        if (providers.CloudflareProvider && options.cloudflare !== "-") {
-            try {
-                providerList.push(new providers.CloudflareProvider(network));
-            }
-            catch (error) { }
-        }
-        if (providers.AnkrProvider && options.ankr !== "-") {
-            try {
-                const skip = ["ropsten"];
-                const provider = new providers.AnkrProvider(network, options.ankr);
-                if (provider.network && skip.indexOf(provider.network.name) === -1) {
-                    providerList.push(provider);
-                }
-            }
-            catch (error) { }
-        }
-        if (providers.QuickNodeProvider && options.quicknode !== "-") {
-            try {
-                providerList.push(new providers.QuickNodeProvider(network, options.quicknode));
-            }
-            catch (error) { }
-        }
-        if (providerList.length === 0) {
-            return null;
-        }
-        if (providers.FallbackProvider) {
-            let quorum = 1;
-            if (options.quorum != null) {
-                quorum = options.quorum;
-            }
-            else if (network === "homestead") {
-                quorum = 2;
-            }
-            return new providers.FallbackProvider(providerList, quorum);
-        }
-        return providerList[0];
-    };
-    func.renetwork = function (network) {
-        return ethDefaultProvider(network);
-    };
-    return func;
-}
-function etcDefaultProvider(url, network) {
-    const func = function (providers, options) {
-        if (providers.JsonRpcProvider) {
-            return new providers.JsonRpcProvider(url, network);
-        }
-        return null;
-    };
-    func.renetwork = function (network) {
-        return etcDefaultProvider(url, network);
-    };
-    return func;
-}
-const homestead = {
-    chainId: 1,
-    ensAddress: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e",
-    name: "homestead",
-    _defaultProvider: ethDefaultProvider("homestead")
-};
-const ropsten = {
-    chainId: 3,
-    ensAddress: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e",
-    name: "ropsten",
-    _defaultProvider: ethDefaultProvider("ropsten")
-};
-const classicMordor = {
-    chainId: 63,
-    name: "classicMordor",
-    _defaultProvider: etcDefaultProvider("https://www.ethercluster.com/mordor", "classicMordor")
-};
-// See: https://chainlist.org
-const networks = {
-    unspecified: { chainId: 0, name: "unspecified" },
-    homestead: homestead,
-    mainnet: homestead,
-    morden: { chainId: 2, name: "morden" },
-    ropsten: ropsten,
-    testnet: ropsten,
-    rinkeby: {
-        chainId: 4,
-        ensAddress: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e",
-        name: "rinkeby",
-        _defaultProvider: ethDefaultProvider("rinkeby")
-    },
-    kovan: {
-        chainId: 42,
-        name: "kovan",
-        _defaultProvider: ethDefaultProvider("kovan")
-    },
-    goerli: {
-        chainId: 5,
-        ensAddress: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e",
-        name: "goerli",
-        _defaultProvider: ethDefaultProvider("goerli")
-    },
-    kintsugi: { chainId: 1337702, name: "kintsugi" },
-    sepolia: {
-        chainId: 11155111,
-        ensAddress: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e",
-        name: "sepolia",
-        _defaultProvider: ethDefaultProvider("sepolia")
-    },
-    holesky: {
-        chainId: 17000,
-        name: "holesky",
-        _defaultProvider: ethDefaultProvider("holesky")
-    },
-    // ETC (See: #351)
-    classic: {
-        chainId: 61,
-        name: "classic",
-        _defaultProvider: etcDefaultProvider("https:/\/www.ethercluster.com/etc", "classic")
-    },
-    classicMorden: { chainId: 62, name: "classicMorden" },
-    classicMordor: classicMordor,
-    classicTestnet: classicMordor,
-    classicKotti: {
-        chainId: 6,
-        name: "classicKotti",
-        _defaultProvider: etcDefaultProvider("https:/\/www.ethercluster.com/kotti", "classicKotti")
-    },
-    xdai: { chainId: 100, name: "xdai" },
-    matic: {
-        chainId: 137,
-        name: "matic",
-        _defaultProvider: ethDefaultProvider("matic")
-    },
-    maticmum: {
-        chainId: 80001,
-        name: "maticmum",
-        _defaultProvider: ethDefaultProvider("maticmum")
-    },
-    optimism: {
-        chainId: 10,
-        name: "optimism",
-        _defaultProvider: ethDefaultProvider("optimism")
-    },
-    "optimism-kovan": { chainId: 69, name: "optimism-kovan" },
-    "optimism-goerli": { chainId: 420, name: "optimism-goerli" },
-    "optimism-sepolia": { chainId: 11155420, name: "optimism-sepolia" },
-    arbitrum: { chainId: 42161, name: "arbitrum" },
-    "arbitrum-rinkeby": { chainId: 421611, name: "arbitrum-rinkeby" },
-    "arbitrum-goerli": { chainId: 421613, name: "arbitrum-goerli" },
-    "arbitrum-sepolia": { chainId: 421614, name: "arbitrum-sepolia" },
-    bnb: { chainId: 56, name: "bnb" },
-    bnbt: { chainId: 97, name: "bnbt" },
-};
-/**
- *  getNetwork
- *
- *  Converts a named common networks or chain ID (network ID) to a Network
- *  and verifies a network is a valid Network..
- */
-function getNetwork(network) {
-    // No network (null)
-    if (network == null) {
-        return null;
-    }
-    if (typeof (network) === "number") {
-        for (const name in networks) {
-            const standard = networks[name];
-            if (standard.chainId === network) {
-                return {
-                    name: standard.name,
-                    chainId: standard.chainId,
-                    ensAddress: (standard.ensAddress || null),
-                    _defaultProvider: (standard._defaultProvider || null)
-                };
-            }
-        }
-        return {
-            chainId: network,
-            name: "unknown"
-        };
-    }
-    if (typeof (network) === "string") {
-        const standard = networks[network];
-        if (standard == null) {
-            return null;
-        }
-        return {
-            name: standard.name,
-            chainId: standard.chainId,
-            ensAddress: standard.ensAddress,
-            _defaultProvider: (standard._defaultProvider || null)
-        };
-    }
-    const standard = networks[network.name];
-    // Not a standard network; check that it is a valid network in general
-    if (!standard) {
-        if (typeof (network.chainId) !== "number") {
-            logger.throwArgumentError("invalid network chainId", "network", network);
-        }
-        return network;
-    }
-    // Make sure the chainId matches the expected network chainId (or is 0; disable EIP-155)
-    if (network.chainId !== 0 && network.chainId !== standard.chainId) {
-        logger.throwArgumentError("network chainId mismatch", "network", network);
-    }
-    // @TODO: In the next major version add an attach function to a defaultProvider
-    // class and move the _defaultProvider internal to this file (extend Network)
-    let defaultProvider = network._defaultProvider || null;
-    if (defaultProvider == null && standard._defaultProvider) {
-        if (isRenetworkable(standard._defaultProvider)) {
-            defaultProvider = standard._defaultProvider.renetwork(network);
-        }
-        else {
-            defaultProvider = standard._defaultProvider;
-        }
-    }
-    // Standard Network (allow overriding the ENS address)
-    return {
-        name: network.name,
-        chainId: standard.chainId,
-        ensAddress: (network.ensAddress || standard.ensAddress || null),
-        _defaultProvider: defaultProvider
-    };
-}
-
-export { getNetwork };

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

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