essential-eth 0.4.9-beta.1 → 0.4.9-beta.4

package/lib/esm/classes/utils/clean-block.js

@@ -0,0 +1,35 @@
+import { toChecksumAddress } from '../..';
+import { cleanTransaction } from './clean-transaction';
+import { hexToDecimal } from './hex-to-decimal';
+export function cleanBlock(block, returnTransactionObjects) {
+    const cleanedBlock = Object.assign({}, block);
+    Object.keys(block).forEach((key) => {
+        if (!block[key])
+            return;
+        switch (key) {
+            case 'gasLimit':
+            case 'gasUsed':
+            case 'number':
+            case 'size':
+            case 'timestamp':
+            case 'baseFeePerGas':
+                cleanedBlock[key] = Number(hexToDecimal(block[key]));
+                break;
+            case 'difficulty':
+            case 'totalDifficulty':
+                cleanedBlock[key] = hexToDecimal(block[key]);
+                break;
+            case 'miner':
+                if (block[key]) {
+                    cleanedBlock[key] = toChecksumAddress(block[key]);
+                }
+                break;
+        }
+    });
+    if (returnTransactionObjects) {
+        cleanedBlock.transactions.forEach((transaction, index) => {
+            cleanedBlock.transactions[index] = cleanTransaction(transaction);
+        });
+    }
+    return cleanedBlock;
+}

package/lib/esm/classes/utils/clean-transaction.d.ts

@@ -0,0 +1,2 @@
+import { RPCTransaction, Transaction } from '../../types/Transaction.types';
+export declare function cleanTransaction(transaction: RPCTransaction): Transaction;

package/lib/esm/classes/utils/clean-transaction.js

@@ -0,0 +1,29 @@
+import { toChecksumAddress } from '../..';
+import { hexToDecimal } from './hex-to-decimal';
+export function cleanTransaction(transaction) {
+    const cleanedTransaction = Object.assign({}, transaction);
+    Object.keys(transaction).forEach((key) => {
+        if (!transaction[key])
+            return;
+        switch (key) {
+            case 'blockNumber':
+            case 'gas':
+            case 'nonce':
+            case 'transactionIndex':
+            case 'type':
+                cleanedTransaction[key] = Number(hexToDecimal(transaction[key]));
+                break;
+            case 'gasPrice':
+            case 'value':
+                cleanedTransaction[key] = hexToDecimal(transaction[key]);
+                break;
+            case 'from':
+            case 'to':
+                if (transaction[key]) {
+                    cleanedTransaction[key] = toChecksumAddress(transaction[key]);
+                }
+                break;
+        }
+    });
+    return cleanedTransaction;
+}

package/lib/esm/classes/utils/encode-decode-transaction.d.ts

@@ -0,0 +1,3 @@
+import { JSONABIArgument } from '../../types/Contract.types';
+export declare function encodeData(jsonABIArgument: JSONABIArgument, args: any[]): string;
+export declare function decodeRPCResponse(jsonABIArgument: JSONABIArgument, nodeResponse: string): string | number | boolean | import("../..").TinyBig | (string | number | boolean | import("../..").TinyBig)[];

package/lib/esm/classes/utils/encode-decode-transaction.js

@@ -0,0 +1,98 @@
+import { Keccak } from 'sha3';
+import { tinyBig, toChecksumAddress } from '../..';
+import { hexToDecimal } from './hex-to-decimal';
+const hexTrue = '0000000000000000000000000000000000000000000000000000000000000001';
+const hexFalse = '0000000000000000000000000000000000000000000000000000000000000000';
+function expandType(type) {
+    if (type === 'uint[]') {
+        return 'uint256[]';
+    }
+    else if (type === 'int[]') {
+        return 'int256[]';
+    }
+    return type;
+}
+export function encodeData(jsonABIArgument, args) {
+    const hash = new Keccak(256);
+    const functionString = `${jsonABIArgument.name}(${jsonABIArgument.inputs.map((input) => expandType(input.type))})`;
+    const functionHash = hash.update(functionString).digest('hex');
+    const jsonABIInputsLength = jsonABIArgument.inputs.length;
+    let shouldValidateInputLength = true;
+    if (jsonABIArgument.inputs.find((input) => input.type.includes('['))) {
+        shouldValidateInputLength = false;
+    }
+    if (shouldValidateInputLength && args.length !== jsonABIInputsLength) {
+        throw new Error(`args inputs  of "${args.length}" does not match expected length of "${jsonABIArgument.inputs.length}"`);
+    }
+    const argsWithTypes = (jsonABIArgument.inputs || []).reduce((acc, input, i) => {
+        var _a;
+        if (input.type.includes('[')) {
+            const basicType = (_a = /([^[]*)\[.*$/g.exec(input.type)) === null || _a === void 0 ? void 0 : _a[1];
+            args.forEach((arg) => {
+                acc = acc.concat([[arg, basicType]]);
+            });
+            return acc;
+        }
+        else {
+            return acc.concat([[args[i], input.type]]);
+        }
+    }, []);
+    const encodedArgs = argsWithTypes.map(([arg, inputType]) => {
+        let rawArg = arg;
+        switch (inputType) {
+            case 'bool':
+                return arg ? hexTrue : hexFalse;
+            case 'address':
+                rawArg = arg.replace(/^0x/g, '').toLowerCase();
+                break;
+            default:
+                if (inputType.startsWith('bytes')) {
+                    const argEncoded = rawArg
+                        .split('')
+                        .map((character) => character.charCodeAt(0).toString(16))
+                        .join('');
+                    const paddedEncodedArg = argEncoded.padEnd(64, '0');
+                    return paddedEncodedArg;
+                }
+                else if (inputType === 'uint256') {
+                    const argEncoded = BigInt(arg).toString(16);
+                    const paddedEncodedArg = argEncoded.padStart(64, '0');
+                    return paddedEncodedArg;
+                }
+                else if (inputType.startsWith('uint')) {
+                    break;
+                }
+                else {
+                    throw new Error(`essential-eth does not yet support "${inputType}" inputs. Make a PR today!"`);
+                }
+        }
+        const argEncoded = rawArg.toString(16);
+        const paddedEncodedArg = argEncoded.padStart(64, '0');
+        return paddedEncodedArg;
+    });
+    const functionEncoded = functionHash.slice(0, 8);
+    const data = `0x${functionEncoded}${encodedArgs.join('')}`;
+    return data;
+}
+export function decodeRPCResponse(jsonABIArgument, nodeResponse) {
+    const rawOutputs = jsonABIArgument.outputs;
+    const encodedOutputs = nodeResponse.slice(2).match(/.{1,64}/g);
+    const outputs = (encodedOutputs || []).map((output, i) => {
+        const outputType = (rawOutputs || [])[i].type;
+        switch (outputType) {
+            case 'bool':
+                return output === hexTrue;
+            case 'address':
+                return toChecksumAddress(`0x${output.slice(24)}`);
+            case 'uint256':
+                return tinyBig(hexToDecimal(`0x${output}`));
+            case 'bytes32':
+                return `0x${output}`;
+            case 'uint8':
+                return Number(hexToDecimal(`0x${output}`));
+            default:
+                throw new Error(`essential-eth does not yet support "${outputType}" outputs. Make a PR today!"`);
+        }
+    });
+    return outputs.length === 1 ? outputs[0] : outputs;
+}

package/lib/esm/classes/utils/fetchers.d.ts

@@ -0,0 +1,9 @@
+export declare function post(url: string, body: Record<string, unknown>): Promise<any>;
+declare type RPCMethodName = 'eth_getBlockByNumber' | 'eth_call' | 'eth_chainId';
+export declare function buildRPCPostBody(method: RPCMethodName, params: any[]): {
+    jsonrpc: string;
+    id: number;
+    method: RPCMethodName;
+    params: any[];
+};
+export {};

package/lib/esm/classes/utils/fetchers.js

@@ -0,0 +1,25 @@
+import unfetch from 'isomorphic-unfetch';
+export function post(url, body) {
+    return unfetch(url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(body),
+    })
+        .then((r) => r.json())
+        .then((response) => {
+        if (response.error) {
+            throw new Error(response.error);
+        }
+        return response.result;
+    });
+}
+export function buildRPCPostBody(method, params) {
+    return {
+        jsonrpc: '2.0',
+        id: 1,
+        method,
+        params,
+    };
+}

package/lib/esm/classes/utils/hex-to-decimal.d.ts

@@ -0,0 +1 @@
+export declare function hexToDecimal(hex: string): string;

package/lib/esm/classes/utils/hex-to-decimal.js

@@ -0,0 +1,3 @@
+export function hexToDecimal(hex) {
+    return BigInt(hex).toString();
+}

package/lib/esm/index.d.ts

@@ -0,0 +1,13 @@
+import { Contract } from './classes/Contract';
+import { JsonRpcProvider, jsonRpcProvider } from './providers/JsonRpcProvider';
+import { tinyBig, TinyBig } from './shared/tiny-big/tiny-big';
+import { Block } from './types/Block.types';
+import { ContractTypes, JSONABI, JSONABIArgument } from './types/Contract.types';
+import { Network } from './types/Network.types';
+import { Transaction } from './types/Transaction.types';
+import * as utils from './utils';
+import { etherToWei } from './utils/ether-to-wei';
+import { isAddress } from './utils/is-address';
+import { toChecksumAddress } from './utils/to-checksum-address';
+import { weiToEther } from './utils/wei-to-ether';
+export { utils, etherToWei, isAddress, jsonRpcProvider, JsonRpcProvider, tinyBig, toChecksumAddress, weiToEther, Contract, TinyBig, Block, ContractTypes, JSONABI, JSONABIArgument, Network, Transaction, };

package/lib/esm/index.js

@@ -0,0 +1,9 @@
+import { Contract } from './classes/Contract';
+import { JsonRpcProvider, jsonRpcProvider } from './providers/JsonRpcProvider';
+import { tinyBig, TinyBig } from './shared/tiny-big/tiny-big';
+import * as utils from './utils';
+import { etherToWei } from './utils/ether-to-wei';
+import { isAddress } from './utils/is-address';
+import { toChecksumAddress } from './utils/to-checksum-address';
+import { weiToEther } from './utils/wei-to-ether';
+export { utils, etherToWei, isAddress, jsonRpcProvider, JsonRpcProvider, tinyBig, toChecksumAddress, weiToEther, Contract, TinyBig, };

package/lib/esm/providers/JsonRpcProvider.d.ts

@@ -0,0 +1,10 @@
+import { Block } from '../types/Block.types';
+import { Network } from '../types/Network.types';
+export declare class JsonRpcProvider {
+    readonly _rpcUrl: Array<string>;
+    _rpcUrlCounter: number;
+    constructor(rpcUrl?: string | Array<string>);
+    getBlock(timeFrame: 'latest' | 'earliest' | 'pending' | number, returnTransactionObjects?: boolean): Promise<Block>;
+    getNetwork(): Promise<Network>;
+}
+export declare function jsonRpcProvider(rpcUrl?: string): JsonRpcProvider;

package/lib/esm/providers/JsonRpcProvider.js

@@ -0,0 +1,74 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { cleanBlock } from '../classes/utils/clean-block';
+import { buildRPCPostBody, post } from '../classes/utils/fetchers';
+import { hexToDecimal } from '../classes/utils/hex-to-decimal';
+import chainsInfo from './utils/chains-info';
+export class JsonRpcProvider {
+    constructor(rpcUrl) {
+        this._rpcUrl = (() => {
+            if (!rpcUrl) {
+                return ['https://free-eth-node.com/api/eth'];
+            }
+            else if (!Array.isArray(rpcUrl)) {
+                return [rpcUrl];
+            }
+            return rpcUrl;
+        })();
+        this._rpcUrlCounter = 0;
+    }
+    getBlock(timeFrame, returnTransactionObjects = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let rpcTimeFrame;
+            if (typeof timeFrame === 'number') {
+                rpcTimeFrame = `0x${timeFrame.toString(16)}`;
+            }
+            else {
+                rpcTimeFrame = timeFrame;
+            }
+            const req = () => __awaiter(this, void 0, void 0, function* () {
+                return yield post(this._rpcUrl[this._rpcUrlCounter], buildRPCPostBody('eth_getBlockByNumber', [
+                    rpcTimeFrame,
+                    returnTransactionObjects,
+                ])).catch((e) => {
+                    if (e.code === 'ENOTFOUND') {
+                        this._rpcUrlCounter++;
+                        return req();
+                    }
+                });
+            });
+            const nodeResponse = (yield req());
+            return cleanBlock(nodeResponse, returnTransactionObjects);
+        });
+    }
+    getNetwork() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const req = () => __awaiter(this, void 0, void 0, function* () {
+                return yield post(this._rpcUrl[this._rpcUrlCounter], buildRPCPostBody('eth_chainId', [])).catch((e) => {
+                    if (e.code === 'ENOTFOUND') {
+                        this._rpcUrlCounter++;
+                        return req();
+                    }
+                });
+            });
+            const nodeResponse = (yield req());
+            const chainId = hexToDecimal(nodeResponse);
+            const info = chainsInfo[chainId];
+            return {
+                chainId: Number(chainId),
+                name: info[0] || 'unknown',
+                ensAddress: info[1] || null,
+            };
+        });
+    }
+}
+export function jsonRpcProvider(rpcUrl) {
+    return new JsonRpcProvider(rpcUrl);
+}

package/lib/esm/providers/utils/chains-info.d.ts

@@ -0,0 +1,360 @@
+declare const _default: {
+    "1": string[];
+    "2": string[];
+    "3": string[];
+    "4": string[];
+    "5": string[];
+    "6": string[];
+    "7": string[];
+    "8": string[];
+    "9": string[];
+    "10": string[];
+    "11": string[];
+    "12": string[];
+    "13": string[];
+    "14": string[];
+    "15": string[];
+    "16": string[];
+    "17": string[];
+    "18": string[];
+    "19": string[];
+    "20": string[];
+    "21": string[];
+    "22": string[];
+    "23": string[];
+    "24": string[];
+    "25": string[];
+    "26": string[];
+    "27": string[];
+    "28": string[];
+    "29": string[];
+    "30": string[];
+    "31": string[];
+    "32": string[];
+    "33": string[];
+    "34": string[];
+    "35": string[];
+    "38": string[];
+    "40": string[];
+    "41": string[];
+    "42": string[];
+    "43": string[];
+    "44": string[];
+    "45": string[];
+    "50": string[];
+    "51": string[];
+    "52": string[];
+    "53": string[];
+    "55": string[];
+    "56": string[];
+    "57": string[];
+    "58": string[];
+    "59": string[];
+    "60": string[];
+    "61": string[];
+    "62": string[];
+    "63": string[];
+    "64": string[];
+    "65": string[];
+    "66": string[];
+    "67": string[];
+    "68": string[];
+    "69": string[];
+    "71": string[];
+    "74": string[];
+    "76": string[];
+    "77": string[];
+    "78": string[];
+    "80": string[];
+    "82": string[];
+    "83": string[];
+    "85": string[];
+    "86": string[];
+    "87": string[];
+    "88": string[];
+    "89": string[];
+    "90": string[];
+    "91": string[];
+    "92": string[];
+    "93": string[];
+    "95": string[];
+    "96": string[];
+    "97": string[];
+    "99": string[];
+    "100": string[];
+    "101": string[];
+    "102": string[];
+    "105": string[];
+    "106": string[];
+    "107": string[];
+    "108": string[];
+    "110": string[];
+    "111": string[];
+    "122": string[];
+    "123": string[];
+    "124": string[];
+    "125": string[];
+    "126": string[];
+    "127": string[];
+    "128": string[];
+    "137": string[];
+    "142": string[];
+    "162": string[];
+    "163": string[];
+    "170": string[];
+    "172": string[];
+    "186": string[];
+    "188": string[];
+    "189": string[];
+    "199": string[];
+    "200": string[];
+    "211": string[];
+    "222": string[];
+    "246": string[];
+    "250": string[];
+    "256": string[];
+    "258": string[];
+    "262": string[];
+    "269": string[];
+    "288": string[];
+    "321": string[];
+    "322": string[];
+    "333": string[];
+    "335": string[];
+    "336": string[];
+    "338": string[];
+    "361": string[];
+    "363": string[];
+    "364": string[];
+    "365": string[];
+    "369": string[];
+    "385": string[];
+    "420": string[];
+    "499": string[];
+    "512": string[];
+    "513": string[];
+    "555": string[];
+    "558": string[];
+    "588": string[];
+    "595": string[];
+    "600": string[];
+    "666": string[];
+    "686": string[];
+    "707": string[];
+    "708": string[];
+    "721": string[];
+    "777": string[];
+    "787": string[];
+    "803": string[];
+    "820": string[];
+    "821": string[];
+    "880": string[];
+    "888": string[];
+    "900": string[];
+    "901": string[];
+    "902": string[];
+    "903": string[];
+    "940": string[];
+    "941": string[];
+    "942": string[];
+    "977": string[];
+    "998": string[];
+    "999": string[];
+    "1001": string[];
+    "1007": string[];
+    "1010": string[];
+    "1012": string[];
+    "1022": string[];
+    "1023": string[];
+    "1024": string[];
+    "1028": string[];
+    "1030": string[];
+    "1088": string[];
+    "1139": string[];
+    "1140": string[];
+    "1197": string[];
+    "1201": string[];
+    "1202": string[];
+    "1213": string[];
+    "1214": string[];
+    "1280": string[];
+    "1284": string[];
+    "1285": string[];
+    "1287": string[];
+    "1288": string[];
+    "1618": string[];
+    "1620": string[];
+    "1657": string[];
+    "1856": string[];
+    "1898": string[];
+    "1987": string[];
+    "2020": string[];
+    "2021": string[];
+    "2022": string[];
+    "2025": string[];
+    "2100": string[];
+    "2101": string[];
+    "2213": string[];
+    "2559": string[];
+    "3331": string[];
+    "3333": string[];
+    "3334": string[];
+    "3400": string[];
+    "3500": string[];
+    "3690": string[];
+    "3966": string[];
+    "3967": string[];
+    "4002": string[];
+    "4689": string[];
+    "4690": string[];
+    "4918": string[];
+    "5197": string[];
+    "5315": string[];
+    "5700": string[];
+    "5851": string[];
+    "5869": string[];
+    "6626": string[];
+    "7341": string[];
+    "7878": string[];
+    "8000": string[];
+    "8001": string[];
+    "8029": string[];
+    "8080": string[];
+    "8217": string[];
+    "8285": string[];
+    "8723": string[];
+    "8724": string[];
+    "8888": string[];
+    "8995": string[];
+    "9000": string[];
+    "9001": string[];
+    "9100": string[];
+    "9527": string[];
+    "9999": string[];
+    "10000": string[];
+    "10001": string[];
+    "10101": string[];
+    "10823": string[];
+    "11111": string[];
+    "11437": string[];
+    "12051": string[];
+    "12052": string[];
+    "13381": string[];
+    "16000": string[];
+    "16001": string[];
+    "19845": string[];
+    "21816": string[];
+    "24484": string[];
+    "24734": string[];
+    "31102": string[];
+    "31337": string[];
+    "32659": string[];
+    "39797": string[];
+    "42069": string[];
+    "42161": string[];
+    "42220": string[];
+    "42261": string[];
+    "42262": string[];
+    "43110": string[];
+    "43113": string[];
+    "43114": string[];
+    "44787": string[];
+    "47805": string[];
+    "49797": string[];
+    "53935": string[];
+    "55555": string[];
+    "55556": string[];
+    "60000": string[];
+    "60001": string[];
+    "60002": string[];
+    "60103": string[];
+    "62320": string[];
+    "63000": string[];
+    "63001": string[];
+    "70000": string[];
+    "70001": string[];
+    "70002": string[];
+    "70103": string[];
+    "71393": string[];
+    "73799": string[];
+    "78110": string[];
+    "80001": string[];
+    "99998": string[];
+    "99999": string[];
+    "100000": string[];
+    "100001": string[];
+    "100002": string[];
+    "100003": string[];
+    "100004": string[];
+    "100005": string[];
+    "100006": string[];
+    "100007": string[];
+    "100008": string[];
+    "108801": string[];
+    "110000": string[];
+    "110001": string[];
+    "110002": string[];
+    "110003": string[];
+    "110004": string[];
+    "110005": string[];
+    "110006": string[];
+    "110007": string[];
+    "110008": string[];
+    "200625": string[];
+    "201018": string[];
+    "201030": string[];
+    "210309": string[];
+    "210425": string[];
+    "234666": string[];
+    "246529": string[];
+    "246785": string[];
+    "281121": string[];
+    "333888": string[];
+    "333999": string[];
+    "421611": string[];
+    "444900": string[];
+    "666666": string[];
+    "888888": string[];
+    "955305": string[];
+    "1313114": string[];
+    "1313500": string[];
+    "1337702": string[];
+    "7762959": string[];
+    "11155111": string[];
+    "13371337": string[];
+    "18289463": string[];
+    "20181205": string[];
+    "28945486": string[];
+    "35855456": string[];
+    "61717561": string[];
+    "99415706": string[];
+    "192837465": string[];
+    "245022926": string[];
+    "245022934": string[];
+    "245022940": string[];
+    "311752642": string[];
+    "356256156": string[];
+    "486217935": string[];
+    "1122334455": string[];
+    "1313161554": string[];
+    "1313161555": string[];
+    "1313161556": string[];
+    "1666600000": string[];
+    "1666600001": string[];
+    "1666600002": string[];
+    "1666600003": string[];
+    "1666700000": string[];
+    "1666700001": string[];
+    "1666700002": string[];
+    "1666700003": string[];
+    "2021121117": string[];
+    "3125659152": string[];
+    "4216137055": string[];
+    "11297108099": string[];
+    "11297108109": string[];
+    "197710212030": string[];
+    "197710212031": string[];
+    "6022140761023": string[];
+    "868455272153094": string[];
+};
+export default _default;