essential-eth 0.1.4 → 0.2.0

package/lib/cjs/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/cjs/index.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TinyBig = exports.tinyBig = exports.weiToEther = exports.etherToWei = exports.toChecksumAddress = void 0;
+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; } });

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/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/cjs/shared/tiny-big/tiny-big.js

@@ -6,15 +6,18 @@ 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 {
+class TinyBig extends big_js_1.default {
     constructor(value) {
-        this.__value = (0, big_js_1.default)(value);
+        super(value);
     }
     toNumber() {
-        return Number((0, helpers_1.scientificStrToDecimalStr)(this.__value.toString()));
+        return Number((0, helpers_1.scientificStrToDecimalStr)(super.toString()));
     }
     toString() {
-        return (0, helpers_1.scientificStrToDecimalStr)(this.__value.toString());
+        if (this.toNumber() === 0) {
+            return '0';
+        }
+        return (0, helpers_1.scientificStrToDecimalStr)(super.toString());
     }
 }
 exports.TinyBig = TinyBig;

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/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/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.4",
+  "version": "0.2.0",
   "license": "MIT",
   "sideEffects": false,
   "main": "./lib/cjs/index.js",
@@ -29,19 +29,30 @@
   "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/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.2",
     "ethers": "^5.4.7",
+    "express": "^4.17.1",
     "husky": "^4.3.0",
     "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.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.3",
@@ -50,6 +61,7 @@
   },
   "dependencies": {
     "big.js": "^6.1.1",
+    "isomorphic-unfetch": "^3.1.0",
     "sha3": "^2.1.4"
   },
   "husky": {

package/readme.md

@@ -26,12 +26,15 @@
 ![](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 (also works with JavaScript)
 - 🌲 Tree-shaking and no side-effects
+- 🧪 Tested heavily to match both web3 and ethers.js
 - 👩‍⚖️ MIT License
 
 ## Install
@@ -43,7 +46,7 @@ npm install --save essential-eth # TypeScript types load automatically
 yarn add essential-eth # TypeScript types load automatically
 ```
 
-## Require
+## Utils (do not require connecting to an Eth node)
 
 ```typescript
 import { etherToWei } from 'essential-eth';
@@ -52,18 +55,48 @@ import { etherToWei } from 'essential-eth';
 const { etherToWei } = require('essential-eth');
 ```
 
-## Functions
+#### `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)