essential-eth 0.6.2 → 0.7.0

package/dist/cjs/classes/test/Contract/uni.test.js

@@ -0,0 +1,387 @@
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _iterableToArrayLimit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _slicedToArray(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+var __generator = this && this.__generator || function(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return(g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g);
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+};
+import { Contract as EthersContract } from "@ethersproject/contracts";
+import { StaticJsonRpcProvider } from "@ethersproject/providers";
+import { JsonRpcProvider } from "../../../index";
+import { Contract as EssentialEthContract } from "../../Contract";
+import { rpcUrls } from "./../../../providers/test/rpc-urls";
+import { uniswapABI } from "./uniswap-abi";
+// The JSONABI
+var JSONABI = uniswapABI;
+var rpcURL = rpcUrls.mainnet;
+var ethersProvider = new StaticJsonRpcProvider(rpcURL);
+var essentialEthProvider = new JsonRpcProvider(rpcURL);
+// The UNI airdrop merkle address
+// https://etherscan.io/address/0x090D4613473dEE047c3f2706764f49E0821D256e#readContract
+var contractAddress = "0x090D4613473dEE047c3f2706764f49E0821D256e";
+var smartContractIsUniClaimed = function() {
+    var _ref = _asyncToGenerator(function(contract, index) {
+        var isClaimed;
+        return __generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        contract.isClaimed(index)
+                    ];
+                case 1:
+                    isClaimed = _state.sent();
+                    return [
+                        2,
+                        isClaimed
+                    ];
+            }
+        });
+    });
+    return function smartContractIsUniClaimed(contract, index) {
+        return _ref.apply(this, arguments);
+    };
+}();
+var smartContractGetUniMerkleRoot = function() {
+    var _ref = _asyncToGenerator(function(contract) {
+        var merkleRoot;
+        return __generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        contract.merkleRoot()
+                    ];
+                case 1:
+                    merkleRoot = _state.sent();
+                    return [
+                        2,
+                        merkleRoot
+                    ];
+            }
+        });
+    });
+    return function smartContractGetUniMerkleRoot(contract) {
+        return _ref.apply(this, arguments);
+    };
+}();
+var smartContractGetUniTokenAddress = function() {
+    var _ref = _asyncToGenerator(function(contract) {
+        var merkleRoot;
+        return __generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        contract.token()
+                    ];
+                case 1:
+                    merkleRoot = _state.sent();
+                    return [
+                        2,
+                        merkleRoot
+                    ];
+            }
+        });
+    });
+    return function smartContractGetUniTokenAddress(contract) {
+        return _ref.apply(this, arguments);
+    };
+}();
+var ethersContract = new EthersContract(contractAddress, JSONABI, ethersProvider);
+var essentialEthContract = new EssentialEthContract(contractAddress, JSONABI, essentialEthProvider);
+describe("uNI contract", function() {
+    it('should fetch "address" data-type', /*#__PURE__*/ _asyncToGenerator(function() {
+        var _ref, ethersResponse, essentialEthResponse;
+        return __generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        Promise.all([
+                            smartContractGetUniTokenAddress(ethersContract),
+                            smartContractGetUniTokenAddress(essentialEthContract)
+                        ])
+                    ];
+                case 1:
+                    _ref = _slicedToArray.apply(void 0, [
+                        _state.sent(),
+                        2
+                    ]), ethersResponse = _ref[0], essentialEthResponse = _ref[1];
+                    /* 0x1f9840a85d5af5bf1d1762f925bdaddc4201f984 */ expect(ethersResponse).toStrictEqual(essentialEthResponse);
+                    return [
+                        2
+                    ];
+            }
+        });
+    }));
+    it('should fetch "bytes32" merkle root', /*#__PURE__*/ _asyncToGenerator(function() {
+        var _ref, ethersResponse, essentialEthResponse;
+        return __generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        Promise.all([
+                            smartContractGetUniMerkleRoot(ethersContract),
+                            smartContractGetUniMerkleRoot(essentialEthContract)
+                        ])
+                    ];
+                case 1:
+                    _ref = _slicedToArray.apply(void 0, [
+                        _state.sent(),
+                        2
+                    ]), ethersResponse = _ref[0], essentialEthResponse = _ref[1];
+                    /* 0xc8500f8e2fcf3c9a32880e1b973fb28acc88be35787a8abcf9981b2b65dbdeb5 */ expect(ethersResponse).toStrictEqual(essentialEthResponse);
+                    return [
+                        2
+                    ];
+            }
+        });
+    }));
+    it('should fetch isClaimed "boolean" for random airdrop indexes', /*#__PURE__*/ _asyncToGenerator(function() {
+        var randomIndexes, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, i, _ref, ethersClaimed, essentialEthClaimed, err;
+        return __generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    randomIndexes = [
+                        0,
+                        4,
+                        102,
+                        999,
+                        999999
+                    ];
+                    _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        6,
+                        7,
+                        8
+                    ]);
+                    _iterator = randomIndexes[Symbol.iterator]();
+                    _state.label = 2;
+                case 2:
+                    if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                        3,
+                        5
+                    ];
+                    i = _step.value;
+                    return [
+                        4,
+                        Promise.all([
+                            smartContractIsUniClaimed(ethersContract, i),
+                            smartContractIsUniClaimed(essentialEthContract, i)
+                        ])
+                    ];
+                case 3:
+                    _ref = _slicedToArray.apply(void 0, [
+                        _state.sent(),
+                        2
+                    ]), ethersClaimed = _ref[0], essentialEthClaimed = _ref[1];
+                    expect(ethersClaimed).toStrictEqual(essentialEthClaimed);
+                    _state.label = 4;
+                case 4:
+                    _iteratorNormalCompletion = true;
+                    return [
+                        3,
+                        2
+                    ];
+                case 5:
+                    return [
+                        3,
+                        8
+                    ];
+                case 6:
+                    err = _state.sent();
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                    return [
+                        3,
+                        8
+                    ];
+                case 7:
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                    return [
+                        7
+                    ];
+                case 8:
+                    return [
+                        2
+                    ];
+            }
+        });
+    }));
+});

package/dist/cjs/classes/test/Contract/uniswap-abi.js

@@ -1,121 +1,117 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.uniswapABI = void 0;
-exports.uniswapABI = 
-// http://api.etherscan.io/api?module=contract&action=getabi&address=0x090d4613473dee047c3f2706764f49e0821d256e&format=raw
+export var uniswapABI = // http://api.etherscan.io/api?module=contract&action=getabi&address=0x090d4613473dee047c3f2706764f49e0821d256e&format=raw
 [
     {
         inputs: [
             {
-                internalType: 'address',
-                name: 'token_',
-                type: 'address',
+                internalType: "address",
+                name: "token_",
+                type: "address"
             },
             {
-                internalType: 'bytes32',
-                name: 'merkleRoot_',
-                type: 'bytes32',
-            },
+                internalType: "bytes32",
+                name: "merkleRoot_",
+                type: "bytes32"
+            }
         ],
-        stateMutability: 'nonpayable',
-        type: 'constructor',
+        stateMutability: "nonpayable",
+        type: "constructor"
     },
     {
         anonymous: false,
         inputs: [
             {
                 indexed: false,
-                internalType: 'uint256',
-                name: 'index',
-                type: 'uint256',
+                internalType: "uint256",
+                name: "index",
+                type: "uint256"
             },
             {
                 indexed: false,
-                internalType: 'address',
-                name: 'account',
-                type: 'address',
+                internalType: "address",
+                name: "account",
+                type: "address"
             },
             {
                 indexed: false,
-                internalType: 'uint256',
-                name: 'amount',
-                type: 'uint256',
-            },
+                internalType: "uint256",
+                name: "amount",
+                type: "uint256"
+            }
         ],
-        name: 'Claimed',
-        type: 'event',
+        name: "Claimed",
+        type: "event"
     },
     {
         inputs: [
             {
-                internalType: 'uint256',
-                name: 'index',
-                type: 'uint256',
+                internalType: "uint256",
+                name: "index",
+                type: "uint256"
             },
             {
-                internalType: 'address',
-                name: 'account',
-                type: 'address',
+                internalType: "address",
+                name: "account",
+                type: "address"
             },
             {
-                internalType: 'uint256',
-                name: 'amount',
-                type: 'uint256',
+                internalType: "uint256",
+                name: "amount",
+                type: "uint256"
             },
             {
-                internalType: 'bytes32[]',
-                name: 'merkleProof',
-                type: 'bytes32[]',
-            },
+                internalType: "bytes32[]",
+                name: "merkleProof",
+                type: "bytes32[]"
+            }
         ],
-        name: 'claim',
+        name: "claim",
         outputs: [],
-        stateMutability: 'nonpayable',
-        type: 'function',
+        stateMutability: "nonpayable",
+        type: "function"
     },
     {
         inputs: [
             {
-                internalType: 'uint256',
-                name: 'index',
-                type: 'uint256',
-            },
+                internalType: "uint256",
+                name: "index",
+                type: "uint256"
+            }
         ],
-        name: 'isClaimed',
+        name: "isClaimed",
         outputs: [
             {
-                internalType: 'bool',
-                name: '',
-                type: 'bool',
-            },
+                internalType: "bool",
+                name: "",
+                type: "bool"
+            }
         ],
-        stateMutability: 'view',
-        type: 'function',
+        stateMutability: "view",
+        type: "function"
     },
     {
         inputs: [],
-        name: 'merkleRoot',
+        name: "merkleRoot",
         outputs: [
             {
-                internalType: 'bytes32',
-                name: '',
-                type: 'bytes32',
-            },
+                internalType: "bytes32",
+                name: "",
+                type: "bytes32"
+            }
         ],
-        stateMutability: 'view',
-        type: 'function',
+        stateMutability: "view",
+        type: "function"
     },
     {
         inputs: [],
-        name: 'token',
+        name: "token",
         outputs: [
             {
-                internalType: 'address',
-                name: '',
-                type: 'address',
-            },
+                internalType: "address",
+                name: "",
+                type: "address"
+            }
         ],
-        stateMutability: 'view',
-        type: 'function',
-    },
+        stateMutability: "view",
+        type: "function"
+    }
 ];

package/dist/cjs/classes/utils/clean-block.d.ts

@@ -1,3 +1,2 @@
-import type { BlockResponse } from '../..';
-import type { RPCBlock } from '../../types/Block.types';
+import type { BlockResponse, RPCBlock } from '../../types/Block.types';
 export declare function cleanBlock(block: RPCBlock, returnTransactionObjects: boolean): BlockResponse;

package/dist/cjs/classes/utils/clean-block.js

@@ -1,10 +1,35 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cleanBlock = void 0;
-const __1 = require("../..");
-const tiny_big_1 = require("../../shared/tiny-big/tiny-big");
-const clean_transaction_1 = require("./clean-transaction");
-const hex_to_decimal_1 = require("./hex-to-decimal");
+function _defineProperty(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _objectSpread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+import { tinyBig } from "../../shared/tiny-big/tiny-big";
+import { toChecksumAddress } from "../../utils/to-checksum-address";
+import { cleanTransaction } from "./clean-transaction";
+import { hexToDecimal } from "./hex-to-decimal";
 /**
  * Converts RPC block response to more JS-friendly format
  *
@@ -122,39 +147,36 @@ const hex_to_decimal_1 = require("./hex-to-decimal");
  * //   paidFees: '0x1fb451615b58',
  * //   cumulativeDifficulty: '0x8fdbe015f7248cf993'
  * // }
- */
-function cleanBlock(block, returnTransactionObjects) {
-    const cleanedBlock = Object.assign({}, block);
-    Object.keys(block).forEach((key) => {
+ */ export function cleanBlock(block, returnTransactionObjects) {
+    var cleanedBlock = _objectSpread({}, block);
+    Object.keys(block).forEach(function(key) {
         // pending blocks have null instead of a difficulty
         // pending blocks have null instead of a miner address
-        if (!block[key])
-            return;
-        switch (key) {
-            case 'difficulty':
-            case 'totalDifficulty':
-            case 'gasLimit':
-            case 'gasUsed':
-            case 'size':
-            case 'timestamp':
-            case 'baseFeePerGas':
-                cleanedBlock[key] = (0, tiny_big_1.tinyBig)((0, hex_to_decimal_1.hexToDecimal)(block[key]));
+        if (!block[key]) return;
+        switch(key){
+            case "difficulty":
+            case "totalDifficulty":
+            case "gasLimit":
+            case "gasUsed":
+            case "size":
+            case "timestamp":
+            case "baseFeePerGas":
+                cleanedBlock[key] = tinyBig(hexToDecimal(block[key]));
                 break;
-            case 'number':
-                cleanedBlock[key] = Number((0, hex_to_decimal_1.hexToDecimal)(block[key]));
+            case "number":
+                cleanedBlock[key] = Number(hexToDecimal(block[key]));
                 break;
-            case 'miner':
-                cleanedBlock[key] = (0, __1.toChecksumAddress)(block[key]);
+            case "miner":
+                cleanedBlock[key] = toChecksumAddress(block[key]);
                 break;
         }
     });
     // for all full transactions
     if (returnTransactionObjects) {
-        const txns = block.transactions;
-        txns.forEach((transaction, index) => {
-            cleanedBlock.transactions[index] = (0, clean_transaction_1.cleanTransaction)(transaction);
+        var txns = block.transactions;
+        txns.forEach(function(transaction, index) {
+            cleanedBlock.transactions[index] = cleanTransaction(transaction);
         });
     }
     return cleanedBlock;
 }
-exports.cleanBlock = cleanBlock;