essential-eth 0.6.2 → 0.8.0

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

@@ -1,89 +1,180 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+function _assertThisInitialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _get(target, property, receiver) {
+    if (typeof Reflect !== "undefined" && Reflect.get) {
+        _get = Reflect.get;
+    } else {
+        _get = function _get(target, property, receiver) {
+            var base = _superPropBase(target, property);
+            if (!base) return;
+            var desc = Object.getOwnPropertyDescriptor(base, property);
+            if (desc.get) {
+                return desc.get.call(receiver);
+            }
+            return desc.value;
+        };
+    }
+    return _get(target, property, receiver || target);
+}
+function _getPrototypeOf(o) {
+    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _getPrototypeOf(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _setPrototypeOf(subClass, superClass);
+}
+function _possibleConstructorReturn(self, call) {
+    if (call && (_typeof(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assertThisInitialized(self);
+}
+function _setPrototypeOf(o, p) {
+    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _setPrototypeOf(o, p);
+}
+function _superPropBase(object, property) {
+    while(!Object.prototype.hasOwnProperty.call(object, property)){
+        object = _getPrototypeOf(object);
+        if (object === null) break;
+    }
+    return object;
+}
+var _typeof = function(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
-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");
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
+import Big from "big.js";
+import { hexToDecimal } from "../../classes/utils/hex-to-decimal";
+import { scientificStrToDecimalStr } from "./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);
+ */ export var TinyBig = /*#__PURE__*/ function(Big) {
+    "use strict";
+    _inherits(TinyBig, Big);
+    var _super = _createSuper(TinyBig);
+    function TinyBig(value) {
+        _classCallCheck(this, TinyBig);
+        var _this;
+        if (typeof value === "string" && value.startsWith("0x")) {
+            value = hexToDecimal(value);
         }
-        super(value);
+        _this = _super.call(this, 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);
+   * 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 = function(str, padChar, length) {
+            return (Array(length).fill(padChar).join("") + str).slice(length * -1);
         };
+        return _this;
     }
+    var _proto = TinyBig.prototype;
     /**
-     * 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() {
+   * 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'
+   */ _proto.toHexString = function toHexString() {
+        return "0x".concat(BigInt(this.toString()).toString(16));
+    };
+    _proto.toNumber = function toNumber() {
+        return Number(scientificStrToDecimalStr(_get(_getPrototypeOf(TinyBig.prototype), "toString", this).call(this)));
+    };
+    _proto.toString = function toString() {
         if (this.toNumber() === 0) {
-            return '0';
+            return "0";
         }
-        return (0, helpers_1.scientificStrToDecimalStr)(super.toString());
-    }
-    toTwos(bitCount) {
-        let binaryStr;
+        return scientificStrToDecimalStr(_get(_getPrototypeOf(TinyBig.prototype), "toString", this).call(this));
+    };
+    _proto.toTwos = function toTwos(bitCount) {
+        var binaryStr;
         if (this.gte(0)) {
-            const twosComp = this.toNumber().toString(2);
-            binaryStr = this.padAndChop(twosComp, '0', bitCount || twosComp.length);
-        }
-        else {
+            var 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');
+                throw new Error("Cannot calculate twos complement");
             }
         }
-        const binary = `0b${binaryStr}`;
-        const decimal = Number(binary);
+        var binary = "0b".concat(binaryStr);
+        var decimal = Number(binary);
         return tinyBig(decimal);
-    }
-}
-exports.TinyBig = TinyBig;
+    };
+    return TinyBig;
+}(Big);
 /**
  * Helper factory function so that you don't have to type "new" when instantiating a new TinyBig
  *
@@ -94,8 +185,6 @@ exports.TinyBig = TinyBig;
  * tinyBig(10).times(3).toNumber()
  * // 30
  * ```
- */
-function tinyBig(value) {
+ */ export function tinyBig(value) {
     return new TinyBig(value);
 }
-exports.tinyBig = tinyBig;

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

@@ -0,0 +1,34 @@
+import { BigNumber } from "ethers";
+import { tinyBig } from "./tiny-big";
+describe("tiny-big", function() {
+    it("allows hex string input", function() {
+        expect(tinyBig("0xa").toString()).toBe("10");
+        expect(tinyBig("10").toString()).toBe("10");
+    });
+    it("performs toHexString properly", function() {
+        expect(tinyBig(0).toHexString()).toBe("0x0");
+        expect(tinyBig(1).toHexString()).toBe("0x1");
+        expect(tinyBig(15).toHexString()).toBe("0xf");
+        expect(tinyBig(16).toHexString()).toBe("0x10");
+    });
+    it("performs twosComplement", function() {
+        var inputs = [
+            {
+                num: -3,
+                bitCount: 3
+            },
+            {
+                num: 0,
+                bitCount: 3
+            },
+            {
+                num: 3,
+                bitCount: 3
+            }
+        ];
+        inputs.forEach(function(param) {
+            var num = param.num, bitCount = param.bitCount;
+            expect(tinyBig(num).toTwos(bitCount).toString()).toBe(BigNumber.from(num).toTwos(bitCount).toString());
+        });
+    });
+});

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

@@ -1,9 +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}`);
+var _typeof = function(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+};
+export var validateType = function(value, allowedTypes) {
+    if (!allowedTypes.includes(typeof value === "undefined" ? "undefined" : _typeof(value))) {
+        throw new Error("".concat(allowedTypes.join(" or "), " required. Received ").concat(typeof value === "undefined" ? "undefined" : _typeof(value)));
     }
 };
-exports.validateType = validateType;

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

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export { }; /* block number as hex string '0x0' */ 

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

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

package/dist/cjs/types/FeeData.types.d.ts

@@ -0,0 +1,7 @@
+import type { TinyBig } from '../shared/tiny-big/tiny-big';
+export interface FeeData {
+    gasPrice: TinyBig;
+    lastBaseFeePerGas: TinyBig | null;
+    maxFeePerGas: TinyBig | null;
+    maxPriorityFeePerGas: TinyBig | null;
+}

package/dist/cjs/types/FeeData.types.js

@@ -0,0 +1 @@
+export { };

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

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

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

@@ -1,2 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * A trimmed version of https://chainid.network/chains.json
+ */ export { };

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

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