essential-eth 0.1.1 → 0.2.0

package/lib/cjs/ether-to-wei.d.ts

@@ -0,0 +1,2 @@
+import { TinyBig } from './shared/tiny-big/tiny-big';
+export declare function etherToWei(etherQuantity: string | number): TinyBig;

package/lib/cjs/ether-to-wei.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.etherToWei = void 0;
+const big_js_1 = __importDefault(require("big.js"));
+const tiny_big_1 = require("./shared/tiny-big/tiny-big");
+const validate_type_1 = require("./shared/validate-type");
+function etherToWei(etherQuantity) {
+    (0, validate_type_1.validateType)(etherQuantity, ['string', 'number']);
+    const result = (0, big_js_1.default)(etherQuantity).times('1000000000000000000').toString();
+    return (0, tiny_big_1.tinyBig)(result);
+}
+exports.etherToWei = etherToWei;

package/lib/cjs/index.d.ts

@@ -0,0 +1,6 @@
+import { etherToWei } from './ether-to-wei';
+import { EssentialEth } from './rpc/index';
+import { tinyBig, TinyBig } from './shared/tiny-big/tiny-big';
+import { toChecksumAddress } from './to-checksum-address';
+import { weiToEther } from './wei-to-ether';
+export { toChecksumAddress, etherToWei, weiToEther, tinyBig, TinyBig, EssentialEth, };

package/lib/cjs/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EssentialEth = exports.TinyBig = exports.tinyBig = exports.weiToEther = exports.etherToWei = exports.toChecksumAddress = void 0;
+const ether_to_wei_1 = require("./ether-to-wei");
+Object.defineProperty(exports, "etherToWei", { enumerable: true, get: function () { return ether_to_wei_1.etherToWei; } });
+const index_1 = require("./rpc/index");
+Object.defineProperty(exports, "EssentialEth", { enumerable: true, get: function () { return index_1.EssentialEth; } });
+const tiny_big_1 = require("./shared/tiny-big/tiny-big");
+Object.defineProperty(exports, "tinyBig", { enumerable: true, get: function () { return tiny_big_1.tinyBig; } });
+Object.defineProperty(exports, "TinyBig", { enumerable: true, get: function () { return tiny_big_1.TinyBig; } });
+const to_checksum_address_1 = require("./to-checksum-address");
+Object.defineProperty(exports, "toChecksumAddress", { enumerable: true, get: function () { return to_checksum_address_1.toChecksumAddress; } });
+const wei_to_ether_1 = require("./wei-to-ether");
+Object.defineProperty(exports, "weiToEther", { enumerable: true, get: function () { return wei_to_ether_1.weiToEther; } });

package/lib/cjs/rpc/get-block.test.d.ts

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

package/lib/cjs/rpc/get-block.test.js

@@ -0,0 +1,66 @@
+"use strict";
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const big_js_1 = __importDefault(require("big.js"));
+const just_omit_1 = __importDefault(require("just-omit"));
+const web3_1 = __importDefault(require("web3"));
+const _1 = require(".");
+const rpcUrl = 'https://free-eth-node.com/api/eth';
+describe('matches web3', () => {
+    function testBlockEquality(block1, block2) {
+        expect((0, just_omit_1.default)(block1, ['totalDifficulty', 'difficulty'])).toStrictEqual((0, just_omit_1.default)(block2, ['totalDifficulty', 'difficulty']));
+        expect((0, big_js_1.default)(block1.difficulty).minus(block2.difficulty).abs().toNumber()).toBeLessThan(3);
+        expect((0, big_js_1.default)(block1.totalDifficulty)
+            .minus(block2.totalDifficulty)
+            .abs()
+            .toNumber()).toBeLessThan(4000000);
+    }
+    it('should allow default eth node to get latest block', () => __awaiter(void 0, void 0, void 0, function* () {
+        const essentialEth = new _1.EssentialEth();
+        const web3 = new web3_1.default(rpcUrl);
+        const [eeLatestBlock, web3LatestBlock] = yield Promise.all([
+            essentialEth.getBlock('latest'),
+            web3.eth.getBlock('latest'),
+        ]);
+        testBlockEquality(eeLatestBlock, web3LatestBlock);
+    }));
+    it('should get latest block', () => __awaiter(void 0, void 0, void 0, function* () {
+        const essentialEth = new _1.EssentialEth(rpcUrl);
+        const web3 = new web3_1.default(rpcUrl);
+        const [eeLatestBlock, web3LatestBlock] = yield Promise.all([
+            essentialEth.getBlock('latest'),
+            web3.eth.getBlock('latest'),
+        ]);
+        testBlockEquality(eeLatestBlock, web3LatestBlock);
+    }));
+    it('should get earliest block', () => __awaiter(void 0, void 0, void 0, function* () {
+        const essentialEth = new _1.EssentialEth(rpcUrl);
+        const web3 = new web3_1.default(rpcUrl);
+        const [eeEarliestBlock, web3EarliestBlock] = yield Promise.all([
+            essentialEth.getBlock('earliest'),
+            web3.eth.getBlock('earliest'),
+        ]);
+        testBlockEquality(eeEarliestBlock, web3EarliestBlock);
+    }));
+    const blockNumber = Math.floor(Math.random() * 13250630);
+    it(`should get random block as decimal integer. (block #${blockNumber})`, () => __awaiter(void 0, void 0, void 0, function* () {
+        const essentialEth = new _1.EssentialEth(rpcUrl);
+        const web3 = new web3_1.default(rpcUrl);
+        const [eeRandomBlock, web3RandomBlock] = yield Promise.all([
+            essentialEth.getBlock(blockNumber, true),
+            web3.eth.getBlock(blockNumber, true),
+        ]);
+        testBlockEquality(eeRandomBlock, web3RandomBlock);
+    }));
+});

package/lib/cjs/rpc/index.d.ts

@@ -0,0 +1,6 @@
+import { Block } from '../types/block.types';
+export declare class EssentialEth {
+    _rpcUrl: string;
+    constructor(rpcUrl?: string);
+    getBlock(timeFrame: 'latest' | 'earliest' | 'pending' | number, returnTransactionObjects?: boolean): Promise<Block>;
+}

package/lib/cjs/rpc/index.js

@@ -0,0 +1,36 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EssentialEth = void 0;
+const clean_block_1 = require("./utils/clean-block");
+const fetchers_1 = require("./utils/fetchers");
+class EssentialEth {
+    constructor(rpcUrl) {
+        this._rpcUrl = rpcUrl || 'https://free-eth-node.com/api/eth';
+    }
+    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 nodeResponse = yield (0, fetchers_1.post)(this._rpcUrl, (0, fetchers_1.buildRPCPostBody)('eth_getBlockByNumber', [
+                rpcTimeFrame,
+                returnTransactionObjects,
+            ])).then((data) => data.result);
+            return (0, clean_block_1.cleanBlock)(nodeResponse, returnTransactionObjects);
+        });
+    }
+}
+exports.EssentialEth = EssentialEth;

package/lib/cjs/rpc/utils/clean-block.d.ts

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

package/lib/cjs/rpc/utils/clean-block.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanBlock = void 0;
+const __1 = require("../..");
+const clean_transaction_1 = require("./clean-transaction");
+const hex_to_decimal_1 = require("./hex-to-decimal");
+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':
+                cleanedBlock[key] = Number((0, hex_to_decimal_1.hexToDecimal)(block[key]));
+                break;
+            case 'difficulty':
+            case 'totalDifficulty':
+                cleanedBlock[key] = (0, hex_to_decimal_1.hexToDecimal)(block[key]);
+                break;
+            case 'miner':
+                if (block[key]) {
+                    cleanedBlock[key] = (0, __1.toChecksumAddress)(block[key]);
+                }
+                break;
+        }
+    });
+    if (returnTransactionObjects) {
+        cleanedBlock.transactions.forEach((transaction, index) => {
+            cleanedBlock.transactions[index] = (0, clean_transaction_1.cleanTransaction)(transaction);
+        });
+    }
+    return cleanedBlock;
+}
+exports.cleanBlock = cleanBlock;

package/lib/cjs/rpc/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/cjs/rpc/utils/clean-transaction.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanTransaction = void 0;
+const __1 = require("../..");
+const hex_to_decimal_1 = require("./hex-to-decimal");
+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((0, hex_to_decimal_1.hexToDecimal)(transaction[key]));
+                break;
+            case 'gasPrice':
+            case 'value':
+                cleanedTransaction[key] = (0, hex_to_decimal_1.hexToDecimal)(transaction[key]);
+                break;
+            case 'from':
+            case 'to':
+                if (transaction[key]) {
+                    cleanedTransaction[key] = (0, __1.toChecksumAddress)(transaction[key]);
+                }
+                break;
+        }
+    });
+    return cleanedTransaction;
+}
+exports.cleanTransaction = cleanTransaction;

package/lib/cjs/rpc/utils/fetchers.d.ts

@@ -0,0 +1,7 @@
+export declare function post(url: string, body: Record<string, unknown>): Promise<any>;
+export declare function buildRPCPostBody(method: 'eth_getBlockByNumber', params: any[]): {
+    jsonrpc: string;
+    id: number;
+    method: "eth_getBlockByNumber";
+    params: any[];
+};

package/lib/cjs/rpc/utils/fetchers.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRPCPostBody = exports.post = void 0;
+const isomorphic_unfetch_1 = __importDefault(require("isomorphic-unfetch"));
+function post(url, body) {
+    return (0, isomorphic_unfetch_1.default)(url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(body),
+    }).then((r) => r.json());
+}
+exports.post = post;
+function buildRPCPostBody(method, params) {
+    return {
+        jsonrpc: '2.0',
+        id: 1,
+        method,
+        params,
+    };
+}
+exports.buildRPCPostBody = buildRPCPostBody;

package/lib/cjs/rpc/utils/hex-to-decimal.d.ts

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

package/lib/cjs/rpc/utils/hex-to-decimal.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hexToDecimal = void 0;
+function hexToDecimal(hex) {
+    return BigInt(hex).toString();
+}
+exports.hexToDecimal = hexToDecimal;

package/lib/cjs/shared/tiny-big/helpers.d.ts

@@ -0,0 +1 @@
+export declare function scientificStrToDecimalStr(scientificString: string): string;

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scientificStrToDecimalStr = void 0;
+function stripTrailingZeroes(numberString) {
+    const isNegative = numberString.startsWith('-');
+    numberString = numberString.replace('-', '');
+    numberString = numberString.replace(/\.0*$/g, '');
+    numberString = numberString.replace(/^0+/, '');
+    if (numberString.includes('.')) {
+        numberString = numberString.replace(/0+$/, '');
+    }
+    if (numberString.startsWith('.')) {
+        numberString = `0${numberString}`;
+    }
+    return `${isNegative ? '-' : ''}${numberString}`;
+}
+function scientificStrToDecimalStr(scientificString) {
+    if (!scientificString.match(/e/i)) {
+        return stripTrailingZeroes(scientificString);
+    }
+    let [base, power] = scientificString.split(/e/i);
+    const isNegative = Number(base) < 0;
+    base = base.replace('-', '');
+    base = stripTrailingZeroes(base);
+    const [wholeNumber, fraction = ''] = 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) {
+            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))) {
+                splitPaddedNumber = ['.', ...splitPaddedNumber];
+            }
+            else {
+                splitPaddedNumber.splice(splitPaddedNumber.length - Math.abs(Number(power)), 0, '.');
+            }
+        }
+        else {
+            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/lib/cjs/shared/tiny-big/helpers.test.d.ts

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

package/lib/cjs/shared/tiny-big/helpers.test.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_1 = require("./helpers");
+describe('scientificStrToDecimalStr', () => {
+    it('not even scientific', () => {
+        expect((0, helpers_1.scientificStrToDecimalStr)('010')).toStrictEqual('10');
+        expect((0, helpers_1.scientificStrToDecimalStr)('-010')).toStrictEqual('-10');
+    });
+    it('zero power', () => {
+        expect((0, helpers_1.scientificStrToDecimalStr)('10e0')).toStrictEqual('10');
+        expect((0, helpers_1.scientificStrToDecimalStr)('1.0e0')).toStrictEqual('1');
+        expect((0, helpers_1.scientificStrToDecimalStr)('-10e-0')).toStrictEqual('-10');
+        expect((0, helpers_1.scientificStrToDecimalStr)('-1.0e-0')).toStrictEqual('-1');
+        expect((0, helpers_1.scientificStrToDecimalStr)('-1.10e-0')).toStrictEqual('-1.1');
+        expect((0, helpers_1.scientificStrToDecimalStr)('-1.e-0')).toStrictEqual('-1');
+        expect((0, helpers_1.scientificStrToDecimalStr)('.10e-0')).toStrictEqual('0.1');
+        expect((0, helpers_1.scientificStrToDecimalStr)('00.0010e-0')).toStrictEqual('0.001');
+    });
+    it('negative power', () => {
+        expect((0, helpers_1.scientificStrToDecimalStr)('0100e-2')).toStrictEqual('1');
+        expect((0, helpers_1.scientificStrToDecimalStr)('0100e-4')).toStrictEqual('0.01');
+        expect((0, helpers_1.scientificStrToDecimalStr)('010.1e-3')).toStrictEqual('0.0101');
+        expect((0, helpers_1.scientificStrToDecimalStr)('-010.1e-3')).toStrictEqual('-0.0101');
+        expect((0, helpers_1.scientificStrToDecimalStr)('09.1e-51')).toStrictEqual(`0.${'0'.repeat(50)}91`);
+    });
+    it('positive power', () => {
+        expect((0, helpers_1.scientificStrToDecimalStr)('01e2')).toStrictEqual('100');
+        expect((0, helpers_1.scientificStrToDecimalStr)('-01e2')).toStrictEqual('-100');
+        expect((0, helpers_1.scientificStrToDecimalStr)('09.1e51')).toStrictEqual(`91${'0'.repeat(50)}`);
+    });
+});

package/lib/cjs/shared/tiny-big/tiny-big.d.ts

@@ -0,0 +1,7 @@
+import Big from 'big.js';
+export declare class TinyBig extends Big {
+    constructor(value: number | string);
+    toNumber(): number;
+    toString(): string;
+}
+export declare function tinyBig(value: number | string): TinyBig;

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

@@ -0,0 +1,27 @@
+"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 helpers_1 = require("./helpers");
+class TinyBig extends big_js_1.default {
+    constructor(value) {
+        super(value);
+    }
+    toNumber() {
+        return Number((0, helpers_1.scientificStrToDecimalStr)(super.toString()));
+    }
+    toString() {
+        if (this.toNumber() === 0) {
+            return '0';
+        }
+        return (0, helpers_1.scientificStrToDecimalStr)(super.toString());
+    }
+}
+exports.TinyBig = TinyBig;
+function tinyBig(value) {
+    return new TinyBig(value);
+}
+exports.tinyBig = tinyBig;

package/lib/cjs/shared/validate-type.d.ts

@@ -0,0 +1,3 @@
+declare type JSPrimitiveTypes = 'string' | 'number' | 'bigint' | 'boolean' | 'symbol' | 'undefined' | 'object' | 'function';
+export declare const validateType: (value: unknown, allowedTypes: JSPrimitiveTypes[]) => void;
+export {};

package/lib/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/lib/cjs/to-checksum-address.d.ts

@@ -0,0 +1 @@
+export declare function toChecksumAddress(address: string): string;

package/lib/cjs/to-checksum-address.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toChecksumAddress = void 0;
+const sha3_1 = require("sha3");
+const validate_type_1 = require("./shared/validate-type");
+function toChecksumAddress(address) {
+    (0, validate_type_1.validateType)(address, ['string']);
+    if (!/^(0x)?[0-9a-f]{40}$/i.test(address)) {
+        throw new Error(`Invalid Ethereum address "${address}"`);
+    }
+    address = address.toLowerCase().replace(/^0x/i, '');
+    const keccak = new sha3_1.Keccak(256);
+    const addressHash = keccak.update(address).digest('hex').replace(/^0x/i, '');
+    let checksumAddress = '0x';
+    for (let i = 0; i < address.length; i++) {
+        if (parseInt(addressHash[i], 16) > 7) {
+            checksumAddress += address[i].toUpperCase();
+        }
+        else {
+            checksumAddress += address[i];
+        }
+    }
+    return checksumAddress;
+}
+exports.toChecksumAddress = toChecksumAddress;

package/lib/cjs/types/block.types.d.ts

@@ -0,0 +1,47 @@
+import { RPCTransaction, Transaction } from './transaction.types';
+export interface Block {
+    baseFeePerGas: string;
+    difficulty: number;
+    extraData: string;
+    gasLimit: number;
+    gasUsed: number;
+    hash: string;
+    logsBloom: string;
+    miner: string;
+    mixHash: string;
+    nonce: string;
+    number: number;
+    parentHash: string;
+    receiptsRoot: string;
+    sha3Uncles: string;
+    size: number;
+    stateRoot: string;
+    timestamp: number;
+    totalDifficulty: number;
+    transactions: string[] | Transaction[];
+    transactionsRoot: string;
+    uncles: unknown[];
+}
+export interface RPCBlock {
+    baseFeePerGas: string;
+    difficulty: string;
+    extraData: string;
+    gasLimit: string;
+    gasUsed: string;
+    hash: string;
+    logsBloom: string;
+    miner: string;
+    mixHash: string;
+    nonce: string;
+    number: string;
+    parentHash: string;
+    receiptsRoot: string;
+    sha3Uncles: string;
+    size: string;
+    stateRoot: string;
+    timestamp: string;
+    totalDifficulty: string;
+    transactions: Array<string> | Array<RPCTransaction>;
+    transactionsRoot: string;
+    uncles: unknown[];
+}

package/lib/cjs/types/block.types.js

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

package/lib/cjs/types/transaction.types.d.ts

@@ -0,0 +1,34 @@
+export interface Transaction {
+    blockHash: string;
+    blockNumber: number;
+    from: string;
+    gas: number;
+    gasPrice: string;
+    hash: string;
+    input: string;
+    nonce: number;
+    r: string;
+    s: string;
+    to: string;
+    transactionIndex: number;
+    type: number;
+    v: string;
+    value: string;
+}
+export interface RPCTransaction {
+    blockHash: string;
+    blockNumber: string;
+    from: string;
+    gas: string;
+    gasPrice: string;
+    hash: string;
+    input: string;
+    nonce: string;
+    r: string;
+    s: string;
+    to: string;
+    transactionIndex: string;
+    type: string;
+    v: string;
+    value: string;
+}

package/lib/cjs/types/transaction.types.js

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

package/lib/cjs/wei-to-ether.d.ts

@@ -0,0 +1 @@
+export declare function weiToEther(weiQuantity: string | number): import("./shared/tiny-big/tiny-big").TinyBig;

package/lib/cjs/wei-to-ether.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.weiToEther = void 0;
+const big_js_1 = __importDefault(require("big.js"));
+const tiny_big_1 = require("./shared/tiny-big/tiny-big");
+const validate_type_1 = require("./shared/validate-type");
+function weiToEther(weiQuantity) {
+    (0, validate_type_1.validateType)(weiQuantity, ['string', 'number']);
+    const result = (0, big_js_1.default)(weiQuantity).div('1000000000000000000').toString();
+    return (0, tiny_big_1.tinyBig)(result);
+}
+exports.weiToEther = weiToEther;

package/lib/esm/index.d.ts

@@ -1,5 +1,6 @@
 import { etherToWei } from './ether-to-wei';
+import { EssentialEth } from './rpc/index';
 import { tinyBig, TinyBig } from './shared/tiny-big/tiny-big';
 import { toChecksumAddress } from './to-checksum-address';
 import { weiToEther } from './wei-to-ether';
-export { toChecksumAddress, etherToWei, weiToEther, tinyBig, TinyBig };
+export { toChecksumAddress, etherToWei, weiToEther, tinyBig, TinyBig, EssentialEth, };

package/lib/esm/index.js

@@ -1,5 +1,6 @@
 import { etherToWei } from './ether-to-wei';
+import { EssentialEth } from './rpc/index';
 import { tinyBig, TinyBig } from './shared/tiny-big/tiny-big';
 import { toChecksumAddress } from './to-checksum-address';
 import { weiToEther } from './wei-to-ether';
-export { toChecksumAddress, etherToWei, weiToEther, tinyBig, TinyBig };
+export { toChecksumAddress, etherToWei, weiToEther, tinyBig, TinyBig, EssentialEth, };

package/lib/esm/rpc/get-block.test.d.ts

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

package/lib/esm/rpc/get-block.test.js

@@ -0,0 +1,61 @@
+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 Big from 'big.js';
+import omit from 'just-omit';
+import Web3 from 'web3';
+import { EssentialEth } from '.';
+const rpcUrl = 'https://free-eth-node.com/api/eth';
+describe('matches web3', () => {
+    function testBlockEquality(block1, block2) {
+        expect(omit(block1, ['totalDifficulty', 'difficulty'])).toStrictEqual(omit(block2, ['totalDifficulty', 'difficulty']));
+        expect(Big(block1.difficulty).minus(block2.difficulty).abs().toNumber()).toBeLessThan(3);
+        expect(Big(block1.totalDifficulty)
+            .minus(block2.totalDifficulty)
+            .abs()
+            .toNumber()).toBeLessThan(4000000);
+    }
+    it('should allow default eth node to get latest block', () => __awaiter(void 0, void 0, void 0, function* () {
+        const essentialEth = new EssentialEth();
+        const web3 = new Web3(rpcUrl);
+        const [eeLatestBlock, web3LatestBlock] = yield Promise.all([
+            essentialEth.getBlock('latest'),
+            web3.eth.getBlock('latest'),
+        ]);
+        testBlockEquality(eeLatestBlock, web3LatestBlock);
+    }));
+    it('should get latest block', () => __awaiter(void 0, void 0, void 0, function* () {
+        const essentialEth = new EssentialEth(rpcUrl);
+        const web3 = new Web3(rpcUrl);
+        const [eeLatestBlock, web3LatestBlock] = yield Promise.all([
+            essentialEth.getBlock('latest'),
+            web3.eth.getBlock('latest'),
+        ]);
+        testBlockEquality(eeLatestBlock, web3LatestBlock);
+    }));
+    it('should get earliest block', () => __awaiter(void 0, void 0, void 0, function* () {
+        const essentialEth = new EssentialEth(rpcUrl);
+        const web3 = new Web3(rpcUrl);
+        const [eeEarliestBlock, web3EarliestBlock] = yield Promise.all([
+            essentialEth.getBlock('earliest'),
+            web3.eth.getBlock('earliest'),
+        ]);
+        testBlockEquality(eeEarliestBlock, web3EarliestBlock);
+    }));
+    const blockNumber = Math.floor(Math.random() * 13250630);
+    it(`should get random block as decimal integer. (block #${blockNumber})`, () => __awaiter(void 0, void 0, void 0, function* () {
+        const essentialEth = new EssentialEth(rpcUrl);
+        const web3 = new Web3(rpcUrl);
+        const [eeRandomBlock, web3RandomBlock] = yield Promise.all([
+            essentialEth.getBlock(blockNumber, true),
+            web3.eth.getBlock(blockNumber, true),
+        ]);
+        testBlockEquality(eeRandomBlock, web3RandomBlock);
+    }));
+});

package/lib/esm/rpc/index.d.ts

@@ -0,0 +1,6 @@
+import { Block } from '../types/block.types';
+export declare class EssentialEth {
+    _rpcUrl: string;
+    constructor(rpcUrl?: string);
+    getBlock(timeFrame: 'latest' | 'earliest' | 'pending' | number, returnTransactionObjects?: boolean): Promise<Block>;
+}

package/lib/esm/rpc/index.js

@@ -0,0 +1,32 @@
+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 './utils/clean-block';
+import { buildRPCPostBody, post } from './utils/fetchers';
+export class EssentialEth {
+    constructor(rpcUrl) {
+        this._rpcUrl = rpcUrl || 'https://free-eth-node.com/api/eth';
+    }
+    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 nodeResponse = yield post(this._rpcUrl, buildRPCPostBody('eth_getBlockByNumber', [
+                rpcTimeFrame,
+                returnTransactionObjects,
+            ])).then((data) => data.result);
+            return cleanBlock(nodeResponse, returnTransactionObjects);
+        });
+    }
+}

package/lib/esm/rpc/utils/clean-block.d.ts

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

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

@@ -0,0 +1,34 @@
+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':
+                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/rpc/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/rpc/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/rpc/utils/fetchers.d.ts

@@ -0,0 +1,7 @@
+export declare function post(url: string, body: Record<string, unknown>): Promise<any>;
+export declare function buildRPCPostBody(method: 'eth_getBlockByNumber', params: any[]): {
+    jsonrpc: string;
+    id: number;
+    method: "eth_getBlockByNumber";
+    params: any[];
+};

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

@@ -0,0 +1,18 @@
+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());
+}
+export function buildRPCPostBody(method, params) {
+    return {
+        jsonrpc: '2.0',
+        id: 1,
+        method,
+        params,
+    };
+}

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

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

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

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

package/lib/esm/shared/tiny-big/tiny-big.d.ts

@@ -1,6 +1,5 @@
 import Big from 'big.js';
-export declare class TinyBig {
-    __value: Big;
+export declare class TinyBig extends Big {
     constructor(value: number | string);
     toNumber(): number;
     toString(): string;

package/lib/esm/shared/tiny-big/tiny-big.js

@@ -1,14 +1,17 @@
 import Big from 'big.js';
 import { scientificStrToDecimalStr } from './helpers';
-export class TinyBig {
+export class TinyBig extends Big {
     constructor(value) {
-        this.__value = Big(value);
+        super(value);
     }
     toNumber() {
-        return Number(scientificStrToDecimalStr(this.__value.toString()));
+        return Number(scientificStrToDecimalStr(super.toString()));
     }
     toString() {
-        return scientificStrToDecimalStr(this.__value.toString());
+        if (this.toNumber() === 0) {
+            return '0';
+        }
+        return scientificStrToDecimalStr(super.toString());
     }
 }
 export function tinyBig(value) {

package/lib/esm/to-checksum-address.js

@@ -1,15 +1,21 @@
-import createKeccakHash from 'keccak';
+import { Keccak } from 'sha3';
+import { validateType } from './shared/validate-type';
 export function toChecksumAddress(address) {
-    address = address.toLowerCase().replace('0x', '');
-    const hash = createKeccakHash('keccak256').update(address).digest('hex');
-    let ret = '0x';
+    validateType(address, ['string']);
+    if (!/^(0x)?[0-9a-f]{40}$/i.test(address)) {
+        throw new Error(`Invalid Ethereum address "${address}"`);
+    }
+    address = address.toLowerCase().replace(/^0x/i, '');
+    const keccak = new Keccak(256);
+    const addressHash = keccak.update(address).digest('hex').replace(/^0x/i, '');
+    let checksumAddress = '0x';
     for (let i = 0; i < address.length; i++) {
-        if (parseInt(hash[i], 16) >= 8) {
-            ret += address[i].toUpperCase();
+        if (parseInt(addressHash[i], 16) > 7) {
+            checksumAddress += address[i].toUpperCase();
         }
         else {
-            ret += address[i];
+            checksumAddress += address[i];
         }
     }
-    return ret;
+    return checksumAddress;
 }

package/lib/esm/types/block.types.d.ts

@@ -0,0 +1,47 @@
+import { RPCTransaction, Transaction } from './transaction.types';
+export interface Block {
+    baseFeePerGas: string;
+    difficulty: number;
+    extraData: string;
+    gasLimit: number;
+    gasUsed: number;
+    hash: string;
+    logsBloom: string;
+    miner: string;
+    mixHash: string;
+    nonce: string;
+    number: number;
+    parentHash: string;
+    receiptsRoot: string;
+    sha3Uncles: string;
+    size: number;
+    stateRoot: string;
+    timestamp: number;
+    totalDifficulty: number;
+    transactions: string[] | Transaction[];
+    transactionsRoot: string;
+    uncles: unknown[];
+}
+export interface RPCBlock {
+    baseFeePerGas: string;
+    difficulty: string;
+    extraData: string;
+    gasLimit: string;
+    gasUsed: string;
+    hash: string;
+    logsBloom: string;
+    miner: string;
+    mixHash: string;
+    nonce: string;
+    number: string;
+    parentHash: string;
+    receiptsRoot: string;
+    sha3Uncles: string;
+    size: string;
+    stateRoot: string;
+    timestamp: string;
+    totalDifficulty: string;
+    transactions: Array<string> | Array<RPCTransaction>;
+    transactionsRoot: string;
+    uncles: unknown[];
+}

package/lib/esm/types/block.types.js

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

package/lib/esm/types/transaction.types.d.ts

@@ -0,0 +1,34 @@
+export interface Transaction {
+    blockHash: string;
+    blockNumber: number;
+    from: string;
+    gas: number;
+    gasPrice: string;
+    hash: string;
+    input: string;
+    nonce: number;
+    r: string;
+    s: string;
+    to: string;
+    transactionIndex: number;
+    type: number;
+    v: string;
+    value: string;
+}
+export interface RPCTransaction {
+    blockHash: string;
+    blockNumber: string;
+    from: string;
+    gas: string;
+    gasPrice: string;
+    hash: string;
+    input: string;
+    nonce: string;
+    r: string;
+    s: string;
+    to: string;
+    transactionIndex: string;
+    type: string;
+    v: string;
+    value: string;
+}

package/lib/esm/types/transaction.types.js

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "essential-eth",
   "description": "Ultralight JS library for Ethereum utilities",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "license": "MIT",
   "sideEffects": false,
   "main": "./lib/cjs/index.js",
@@ -9,44 +9,60 @@
   "files": [
     "lib/"
   ],
+  "bugs": {
+    "url": "https://github.com/dawsbot/essential-eth/issues"
+  },
+  "repository": "https://github.com/dawsbot/essential-eth.git",
+  "author": "@dawsbot",
   "scripts": {
-    "test": "npm-run-all --parallel jest tsc lint",
+    "test": "npm-run-all --parallel jest compile lint",
     "lint": "eslint .",
-    "tsc": "npm-run-all --parallel tsc:esm tsc:cjs",
+    "compile": "npm-run-all --parallel tsc:esm tsc:cjs",
     "tsc:esm": "tsc -p tsconfig.json",
     "tsc:cjs": "tsc -p tsconfig-cjs.json",
-    "build": "rm -rf lib && tsc",
-    "prepublishOnly": "npm run build && npm-run-all build:website build:website:new-version",
+    "build": "rm -rf lib && npm run compile",
+    "prepublishOnly": "npm run build && npm run build:website && npm run build:website:new-version",
     "jest": "jest",
-    "build:website": "typedoc --options typedoc/options.js",
+    "build:website": "sh scripts/build-website.sh",
     "build:website:new-version": "typedoc --options typedoc/options-new-version.js"
   },
   "devDependencies": {
     "@ethersproject/keccak256": "^5.4.0",
     "@types/big.js": "^6.1.2",
+    "@types/body-parser": "^1.19.1",
+    "@types/eslint": "^7.28.0",
+    "@types/express": "^4.17.13",
     "@types/jest": "^27.0.1",
-    "@types/keccak": "^3.0.1",
-    "@types/node": "^16.9.1",
-    "@typescript-eslint/eslint-plugin": "^4.31.0",
-    "@typescript-eslint/parser": "^4.31.0",
+    "@types/jest-dev-server": "^5.0.0",
+    "@types/node": "^16.9.2",
+    "@types/prettier": "^2.3.2",
+    "@types/supertest": "^2.0.11",
+    "@typescript-eslint/eslint-plugin": "^4.31.1",
+    "@typescript-eslint/parser": "^4.31.1",
+    "body-parser": "^1.19.0",
     "eslint": "^7.32.0",
-    "eslint-plugin-jest": "^24.4.0",
-    "ethers": "^5.4.6",
+    "eslint-plugin-jest": "^24.4.2",
+    "ethers": "^5.4.7",
+    "express": "^4.17.1",
     "husky": "^4.3.0",
-    "jest": "^27.1.1",
+    "jest": "^27.2.0",
+    "jest-dev-server": "^5.0.3",
+    "just-omit": "^1.2.0",
     "lint-staged": "^11.1.2",
     "npm-run-all": "^4.1.5",
-    "prettier": "^2.4.0",
+    "prettier": "^2.4.1",
     "prettier-plugin-organize-imports": "^2.3.3",
+    "supertest": "^6.1.6",
     "ts-jest": "^27.0.5",
     "ts-node": "^10.2.1",
-    "typedoc": "^0.22.2",
+    "typedoc": "^0.22.3",
     "typescript": "^4.4.3",
     "web3": "^1.5.2"
   },
   "dependencies": {
     "big.js": "^6.1.1",
-    "keccak": "^3.0.2"
+    "isomorphic-unfetch": "^3.1.0",
+    "sha3": "^2.1.4"
   },
   "husky": {
     "hooks": {

package/readme.md

@@ -1,4 +1,24 @@
-# Essential Eth
+<p align="center">
+  <a><img src="https://blog.ethereum.org/img/2018/08/grants_eth_logo.png" title="Ethereum triangle" height="300"/></a>
+</p>
+<p align="center">
+  <b>
+    Essential Eth
+  </b>
+  <br>
+  <i>Ultralight Ethereum utilities for JS and TS</i>
+  <br>
+</p>
+
+---
+
+<p align="center">
+<img src="https://user-images.githubusercontent.com/3408480/133322814-f3d18424-4ba8-4a37-8cbc-c5e6828354a3.png" title="Ethereum triangle" width="900"/>
+</p>
+
+---
+
+<br>
 
 ![](https://badgen.net/bundlephobia/minzip/essential-eth) ![](https://badgen.net/bundlephobia/tree-shaking/essential-eth)
 
@@ -6,10 +26,77 @@
 ![](https://badgen.net/bundlephobia/min/essential-eth)
 ![](https://badgen.net/bundlephobia/dependency-count/essential-eth)
 
+👨🏻‍💻 Breaking changes will exist between minor versions until `1.0.0` (Versions go `major.minor.patch`)
+
 ## Features
 
 - ⚡️ A replacement for the utils in web3.js and ethers.js
 - 🏎 [The TINIEST code size possible](https://bundlephobia.com/package/essential-eth)
-- ʦ Fully typed with TypeScript
+- ʦ Fully typed with TypeScript (also works with JavaScript)
 - 🌲 Tree-shaking and no side-effects
+- 🧪 Tested heavily to match both web3 and ethers.js
 - 👩‍⚖️ MIT License
+
+## Install
+
+```sh
+npm install --save essential-eth # TypeScript types load automatically
+
+# or if you prefer yarn
+yarn add essential-eth # TypeScript types load automatically
+```
+
+## Utils (do not require connecting to an Eth node)
+
+```typescript
+import { etherToWei } from 'essential-eth';
+
+// or in a non-import environment
+const { etherToWei } = require('essential-eth');
+```
+
+#### `etherToWei`
+
+```typescript
+// convert ether to wei
+etherToWei(etherQuantity: string | number): TinyBig
+```
+
+#### `weiToEther`
+
+```typescript
+// convert wei to ether
+weiToEther(weiQuantity: string | number): TinyBig
+```
+
+#### `toChecksumAddress`
+
+```typescript
+// return proper mixed-case address
+toChecksumAddress(address: string): string
+```
+
+## RPC
+
+```typescript
+import { EssentialEth } from 'essential-eth';
+const essentialEth = new EssentialEth('RPC URL HERE' /* Try POKT or Infura */);
+// OR for very quick testing (limited to 500 requests)
+const essentialEth = new EssentialEth();
+```
+
+#### `getBlock`
+
+Returns a [Block](src/types/block.types.ts)
+
+```typescript
+// Same API as web3.eth.getBlock
+getBlock(timeFrame: number | "latest" | "earliest" | "pending", returnTransactionObjects?: boolean): Promise<Block>
+```
+
+<br/>
+<br/>
+
+- [📓 View full docs](https://essential-eth.vercel.app)
+- [📓 View changelog (by looking at releases diff)](https://github.com/dawsbot/essential-eth/releases)
+- [📓 View docs for an older version](https://essential-eth.vercel.app/versions)