@waku/rln 0.1.3-f6d5deb → 0.1.4-29a4c3f.0

package/bundle/node_modules/@ethersproject/abstract-signer/lib.esm/index.js

@@ -0,0 +1,302 @@
+import { defineReadOnly, resolveProperties, shallowCopy } from '../../properties/lib.esm/index.js';
+import { Logger } from '../../logger/lib.esm/index.js';
+import { version } from './_version.js';
+
+var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const logger = new Logger(version);
+const allowedTransactionKeys = [
+    "accessList", "ccipReadEnabled", "chainId", "customData", "data", "from", "gasLimit", "gasPrice", "maxFeePerGas", "maxPriorityFeePerGas", "nonce", "to", "type", "value"
+];
+const forwardErrors = [
+    Logger.errors.INSUFFICIENT_FUNDS,
+    Logger.errors.NONCE_EXPIRED,
+    Logger.errors.REPLACEMENT_UNDERPRICED,
+];
+class Signer {
+    ///////////////////
+    // Sub-classes MUST call super
+    constructor() {
+        logger.checkAbstract(new.target, Signer);
+        defineReadOnly(this, "_isSigner", true);
+    }
+    ///////////////////
+    // Sub-classes MAY override these
+    getBalance(blockTag) {
+        return __awaiter(this, undefined, undefined, function* () {
+            this._checkProvider("getBalance");
+            return yield this.provider.getBalance(this.getAddress(), blockTag);
+        });
+    }
+    getTransactionCount(blockTag) {
+        return __awaiter(this, undefined, undefined, function* () {
+            this._checkProvider("getTransactionCount");
+            return yield this.provider.getTransactionCount(this.getAddress(), blockTag);
+        });
+    }
+    // Populates "from" if unspecified, and estimates the gas for the transaction
+    estimateGas(transaction) {
+        return __awaiter(this, undefined, undefined, function* () {
+            this._checkProvider("estimateGas");
+            const tx = yield resolveProperties(this.checkTransaction(transaction));
+            return yield this.provider.estimateGas(tx);
+        });
+    }
+    // Populates "from" if unspecified, and calls with the transaction
+    call(transaction, blockTag) {
+        return __awaiter(this, undefined, undefined, function* () {
+            this._checkProvider("call");
+            const tx = yield resolveProperties(this.checkTransaction(transaction));
+            return yield this.provider.call(tx, blockTag);
+        });
+    }
+    // Populates all fields in a transaction, signs it and sends it to the network
+    sendTransaction(transaction) {
+        return __awaiter(this, undefined, undefined, function* () {
+            this._checkProvider("sendTransaction");
+            const tx = yield this.populateTransaction(transaction);
+            const signedTx = yield this.signTransaction(tx);
+            return yield this.provider.sendTransaction(signedTx);
+        });
+    }
+    getChainId() {
+        return __awaiter(this, undefined, undefined, function* () {
+            this._checkProvider("getChainId");
+            const network = yield this.provider.getNetwork();
+            return network.chainId;
+        });
+    }
+    getGasPrice() {
+        return __awaiter(this, undefined, undefined, function* () {
+            this._checkProvider("getGasPrice");
+            return yield this.provider.getGasPrice();
+        });
+    }
+    getFeeData() {
+        return __awaiter(this, undefined, undefined, function* () {
+            this._checkProvider("getFeeData");
+            return yield this.provider.getFeeData();
+        });
+    }
+    resolveName(name) {
+        return __awaiter(this, undefined, undefined, function* () {
+            this._checkProvider("resolveName");
+            return yield this.provider.resolveName(name);
+        });
+    }
+    // Checks a transaction does not contain invalid keys and if
+    // no "from" is provided, populates it.
+    // - does NOT require a provider
+    // - adds "from" is not present
+    // - returns a COPY (safe to mutate the result)
+    // By default called from: (overriding these prevents it)
+    //   - call
+    //   - estimateGas
+    //   - populateTransaction (and therefor sendTransaction)
+    checkTransaction(transaction) {
+        for (const key in transaction) {
+            if (allowedTransactionKeys.indexOf(key) === -1) {
+                logger.throwArgumentError("invalid transaction key: " + key, "transaction", transaction);
+            }
+        }
+        const tx = shallowCopy(transaction);
+        if (tx.from == null) {
+            tx.from = this.getAddress();
+        }
+        else {
+            // Make sure any provided address matches this signer
+            tx.from = Promise.all([
+                Promise.resolve(tx.from),
+                this.getAddress()
+            ]).then((result) => {
+                if (result[0].toLowerCase() !== result[1].toLowerCase()) {
+                    logger.throwArgumentError("from address mismatch", "transaction", transaction);
+                }
+                return result[0];
+            });
+        }
+        return tx;
+    }
+    // Populates ALL keys for a transaction and checks that "from" matches
+    // this Signer. Should be used by sendTransaction but NOT by signTransaction.
+    // By default called from: (overriding these prevents it)
+    //   - sendTransaction
+    //
+    // Notes:
+    //  - We allow gasPrice for EIP-1559 as long as it matches maxFeePerGas
+    populateTransaction(transaction) {
+        return __awaiter(this, undefined, undefined, function* () {
+            const tx = yield resolveProperties(this.checkTransaction(transaction));
+            if (tx.to != null) {
+                tx.to = Promise.resolve(tx.to).then((to) => __awaiter(this, undefined, undefined, function* () {
+                    if (to == null) {
+                        return null;
+                    }
+                    const address = yield this.resolveName(to);
+                    if (address == null) {
+                        logger.throwArgumentError("provided ENS name resolves to null", "tx.to", to);
+                    }
+                    return address;
+                }));
+                // Prevent this error from causing an UnhandledPromiseException
+                tx.to.catch((error) => { });
+            }
+            // Do not allow mixing pre-eip-1559 and eip-1559 properties
+            const hasEip1559 = (tx.maxFeePerGas != null || tx.maxPriorityFeePerGas != null);
+            if (tx.gasPrice != null && (tx.type === 2 || hasEip1559)) {
+                logger.throwArgumentError("eip-1559 transaction do not support gasPrice", "transaction", transaction);
+            }
+            else if ((tx.type === 0 || tx.type === 1) && hasEip1559) {
+                logger.throwArgumentError("pre-eip-1559 transaction do not support maxFeePerGas/maxPriorityFeePerGas", "transaction", transaction);
+            }
+            if ((tx.type === 2 || tx.type == null) && (tx.maxFeePerGas != null && tx.maxPriorityFeePerGas != null)) {
+                // Fully-formed EIP-1559 transaction (skip getFeeData)
+                tx.type = 2;
+            }
+            else if (tx.type === 0 || tx.type === 1) {
+                // Explicit Legacy or EIP-2930 transaction
+                // Populate missing gasPrice
+                if (tx.gasPrice == null) {
+                    tx.gasPrice = this.getGasPrice();
+                }
+            }
+            else {
+                // We need to get fee data to determine things
+                const feeData = yield this.getFeeData();
+                if (tx.type == null) {
+                    // We need to auto-detect the intended type of this transaction...
+                    if (feeData.maxFeePerGas != null && feeData.maxPriorityFeePerGas != null) {
+                        // The network supports EIP-1559!
+                        // Upgrade transaction from null to eip-1559
+                        tx.type = 2;
+                        if (tx.gasPrice != null) {
+                            // Using legacy gasPrice property on an eip-1559 network,
+                            // so use gasPrice as both fee properties
+                            const gasPrice = tx.gasPrice;
+                            delete tx.gasPrice;
+                            tx.maxFeePerGas = gasPrice;
+                            tx.maxPriorityFeePerGas = gasPrice;
+                        }
+                        else {
+                            // Populate missing fee data
+                            if (tx.maxFeePerGas == null) {
+                                tx.maxFeePerGas = feeData.maxFeePerGas;
+                            }
+                            if (tx.maxPriorityFeePerGas == null) {
+                                tx.maxPriorityFeePerGas = feeData.maxPriorityFeePerGas;
+                            }
+                        }
+                    }
+                    else if (feeData.gasPrice != null) {
+                        // Network doesn't support EIP-1559...
+                        // ...but they are trying to use EIP-1559 properties
+                        if (hasEip1559) {
+                            logger.throwError("network does not support EIP-1559", Logger.errors.UNSUPPORTED_OPERATION, {
+                                operation: "populateTransaction"
+                            });
+                        }
+                        // Populate missing fee data
+                        if (tx.gasPrice == null) {
+                            tx.gasPrice = feeData.gasPrice;
+                        }
+                        // Explicitly set untyped transaction to legacy
+                        tx.type = 0;
+                    }
+                    else {
+                        // getFeeData has failed us.
+                        logger.throwError("failed to get consistent fee data", Logger.errors.UNSUPPORTED_OPERATION, {
+                            operation: "signer.getFeeData"
+                        });
+                    }
+                }
+                else if (tx.type === 2) {
+                    // Explicitly using EIP-1559
+                    // Populate missing fee data
+                    if (tx.maxFeePerGas == null) {
+                        tx.maxFeePerGas = feeData.maxFeePerGas;
+                    }
+                    if (tx.maxPriorityFeePerGas == null) {
+                        tx.maxPriorityFeePerGas = feeData.maxPriorityFeePerGas;
+                    }
+                }
+            }
+            if (tx.nonce == null) {
+                tx.nonce = this.getTransactionCount("pending");
+            }
+            if (tx.gasLimit == null) {
+                tx.gasLimit = this.estimateGas(tx).catch((error) => {
+                    if (forwardErrors.indexOf(error.code) >= 0) {
+                        throw error;
+                    }
+                    return logger.throwError("cannot estimate gas; transaction may fail or may require manual gas limit", Logger.errors.UNPREDICTABLE_GAS_LIMIT, {
+                        error: error,
+                        tx: tx
+                    });
+                });
+            }
+            if (tx.chainId == null) {
+                tx.chainId = this.getChainId();
+            }
+            else {
+                tx.chainId = Promise.all([
+                    Promise.resolve(tx.chainId),
+                    this.getChainId()
+                ]).then((results) => {
+                    if (results[1] !== 0 && results[0] !== results[1]) {
+                        logger.throwArgumentError("chainId address mismatch", "transaction", transaction);
+                    }
+                    return results[0];
+                });
+            }
+            return yield resolveProperties(tx);
+        });
+    }
+    ///////////////////
+    // Sub-classes SHOULD leave these alone
+    _checkProvider(operation) {
+        if (!this.provider) {
+            logger.throwError("missing provider", Logger.errors.UNSUPPORTED_OPERATION, {
+                operation: (operation || "_checkProvider")
+            });
+        }
+    }
+    static isSigner(value) {
+        return !!(value && value._isSigner);
+    }
+}
+class VoidSigner extends Signer {
+    constructor(address, provider) {
+        super();
+        defineReadOnly(this, "address", address);
+        defineReadOnly(this, "provider", provider || null);
+    }
+    getAddress() {
+        return Promise.resolve(this.address);
+    }
+    _fail(message, operation) {
+        return Promise.resolve().then(() => {
+            logger.throwError(message, Logger.errors.UNSUPPORTED_OPERATION, { operation: operation });
+        });
+    }
+    signMessage(message) {
+        return this._fail("VoidSigner cannot sign messages", "signMessage");
+    }
+    signTransaction(transaction) {
+        return this._fail("VoidSigner cannot sign transactions", "signTransaction");
+    }
+    _signTypedData(domain, types, value) {
+        return this._fail("VoidSigner cannot sign typed data", "signTypedData");
+    }
+    connect(provider) {
+        return new VoidSigner(this.address, provider);
+    }
+}
+
+export { Signer, VoidSigner };

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

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

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

@@ -0,0 +1,110 @@
+import { stripZeros, arrayify, hexDataSlice, isHexString } from '../../bytes/lib.esm/index.js';
+import { keccak256 } from '../../keccak256/lib.esm/index.js';
+import { encode } from '../../rlp/lib.esm/index.js';
+import { Logger } from '../../logger/lib.esm/index.js';
+import { version } from './_version.js';
+import { _base36To16, BigNumber } from '../../bignumber/lib.esm/bignumber.js';
+
+const logger = new Logger(version);
+function getChecksumAddress(address) {
+    if (!isHexString(address, 20)) {
+        logger.throwArgumentError("invalid address", "address", address);
+    }
+    address = address.toLowerCase();
+    const chars = address.substring(2).split("");
+    const expanded = new Uint8Array(40);
+    for (let i = 0; i < 40; i++) {
+        expanded[i] = chars[i].charCodeAt(0);
+    }
+    const hashed = arrayify(keccak256(expanded));
+    for (let i = 0; i < 40; i += 2) {
+        if ((hashed[i >> 1] >> 4) >= 8) {
+            chars[i] = chars[i].toUpperCase();
+        }
+        if ((hashed[i >> 1] & 0x0f) >= 8) {
+            chars[i + 1] = chars[i + 1].toUpperCase();
+        }
+    }
+    return "0x" + chars.join("");
+}
+// Shims for environments that are missing some required constants and functions
+const MAX_SAFE_INTEGER = 0x1fffffffffffff;
+function log10(x) {
+    if (Math.log10) {
+        return Math.log10(x);
+    }
+    return Math.log(x) / Math.LN10;
+}
+// See: https://en.wikipedia.org/wiki/International_Bank_Account_Number
+// Create lookup table
+const ibanLookup = {};
+for (let i = 0; i < 10; i++) {
+    ibanLookup[String(i)] = String(i);
+}
+for (let i = 0; i < 26; i++) {
+    ibanLookup[String.fromCharCode(65 + i)] = String(10 + i);
+}
+// How many decimal digits can we process? (for 64-bit float, this is 15)
+const safeDigits = Math.floor(log10(MAX_SAFE_INTEGER));
+function ibanChecksum(address) {
+    address = address.toUpperCase();
+    address = address.substring(4) + address.substring(0, 2) + "00";
+    let expanded = address.split("").map((c) => { return ibanLookup[c]; }).join("");
+    // Javascript can handle integers safely up to 15 (decimal) digits
+    while (expanded.length >= safeDigits) {
+        let block = expanded.substring(0, safeDigits);
+        expanded = parseInt(block, 10) % 97 + expanded.substring(block.length);
+    }
+    let checksum = String(98 - (parseInt(expanded, 10) % 97));
+    while (checksum.length < 2) {
+        checksum = "0" + checksum;
+    }
+    return checksum;
+}
+function getAddress(address) {
+    let result = null;
+    if (typeof (address) !== "string") {
+        logger.throwArgumentError("invalid address", "address", address);
+    }
+    if (address.match(/^(0x)?[0-9a-fA-F]{40}$/)) {
+        // Missing the 0x prefix
+        if (address.substring(0, 2) !== "0x") {
+            address = "0x" + address;
+        }
+        result = getChecksumAddress(address);
+        // It is a checksummed address with a bad checksum
+        if (address.match(/([A-F].*[a-f])|([a-f].*[A-F])/) && result !== address) {
+            logger.throwArgumentError("bad address checksum", "address", address);
+        }
+        // Maybe ICAP? (we only support direct mode)
+    }
+    else if (address.match(/^XE[0-9]{2}[0-9A-Za-z]{30,31}$/)) {
+        // It is an ICAP address with a bad checksum
+        if (address.substring(2, 4) !== ibanChecksum(address)) {
+            logger.throwArgumentError("bad icap checksum", "address", address);
+        }
+        result = _base36To16(address.substring(4));
+        while (result.length < 40) {
+            result = "0" + result;
+        }
+        result = getChecksumAddress("0x" + result);
+    }
+    else {
+        logger.throwArgumentError("invalid address", "address", address);
+    }
+    return result;
+}
+// http://ethereum.stackexchange.com/questions/760/how-is-the-address-of-an-ethereum-contract-computed
+function getContractAddress(transaction) {
+    let from = null;
+    try {
+        from = getAddress(transaction.from);
+    }
+    catch (error) {
+        logger.throwArgumentError("missing from address", "transaction", transaction);
+    }
+    const nonce = stripZeros(arrayify(BigNumber.from(transaction.nonce).toHexString()));
+    return getAddress(hexDataSlice(keccak256(encode([from, nonce])), 12));
+}
+
+export { getAddress, getContractAddress };

package/bundle/node_modules/@ethersproject/base64/lib.esm/base64.js

@@ -0,0 +1,20 @@
+import { arrayify } from '../../bytes/lib.esm/index.js';
+
+function decode(textData) {
+    textData = atob(textData);
+    const data = [];
+    for (let i = 0; i < textData.length; i++) {
+        data.push(textData.charCodeAt(i));
+    }
+    return arrayify(data);
+}
+function encode(data) {
+    data = arrayify(data);
+    let textData = "";
+    for (let i = 0; i < data.length; i++) {
+        textData += String.fromCharCode(data[i]);
+    }
+    return btoa(textData);
+}
+
+export { decode, encode };

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

@@ -0,0 +1,120 @@
+import { arrayify } from '../../bytes/lib.esm/index.js';
+import { defineReadOnly } from '../../properties/lib.esm/index.js';
+
+/**
+ * var basex = require("base-x");
+ *
+ * This implementation is heavily based on base-x. The main reason to
+ * deviate was to prevent the dependency of Buffer.
+ *
+ * Contributors:
+ *
+ * base-x encoding
+ * Forked from https://github.com/cryptocoinjs/bs58
+ * Originally written by Mike Hearn for BitcoinJ
+ * Copyright (c) 2011 Google Inc
+ * Ported to JavaScript by Stefan Thomas
+ * Merged Buffer refactorings from base58-native by Stephen Pair
+ * Copyright (c) 2013 BitPay Inc
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright base-x contributors (c) 2016
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ *
+ */
+class BaseX {
+    constructor(alphabet) {
+        defineReadOnly(this, "alphabet", alphabet);
+        defineReadOnly(this, "base", alphabet.length);
+        defineReadOnly(this, "_alphabetMap", {});
+        defineReadOnly(this, "_leader", alphabet.charAt(0));
+        // pre-compute lookup table
+        for (let i = 0; i < alphabet.length; i++) {
+            this._alphabetMap[alphabet.charAt(i)] = i;
+        }
+    }
+    encode(value) {
+        let source = arrayify(value);
+        if (source.length === 0) {
+            return "";
+        }
+        let digits = [0];
+        for (let i = 0; i < source.length; ++i) {
+            let carry = source[i];
+            for (let j = 0; j < digits.length; ++j) {
+                carry += digits[j] << 8;
+                digits[j] = carry % this.base;
+                carry = (carry / this.base) | 0;
+            }
+            while (carry > 0) {
+                digits.push(carry % this.base);
+                carry = (carry / this.base) | 0;
+            }
+        }
+        let string = "";
+        // deal with leading zeros
+        for (let k = 0; source[k] === 0 && k < source.length - 1; ++k) {
+            string += this._leader;
+        }
+        // convert digits to a string
+        for (let q = digits.length - 1; q >= 0; --q) {
+            string += this.alphabet[digits[q]];
+        }
+        return string;
+    }
+    decode(value) {
+        if (typeof (value) !== "string") {
+            throw new TypeError("Expected String");
+        }
+        let bytes = [];
+        if (value.length === 0) {
+            return new Uint8Array(bytes);
+        }
+        bytes.push(0);
+        for (let i = 0; i < value.length; i++) {
+            let byte = this._alphabetMap[value[i]];
+            if (byte === undefined) {
+                throw new Error("Non-base" + this.base + " character");
+            }
+            let carry = byte;
+            for (let j = 0; j < bytes.length; ++j) {
+                carry += bytes[j] * this.base;
+                bytes[j] = carry & 0xff;
+                carry >>= 8;
+            }
+            while (carry > 0) {
+                bytes.push(carry & 0xff);
+                carry >>= 8;
+            }
+        }
+        // deal with leading zeros
+        for (let k = 0; value[k] === this._leader && k < value.length - 1; ++k) {
+            bytes.push(0);
+        }
+        return arrayify(new Uint8Array(bytes.reverse()));
+    }
+}
+new BaseX("abcdefghijklmnopqrstuvwxyz234567");
+const Base58 = new BaseX("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");
+//console.log(Base58.decode("Qmd2V777o5XvJbYMeMb8k2nU5f8d3ciUQ5YpYuWhzv8iDj"))
+//console.log(Base58.encode(Base58.decode("Qmd2V777o5XvJbYMeMb8k2nU5f8d3ciUQ5YpYuWhzv8iDj")))
+
+export { Base58, BaseX };

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

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