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

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 };

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

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