essential-eth 0.9.2-beta.1 → 0.9.2-beta.3

package/dist/cjs/providers/JsonRpcProvider.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonRpcProvider = exports.JsonRpcProvider = void 0;
+const BaseProvider_1 = require("./BaseProvider");
+class JsonRpcProvider extends BaseProvider_1.BaseProvider {
+    /**
+     * @ignore
+     */
+    selectRpcUrl() {
+        return this._rpcUrls[0];
+    }
+    /**
+     * @ignore
+     */
+    post(body) {
+        return this._post(body);
+    }
+    /**
+     * @param rpcUrl The URL to your Eth node. Consider POKT or Infura
+     * @example
+     * `https://free-eth-node.com/api/eth`
+     * @example
+     * `https://mainnet.infura.io/v3/YOUR-PROJECT-ID`
+     */
+    constructor(rpcUrl = 'https://free-eth-node.com/api/eth') {
+        super([rpcUrl]);
+    }
+}
+exports.JsonRpcProvider = JsonRpcProvider;
+/**
+ * Helper function to avoid "new"
+ *
+ * @param rpcUrl the RPC URL to post requests to
+ * @returns an initiated {@link JsonRpcProvider}
+ * @example
+ * ```javascript
+ * jsonRpcProvider().getBlock('latest').then(block => {
+ *   console.log(block.number);
+ * })
+ * // 14530496
+ * ```
+ */
+function jsonRpcProvider(rpcUrl) {
+    return new JsonRpcProvider(rpcUrl);
+}
+exports.jsonRpcProvider = jsonRpcProvider;

package/dist/cjs/providers/test/json-rpc-provider/get-logs/mocks.js

@@ -0,0 +1,152 @@
+"use strict";
+// Example logs that should be returned
+// https://etherscan.io/address/0xfbddadd80fe7bda00b901fbaf73803f2238ae655#events
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockRpcAllResponse = exports.mockRpcAddressTopicsResponse = exports.mockRpcAddressFromToResponse = exports.mockfilterAllLogs = exports.mockfilterAddressTopicsLogs = exports.mockfilterAddressFromToLogs = exports.filterAll = exports.WETH_ADDRESS = exports.filterAddressTopics = exports.RARELAND_ADDRESS = exports.filterAddressFromTo = exports.STRONGBLOCK_ADDRESS = void 0;
+// Block(s) are 14809329
+exports.STRONGBLOCK_ADDRESS = '0xfbddadd80fe7bda00b901fbaf73803f2238ae655';
+exports.filterAddressFromTo = {
+    address: exports.STRONGBLOCK_ADDRESS,
+    fromBlock: '0xE1F8F1',
+    toBlock: '0xE1F8F1',
+};
+// Example logs that should be returned
+// https://etherscan.io/address/0x596a0f276ee432d8a28441e55737ff55cf30d0f7#events
+exports.RARELAND_ADDRESS = '0x596a0f276ee432d8a28441e55737ff55cf30d0f7';
+exports.filterAddressTopics = {
+    address: exports.RARELAND_ADDRESS,
+    topics: [
+        '0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925',
+    ],
+};
+// https://etherscan.io/address/0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2#events
+// Address is for Wrapped Ether Contract
+exports.WETH_ADDRESS = '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2';
+exports.filterAll = {
+    address: exports.WETH_ADDRESS,
+    topics: [
+        '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+        '0x00000000000000000000000021b8065d10f73ee2e260e5b47d3344d3ced7596e',
+    ],
+    fromBlock: 14825027,
+    toBlock: 14825039,
+};
+exports.mockfilterAddressFromToLogs = [
+    {
+        address: '0xfbddadd80fe7bda00b901fbaf73803f2238ae655',
+        topics: [
+            '0xd8138f8a3f377c5259ca548e70e4c2de94f129f5a11036a15b69513cba2b426a',
+            '0x00000000000000000000000028c2e3e17f8c61a9b7515f7bb1e1347846588b82',
+        ],
+        data: '0x0000000000000000000000000000000000000000000000001dbaed81bf64db6d',
+        blockNumber: '0xe1f8f1',
+        transactionHash: '0x5dec3a55b87edac0af5c4a9afdd015bb04303fdf86525dd1cc4e7aa7653b6301',
+        transactionIndex: '0x29',
+        blockHash: '0x343ead2d84a53b054bc191fe00807d59b40094bb0cbc49b3ba550169b046d4b8',
+        logIndex: '0x88',
+        removed: false,
+    },
+    {
+        address: '0xfbddadd80fe7bda00b901fbaf73803f2238ae655',
+        topics: [
+            '0xd8138f8a3f377c5259ca548e70e4c2de94f129f5a11036a15b69513cba2b426a',
+            '0x000000000000000000000000c3b80d78bb52fd734c4f730dad5e190ba4ecb830',
+        ],
+        data: '0x0000000000000000000000000000000000000000000000001c277de315af8924',
+        blockNumber: '0xe1f8f1',
+        transactionHash: '0xae04b63efd57852e34bdc84e257bb413f9f942288f63a131d4b7071c8ee0b896',
+        transactionIndex: '0x2f',
+        blockHash: '0x343ead2d84a53b054bc191fe00807d59b40094bb0cbc49b3ba550169b046d4b8',
+        logIndex: '0x95',
+        removed: false,
+    },
+    {
+        address: '0xfbddadd80fe7bda00b901fbaf73803f2238ae655',
+        topics: [
+            '0xd8138f8a3f377c5259ca548e70e4c2de94f129f5a11036a15b69513cba2b426a',
+            '0x000000000000000000000000f1a192063f0a2b2be0cbcb2978b13e95e7f35f6b',
+        ],
+        data: '0x00000000000000000000000000000000000000000000000018ecfa70ea275b6d',
+        blockNumber: '0xe1f8f1',
+        transactionHash: '0xbdba7260507b4ca24757809ac9a23e5225e80a491475ccf89a04c1894a693c77',
+        transactionIndex: '0x30',
+        blockHash: '0x343ead2d84a53b054bc191fe00807d59b40094bb0cbc49b3ba550169b046d4b8',
+        logIndex: '0x97',
+        removed: false,
+    },
+    {
+        address: '0xfbddadd80fe7bda00b901fbaf73803f2238ae655',
+        topics: [
+            '0xd8138f8a3f377c5259ca548e70e4c2de94f129f5a11036a15b69513cba2b426a',
+            '0x000000000000000000000000c78dc12c9b04858d57a108ae948020344895e910',
+        ],
+        data: '0x0000000000000000000000000000000000000000000000000da5142efe16e492',
+        blockNumber: '0xe1f8f1',
+        transactionHash: '0xdcf29bd8a44ec89a3b53488dd60b76bd7f1c532db76f88e166f3de1ab216537e',
+        transactionIndex: '0x31',
+        blockHash: '0x343ead2d84a53b054bc191fe00807d59b40094bb0cbc49b3ba550169b046d4b8',
+        logIndex: '0x99',
+        removed: false,
+    },
+    {
+        address: '0xfbddadd80fe7bda00b901fbaf73803f2238ae655',
+        topics: [
+            '0xd8138f8a3f377c5259ca548e70e4c2de94f129f5a11036a15b69513cba2b426a',
+            '0x000000000000000000000000aaf5c3760f4a77bdf23974f98d69f9ccfd778aea',
+        ],
+        data: '0x0000000000000000000000000000000000000000000000001086ed3d87034000',
+        blockNumber: '0xe1f8f1',
+        transactionHash: '0x56130c6e8fdafd0e08411b21ce984eeb56dc61d99a91f03efc7edde748d7ad81',
+        transactionIndex: '0x35',
+        blockHash: '0x343ead2d84a53b054bc191fe00807d59b40094bb0cbc49b3ba550169b046d4b8',
+        logIndex: '0xac',
+        removed: false,
+    },
+    {
+        address: '0xfbddadd80fe7bda00b901fbaf73803f2238ae655',
+        topics: [
+            '0x39b0a0620bb668047ab7248973ddfd93d53dff1d4952bd2d56bbf5934edc1fd0',
+            '0x0000000000000000000000001753de22132990dd5ab35f13a5951431c8ba08ea',
+        ],
+        data: '0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000e3203b',
+        blockNumber: '0xe1f8f1',
+        transactionHash: '0xf5a77d85296cc670d577d3c9a76b1fa18be77239a4cb4c05493530866d60c36f',
+        transactionIndex: '0x3a',
+        blockHash: '0x343ead2d84a53b054bc191fe00807d59b40094bb0cbc49b3ba550169b046d4b8',
+        logIndex: '0xb5',
+        removed: false,
+    },
+];
+exports.mockfilterAddressTopicsLogs = [];
+exports.mockfilterAllLogs = [
+    {
+        address: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+        topics: [
+            '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+            '0x00000000000000000000000021b8065d10f73ee2e260e5b47d3344d3ced7596e',
+            '0x00000000000000000000000068b3465833fb72a70ecdf485e0e4c7bd8665fc45',
+        ],
+        data: '0x000000000000000000000000000000000000000000000000005f862ee352a38a',
+        blockNumber: '0xe23645',
+        transactionHash: '0xbd49031be16f8fd1775f4e0fe79b408ffd8ae9c65b2827ee47e3238e3f51f4c0',
+        transactionIndex: '0xe2',
+        blockHash: '0x8e0dfac2f704851960f866c8708b3bef2f66c0fee0329cf25ff0261b264ca6bc',
+        logIndex: '0x180',
+        removed: false,
+    },
+];
+exports.mockRpcAddressFromToResponse = JSON.stringify({
+    jsonrpc: '2.0',
+    id: 1,
+    result: exports.mockfilterAddressFromToLogs,
+});
+exports.mockRpcAddressTopicsResponse = JSON.stringify({
+    jsonrpc: '2.0',
+    id: 1,
+    result: exports.mockfilterAddressTopicsLogs,
+});
+exports.mockRpcAllResponse = JSON.stringify({
+    jsonrpc: '2.0',
+    id: 1,
+    result: exports.mockfilterAllLogs,
+});

package/dist/cjs/providers/test/mock-of.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockOf = void 0;
+/**
+ * Helper function for mocking other functions.
+ *
+ * @param fn
+ * @example mockOf(stripe.checkout.sessions.create).mockResolvedValue(mockSession);
+ * @see https://twitter.com/scastiel/status/1631354119192473601?s=20
+ */
+const mockOf = (fn) => fn;
+exports.mockOf = mockOf;

package/dist/cjs/providers/test/rpc-urls.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rpcUrls = exports.fakeUrls = void 0;
+const zod_1 = __importDefault(require("zod"));
+exports.fakeUrls = {
+    notRPCButRealHttp: 'https://httpstat.us/200',
+};
+const RPC_ORIGIN = 'https://free-eth-node.com';
+zod_1.default.string({
+    required_error: '"RPC_ORIGIN" required but not found',
+})
+    .url('Expected url for "RPC_ORIGIN"')
+    .parse(RPC_ORIGIN);
+exports.rpcUrls = {
+    mainnet: `${RPC_ORIGIN}/api/eth`,
+    oeth: `${RPC_ORIGIN}/api/oeth`,
+    matic: `${RPC_ORIGIN}/api/MATIC`,
+    gno: `${RPC_ORIGIN}/api/gno`,
+    bnb: `${RPC_ORIGIN}/api/bnb`,
+    arb1: `${RPC_ORIGIN}/api/arb1`,
+    gor: `${RPC_ORIGIN}/api/gor`,
+};

package/dist/cjs/providers/utils/chains-info.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// autogenerated in "fetch-chains-info.ts"
+// Do not edit directly
+exports.default = {
+    "1": [
+        "eth",
+        "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
+    ],
+    "5": [
+        "gor",
+        "0x112234455c3a32fd11230c42e7bccd4a84e02010"
+    ],
+    "10": [
+        "oeth"
+    ],
+    "50": [
+        "xdc"
+    ],
+    "56": [
+        "bnb"
+    ],
+    "100": [
+        "gno"
+    ],
+    "137": [
+        "matic"
+    ],
+    "250": [
+        "ftm"
+    ],
+    "324": [
+        "zksync"
+    ],
+    "1101": [
+        "zkevm"
+    ],
+    "1337": [
+        "geth"
+    ],
+    "7700": [
+        "canto"
+    ],
+    "9001": [
+        "evmos"
+    ],
+    "42161": [
+        "arb1"
+    ],
+    "42220": [
+        "celo"
+    ],
+    "43114": [
+        "avax"
+    ],
+    "59140": [
+        "linea-testnet"
+    ],
+    "80001": [
+        "maticmum"
+    ],
+    "421613": [
+        "arb-goerli"
+    ],
+    "534352": [
+        "scr"
+    ],
+    "11155111": [
+        "sep"
+    ]
+};

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);
+    }
+    /**
+     * 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());
+    }
+    /**
+     * 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'
+     * ```
+     */
+    padAndChop = (str, padChar, length) => {
+        return (Array(length).fill(padChar).join('') + str).slice(length * -1);
+    };
+    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/FeeData.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 });