essential-eth 0.5.11-next.0 → 0.5.13-next.0

package/dist/cjs/shared/tiny-big/helpers.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scientificStrToDecimalStr = void 0;
+/**
+ * Strips both leading and trailing zeroes from a number string
+ *
+ * @param numberString the string of numbers to strip zeros from
+ * @returns a string of numbers without leading or trailing zeros
+ * @example
+ * ```javascript
+ * stripTrailingZeros('0005280');
+ * // '5280'
+ * ```
+ */
+function stripTrailingZeroes(numberString) {
+    const isNegative = numberString.startsWith('-');
+    numberString = numberString.replace('-', '');
+    numberString = numberString.replace(/\.0*$/g, '' /* for numbers like "1.0" -> "1" */);
+    numberString = numberString.replace(/^0+/, '');
+    // for numbers like "1.10" -> "1.1"
+    if (numberString.includes('.')) {
+        numberString = numberString.replace(/0+$/, '');
+    }
+    if (numberString.startsWith('.')) {
+        // so that ".1" returns as "0.1"
+        numberString = `0${numberString}`;
+    }
+    return `${isNegative ? '-' : ''}${numberString}`;
+}
+/**
+ * Converts a string in scientific notation formatting to string in decimal format
+ *
+ * @param scientificString a string in scientific format to convert to decimal
+ * @returns a string of a decimal number equivalent to the specified scientificString
+ * @example
+ * ```javascript
+ * scientificStrToDecimalStr('2.3e-5');
+ * // '0.000023'
+ * ```
+ * @example
+ * ```javascript
+ * scientificStrToDecimalStr('2.3e+5');
+ * // '230000'
+ * ```
+ */
+function scientificStrToDecimalStr(scientificString) {
+    // Does not contain "e" nor "E"
+    if (!scientificString.match(/e/i /* lowercase and uppercase E */)) {
+        return stripTrailingZeroes(scientificString);
+    }
+    // eslint-disable-next-line prefer-const
+    let [base, power] = scientificString.split(/e/i /* lowercase and uppercase E */);
+    // remove the leading "-" if negative
+    const isNegative = Number(base) < 0;
+    base = base.replace('-', '');
+    base = stripTrailingZeroes(base);
+    const [wholeNumber, fraction /* move decimal this many places */ = ''] = base.split('.');
+    if (Number(power) === 0) {
+        return `${isNegative ? '-' : ''}${stripTrailingZeroes(base)}`;
+    }
+    else {
+        const includesDecimal = base.includes('.');
+        if (!includesDecimal) {
+            base = `${base}.`;
+        }
+        base = base.replace('.', '');
+        const baseLength = base.length;
+        let splitPaddedNumber;
+        if (Number(power) < 0) {
+            // move decimal left
+            if (wholeNumber.length < Math.abs(Number(power))) {
+                base = base.padStart(baseLength + Math.abs(Number(power)) - wholeNumber.length, '0');
+            }
+            splitPaddedNumber = base.split('');
+            if (wholeNumber.length < Math.abs(Number(power))) {
+                // starts with zeroes
+                splitPaddedNumber = ['.', ...splitPaddedNumber];
+            }
+            else {
+                splitPaddedNumber.splice(splitPaddedNumber.length - Math.abs(Number(power)), 0, '.');
+            }
+        }
+        else {
+            // move decimal right
+            if (fraction.length < Math.abs(Number(power))) {
+                base = base.padEnd(baseLength + Math.abs(Number(power)) - fraction.length, '0');
+            }
+            splitPaddedNumber = base.split('');
+            if (fraction.length > Math.abs(Number(power))) {
+                splitPaddedNumber.splice(splitPaddedNumber.length - Math.abs(Number(power)), 0, '.');
+            }
+        }
+        const toReturn = stripTrailingZeroes(splitPaddedNumber.join(''));
+        return `${isNegative ? '-' : ''}${toReturn}`;
+    }
+}
+exports.scientificStrToDecimalStr = scientificStrToDecimalStr;

package/dist/cjs/shared/tiny-big/tiny-big.js

@@ -0,0 +1,101 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tinyBig = exports.TinyBig = void 0;
+const big_js_1 = __importDefault(require("big.js"));
+const hex_to_decimal_1 = require("../../classes/utils/hex-to-decimal");
+const helpers_1 = require("./helpers");
+/**
+ * A wrapper around [big.js](https://github.com/MikeMcl/big.js) which expands scientific notation and creates a "toHexString" function.
+ * This is the return type of every operation on ether, wei, etc.
+ */
+class TinyBig extends big_js_1.default {
+    constructor(value) {
+        if (typeof value === 'string' && value.startsWith('0x')) {
+            value = (0, hex_to_decimal_1.hexToDecimal)(value);
+        }
+        super(value);
+        /**
+         * Eithers pads or shortens a string to a specified length
+         *
+         * @param str the string to pad or chop
+         * @param padChar the character to pad the string with
+         * @param length the desired length of the given string
+         * @returns a string of the desired length, either padded with the specified padChar or with the beginning of the string chopped off
+         * @example
+         * ```javascript
+         * padAndChop('essential-eth', 'a', 8);
+         * // 'tial-eth'
+         * ```
+         * @example
+         * ```javascript
+         * padAndChop('essential-eth', 'A', 20);
+         * // 'AAAAAAAessential-eth'
+         * ```
+         */
+        this.padAndChop = (str, padChar, length) => {
+            return (Array(length).fill(padChar).join('') + str).slice(length * -1);
+        };
+    }
+    /**
+     * Used anytime you're passing in "value" to ethers or web3
+     * For now, TypeScript will complain that `TinyBig` is not a `BigNumberish`. You can // @ts-ignore or call this
+     *
+     * @returns the TinyBig represented as a hex string
+     * @example
+     * ```javascript
+     * tinyBig(293).toHexString();
+     * // '0x125'
+     * ```
+     * @example
+     * ```javascript
+     * tinyBig(681365874).toHexString();
+     * // '0x289cd172'
+     */
+    toHexString() {
+        return `0x${BigInt(this.toString()).toString(16)}`;
+    }
+    toNumber() {
+        return Number((0, helpers_1.scientificStrToDecimalStr)(super.toString()));
+    }
+    toString() {
+        if (this.toNumber() === 0) {
+            return '0';
+        }
+        return (0, helpers_1.scientificStrToDecimalStr)(super.toString());
+    }
+    toTwos(bitCount) {
+        let binaryStr;
+        if (this.gte(0)) {
+            const twosComp = this.toNumber().toString(2);
+            binaryStr = this.padAndChop(twosComp, '0', bitCount || twosComp.length);
+        }
+        else {
+            binaryStr = this.plus(Math.pow(2, bitCount)).toNumber().toString(2);
+            if (Number(binaryStr) < 0) {
+                throw new Error('Cannot calculate twos complement');
+            }
+        }
+        const binary = `0b${binaryStr}`;
+        const decimal = Number(binary);
+        return tinyBig(decimal);
+    }
+}
+exports.TinyBig = TinyBig;
+/**
+ * Helper factory function so that you don't have to type "new" when instantiating a new TinyBig
+ *
+ * @param value the value to initiate the TinyBig with
+ * @returns an initiated {@link TinyBig}
+ * @example
+ * ```javascript
+ * tinyBig(10).times(3).toNumber()
+ * // 30
+ * ```
+ */
+function tinyBig(value) {
+    return new TinyBig(value);
+}
+exports.tinyBig = tinyBig;

package/dist/cjs/shared/validate-type.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateType = void 0;
+const validateType = (value, allowedTypes) => {
+    if (!allowedTypes.includes(typeof value)) {
+        throw new Error(`${allowedTypes.join(' or ')} required. Received ${typeof value}`);
+    }
+};
+exports.validateType = validateType;

package/dist/cjs/types/Block.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types/Contract.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types/Filter.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types/Network.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types/Transaction.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });