@waku/rln 0.1.5-1e590d7.0 → 0.1.5-3038c48.0

package/bundle/node_modules/@ethersproject/providers/lib.esm/web3-provider.js

@@ -0,0 +1,132 @@
+import { defineReadOnly, deepCopy } from '../../properties/lib.esm/index.js';
+import { Logger } from '../../logger/lib.esm/index.js';
+import { version } from './_version.js';
+import { JsonRpcProvider } from './json-rpc-provider.js';
+
+const logger = new Logger(version);
+let _nextId = 1;
+function buildWeb3LegacyFetcher(provider, sendFunc) {
+    const fetcher = "Web3LegacyFetcher";
+    return function (method, params) {
+        const request = {
+            method: method,
+            params: params,
+            id: (_nextId++),
+            jsonrpc: "2.0"
+        };
+        return new Promise((resolve, reject) => {
+            this.emit("debug", {
+                action: "request",
+                fetcher,
+                request: deepCopy(request),
+                provider: this
+            });
+            sendFunc(request, (error, response) => {
+                if (error) {
+                    this.emit("debug", {
+                        action: "response",
+                        fetcher,
+                        error,
+                        request,
+                        provider: this
+                    });
+                    return reject(error);
+                }
+                this.emit("debug", {
+                    action: "response",
+                    fetcher,
+                    request,
+                    response,
+                    provider: this
+                });
+                if (response.error) {
+                    const error = new Error(response.error.message);
+                    error.code = response.error.code;
+                    error.data = response.error.data;
+                    return reject(error);
+                }
+                resolve(response.result);
+            });
+        });
+    };
+}
+function buildEip1193Fetcher(provider) {
+    return function (method, params) {
+        if (params == null) {
+            params = [];
+        }
+        const request = { method, params };
+        this.emit("debug", {
+            action: "request",
+            fetcher: "Eip1193Fetcher",
+            request: deepCopy(request),
+            provider: this
+        });
+        return provider.request(request).then((response) => {
+            this.emit("debug", {
+                action: "response",
+                fetcher: "Eip1193Fetcher",
+                request,
+                response,
+                provider: this
+            });
+            return response;
+        }, (error) => {
+            this.emit("debug", {
+                action: "response",
+                fetcher: "Eip1193Fetcher",
+                request,
+                error,
+                provider: this
+            });
+            throw error;
+        });
+    };
+}
+class Web3Provider extends JsonRpcProvider {
+    constructor(provider, network) {
+        if (provider == null) {
+            logger.throwArgumentError("missing provider", "provider", provider);
+        }
+        let path = null;
+        let jsonRpcFetchFunc = null;
+        let subprovider = null;
+        if (typeof (provider) === "function") {
+            path = "unknown:";
+            jsonRpcFetchFunc = provider;
+        }
+        else {
+            path = provider.host || provider.path || "";
+            if (!path && provider.isMetaMask) {
+                path = "metamask";
+            }
+            subprovider = provider;
+            if (provider.request) {
+                if (path === "") {
+                    path = "eip-1193:";
+                }
+                jsonRpcFetchFunc = buildEip1193Fetcher(provider);
+            }
+            else if (provider.sendAsync) {
+                jsonRpcFetchFunc = buildWeb3LegacyFetcher(provider, provider.sendAsync.bind(provider));
+            }
+            else if (provider.send) {
+                jsonRpcFetchFunc = buildWeb3LegacyFetcher(provider, provider.send.bind(provider));
+            }
+            else {
+                logger.throwArgumentError("unsupported provider", "provider", provider);
+            }
+            if (!path) {
+                path = "unknown:";
+            }
+        }
+        super(path, network);
+        defineReadOnly(this, "jsonRpcFetchFunc", jsonRpcFetchFunc);
+        defineReadOnly(this, "provider", subprovider);
+    }
+    send(method, params) {
+        return this.jsonRpcFetchFunc(method, params);
+    }
+}
+
+export { Web3Provider };

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

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

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

@@ -0,0 +1,120 @@
+import { hexlify, isBytesLike, arrayify } from '../../bytes/lib.esm/index.js';
+import { Logger } from '../../logger/lib.esm/index.js';
+import { version } from './_version.js';
+
+const logger = new Logger(version);
+function arrayifyInteger(value) {
+    const result = [];
+    while (value) {
+        result.unshift(value & 0xff);
+        value >>= 8;
+    }
+    return result;
+}
+function unarrayifyInteger(data, offset, length) {
+    let result = 0;
+    for (let i = 0; i < length; i++) {
+        result = (result * 256) + data[offset + i];
+    }
+    return result;
+}
+function _encode(object) {
+    if (Array.isArray(object)) {
+        let payload = [];
+        object.forEach(function (child) {
+            payload = payload.concat(_encode(child));
+        });
+        if (payload.length <= 55) {
+            payload.unshift(0xc0 + payload.length);
+            return payload;
+        }
+        const length = arrayifyInteger(payload.length);
+        length.unshift(0xf7 + length.length);
+        return length.concat(payload);
+    }
+    if (!isBytesLike(object)) {
+        logger.throwArgumentError("RLP object must be BytesLike", "object", object);
+    }
+    const data = Array.prototype.slice.call(arrayify(object));
+    if (data.length === 1 && data[0] <= 0x7f) {
+        return data;
+    }
+    else if (data.length <= 55) {
+        data.unshift(0x80 + data.length);
+        return data;
+    }
+    const length = arrayifyInteger(data.length);
+    length.unshift(0xb7 + length.length);
+    return length.concat(data);
+}
+function encode(object) {
+    return hexlify(_encode(object));
+}
+function _decodeChildren(data, offset, childOffset, length) {
+    const result = [];
+    while (childOffset < offset + 1 + length) {
+        const decoded = _decode(data, childOffset);
+        result.push(decoded.result);
+        childOffset += decoded.consumed;
+        if (childOffset > offset + 1 + length) {
+            logger.throwError("child data too short", Logger.errors.BUFFER_OVERRUN, {});
+        }
+    }
+    return { consumed: (1 + length), result: result };
+}
+// returns { consumed: number, result: Object }
+function _decode(data, offset) {
+    if (data.length === 0) {
+        logger.throwError("data too short", Logger.errors.BUFFER_OVERRUN, {});
+    }
+    // Array with extra length prefix
+    if (data[offset] >= 0xf8) {
+        const lengthLength = data[offset] - 0xf7;
+        if (offset + 1 + lengthLength > data.length) {
+            logger.throwError("data short segment too short", Logger.errors.BUFFER_OVERRUN, {});
+        }
+        const length = unarrayifyInteger(data, offset + 1, lengthLength);
+        if (offset + 1 + lengthLength + length > data.length) {
+            logger.throwError("data long segment too short", Logger.errors.BUFFER_OVERRUN, {});
+        }
+        return _decodeChildren(data, offset, offset + 1 + lengthLength, lengthLength + length);
+    }
+    else if (data[offset] >= 0xc0) {
+        const length = data[offset] - 0xc0;
+        if (offset + 1 + length > data.length) {
+            logger.throwError("data array too short", Logger.errors.BUFFER_OVERRUN, {});
+        }
+        return _decodeChildren(data, offset, offset + 1, length);
+    }
+    else if (data[offset] >= 0xb8) {
+        const lengthLength = data[offset] - 0xb7;
+        if (offset + 1 + lengthLength > data.length) {
+            logger.throwError("data array too short", Logger.errors.BUFFER_OVERRUN, {});
+        }
+        const length = unarrayifyInteger(data, offset + 1, lengthLength);
+        if (offset + 1 + lengthLength + length > data.length) {
+            logger.throwError("data array too short", Logger.errors.BUFFER_OVERRUN, {});
+        }
+        const result = hexlify(data.slice(offset + 1 + lengthLength, offset + 1 + lengthLength + length));
+        return { consumed: (1 + lengthLength + length), result: result };
+    }
+    else if (data[offset] >= 0x80) {
+        const length = data[offset] - 0x80;
+        if (offset + 1 + length > data.length) {
+            logger.throwError("data too short", Logger.errors.BUFFER_OVERRUN, {});
+        }
+        const result = hexlify(data.slice(offset + 1, offset + 1 + length));
+        return { consumed: (1 + length), result: result };
+    }
+    return { consumed: 1, result: hexlify(data[offset]) };
+}
+function decode(data) {
+    const bytes = arrayify(data);
+    const decoded = _decode(bytes, 0);
+    if (decoded.consumed !== bytes.length) {
+        logger.throwArgumentError("invalid rlp data", "data", data);
+    }
+    return decoded.result;
+}
+
+export { decode, encode };

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

@@ -0,0 +1,8 @@
+import hash from '../../../hash.js/lib/hash.js';
+import { arrayify } from '../../bytes/lib.esm/index.js';
+
+function sha256(data) {
+    return "0x" + (hash.sha256().update(arrayify(data)).digest("hex"));
+}
+
+export { sha256 };

package/bundle/node_modules/@ethersproject/signing-key/lib.esm/_version.js

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