essential-eth 0.2.2 → 0.3.3

package/lib/esm/classes/test/Contract/uniswap-abi.js

@@ -0,0 +1,116 @@
+export const uniswapABI = [
+    {
+        inputs: [
+            {
+                internalType: 'address',
+                name: 'token_',
+                type: 'address',
+            },
+            {
+                internalType: 'bytes32',
+                name: 'merkleRoot_',
+                type: 'bytes32',
+            },
+        ],
+        stateMutability: 'nonpayable',
+        type: 'constructor',
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: false,
+                internalType: 'uint256',
+                name: 'index',
+                type: 'uint256',
+            },
+            {
+                indexed: false,
+                internalType: 'address',
+                name: 'account',
+                type: 'address',
+            },
+            {
+                indexed: false,
+                internalType: 'uint256',
+                name: 'amount',
+                type: 'uint256',
+            },
+        ],
+        name: 'Claimed',
+        type: 'event',
+    },
+    {
+        inputs: [
+            {
+                internalType: 'uint256',
+                name: 'index',
+                type: 'uint256',
+            },
+            {
+                internalType: 'address',
+                name: 'account',
+                type: 'address',
+            },
+            {
+                internalType: 'uint256',
+                name: 'amount',
+                type: 'uint256',
+            },
+            {
+                internalType: 'bytes32[]',
+                name: 'merkleProof',
+                type: 'bytes32[]',
+            },
+        ],
+        name: 'claim',
+        outputs: [],
+        stateMutability: 'nonpayable',
+        type: 'function',
+    },
+    {
+        inputs: [
+            {
+                internalType: 'uint256',
+                name: 'index',
+                type: 'uint256',
+            },
+        ],
+        name: 'isClaimed',
+        outputs: [
+            {
+                internalType: 'bool',
+                name: '',
+                type: 'bool',
+            },
+        ],
+        stateMutability: 'view',
+        type: 'function',
+    },
+    {
+        inputs: [],
+        name: 'merkleRoot',
+        outputs: [
+            {
+                internalType: 'bytes32',
+                name: '',
+                type: 'bytes32',
+            },
+        ],
+        stateMutability: 'view',
+        type: 'function',
+    },
+    {
+        inputs: [],
+        name: 'token',
+        outputs: [
+            {
+                internalType: 'address',
+                name: '',
+                type: 'address',
+            },
+        ],
+        stateMutability: 'view',
+        type: 'function',
+    },
+];

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,85 @@
+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;
+        if (inputType === 'bool') {
+            return arg ? hexTrue : hexFalse;
+        }
+        else 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 === 'address') {
+            rawArg = arg.replace(/^0x/g, '').toLowerCase();
+        }
+        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}" inputs. 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';
+export declare function buildRPCPostBody(method: RPCMethodName, params: any[]): {
+    jsonrpc: string;
+    id: number;
+    method: RPCMethodName;
+    params: any[];
+};
+export {};

package/lib/esm/{rpc → classes}/utils/fetchers.js

@@ -6,7 +6,14 @@ export function post(url, body) {
             'Content-Type': 'application/json',
         },
         body: JSON.stringify(body),
-    }).then((r) => r.json());
+    })
+        .then((r) => r.json())
+        .then((response) => {
+        if (response.error) {
+            throw new Error(response.error);
+        }
+        return response.result;
+    });
 }
 export function buildRPCPostBody(method, params) {
     return {

package/lib/esm/index.d.ts

@@ -1,7 +1,11 @@
-import { etherToWei } from './ether-to-wei';
-import { isAddress } from './is-address';
-import { EssentialEth } from './rpc/index';
+import { Transaction } from 'ethers';
+import { Contract } from './classes/Contract';
+import { JsonRpcProvider, jsonRpcProvider } from './providers/JsonRpcProvider';
 import { tinyBig, TinyBig } from './shared/tiny-big/tiny-big';
-import { toChecksumAddress } from './to-checksum-address';
-import { weiToEther } from './wei-to-ether';
-export { toChecksumAddress, isAddress, etherToWei, weiToEther, tinyBig, TinyBig, EssentialEth, };
+import { Block } from './types/block.types';
+import { JSONABI, JSONABIArgument } from './types/Contract.types';
+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 { jsonRpcProvider, JsonRpcProvider, toChecksumAddress, isAddress, etherToWei, weiToEther, tinyBig, TinyBig, Contract, JSONABI, Block, JSONABIArgument, Transaction, };

package/lib/esm/index.js

@@ -1,7 +1,8 @@
-import { etherToWei } from './ether-to-wei';
-import { isAddress } from './is-address';
-import { EssentialEth } from './rpc/index';
+import { Contract } from './classes/Contract';
+import { JsonRpcProvider, jsonRpcProvider } from './providers/JsonRpcProvider';
 import { tinyBig, TinyBig } from './shared/tiny-big/tiny-big';
-import { toChecksumAddress } from './to-checksum-address';
-import { weiToEther } from './wei-to-ether';
-export { toChecksumAddress, isAddress, etherToWei, weiToEther, tinyBig, TinyBig, EssentialEth, };
+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 { jsonRpcProvider, JsonRpcProvider, toChecksumAddress, isAddress, etherToWei, weiToEther, tinyBig, TinyBig, Contract, };

package/lib/esm/{rpc/index.d.ts → providers/JsonRpcProvider.d.ts}

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

package/lib/esm/{rpc/index.js → providers/JsonRpcProvider.js}

@@ -7,9 +7,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { cleanBlock } from './utils/clean-block';
-import { buildRPCPostBody, post } from './utils/fetchers';
-export class EssentialEth {
+import { cleanBlock } from '../classes/utils/clean-block';
+import { buildRPCPostBody, post } from '../classes/utils/fetchers';
+export class JsonRpcProvider {
     constructor(rpcUrl) {
         this._rpcUrl = rpcUrl || 'https://free-eth-node.com/api/eth';
     }
@@ -22,11 +22,14 @@ export class EssentialEth {
             else {
                 rpcTimeFrame = timeFrame;
             }
-            const nodeResponse = yield post(this._rpcUrl, buildRPCPostBody('eth_getBlockByNumber', [
+            const nodeResponse = (yield post(this._rpcUrl, buildRPCPostBody('eth_getBlockByNumber', [
                 rpcTimeFrame,
                 returnTransactionObjects,
-            ])).then((data) => data.result);
+            ])));
             return cleanBlock(nodeResponse, returnTransactionObjects);
         });
     }
 }
+export function jsonRpcProvider(rpcUrl) {
+    return new JsonRpcProvider(rpcUrl);
+}

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

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

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

@@ -0,0 +1,22 @@
+export declare type ContractTypes = 'bool' | 'bytes1' | 'bytes2' | 'bytes3' | 'bytes4' | 'bytes5' | 'bytes6' | 'bytes7' | 'bytes8' | 'bytes9' | 'bytes10' | 'bytes11' | 'bytes12' | 'bytes13' | 'bytes14' | 'bytes15' | 'bytes16' | 'bytes17' | 'bytes18' | 'bytes19' | 'bytes20' | 'bytes21' | 'bytes22' | 'bytes23' | 'bytes24' | 'bytes25' | 'bytes26' | 'bytes27' | 'bytes28' | 'bytes29' | 'bytes30' | 'bytes31' | 'bytes32' | 'bytes32[]' | 'address' | 'address payable' | 'address[4]' | 'address[100]' | 'uint256' | 'uint256[100]' | 'uint8' | 'uint32' | string;
+export declare type ContractInterface = JSONABI;
+export declare type ContractFunction<T = any> = (...args: Array<any>) => Promise<T>;
+export declare type JSONABIArgument = {
+    anonymous?: false;
+    inputs: {
+        internalType?: ContractTypes | string;
+        name: string;
+        type: ContractTypes;
+        indexed?: boolean;
+    }[];
+    name?: string;
+    outputs?: {
+        internalType?: ContractTypes | string;
+        name: string;
+        type: ContractTypes;
+    }[];
+    stateMutability?: 'view' | 'nonpayable' | string;
+    type: 'function' | 'event' | 'constructor' | 'error';
+    gas?: number;
+};
+export declare type JSONABI = JSONABIArgument[];

package/lib/esm/types/Contract.types.js

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

package/lib/esm/utils/ether-to-wei.d.ts

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

package/lib/esm/utils/ether-to-wei.js

@@ -0,0 +1,7 @@
+import { tinyBig } from '../shared/tiny-big/tiny-big';
+import { validateType } from '../shared/validate-type';
+export function etherToWei(etherQuantity) {
+    validateType(etherQuantity, ['string', 'number', 'object']);
+    const result = tinyBig(etherQuantity).times('1000000000000000000');
+    return tinyBig(result);
+}

package/lib/esm/{is-address.js → utils/is-address.js}

@@ -1,5 +1,5 @@
-import { toChecksumAddress } from '.';
-import { validateType } from './shared/validate-type';
+import { toChecksumAddress } from '..';
+import { validateType } from '../shared/validate-type';
 export function isAddress(address) {
     validateType(address, ['string']);
     try {

package/lib/esm/utils/tests/ether-to-wei.test.d.ts

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

package/lib/esm/utils/tests/ether-to-wei.test.js

@@ -0,0 +1,36 @@
+import Big from 'big.js';
+import * as ethers from 'ethers';
+import web3 from 'web3';
+import { etherToWei, tinyBig } from '../../index';
+import { scientificStrToDecimalStr } from '../../shared/tiny-big/helpers';
+describe('ether-to-wei', () => {
+    it('happy path', () => {
+        expect(etherToWei('100').toString()).toStrictEqual('100000000000000000000');
+        expect(etherToWei(100).toString()).toStrictEqual('100000000000000000000');
+        expect(etherToWei('1000.0').toString()).toStrictEqual('1000000000000000000000');
+        expect(etherToWei(1000).toString()).toStrictEqual('1000000000000000000000');
+        expect(etherToWei('1000.0').toNumber()).toStrictEqual(1000000000000000000000);
+        expect(etherToWei(tinyBig(1000)).toString()).toStrictEqual('1000000000000000000000');
+        expect(etherToWei(tinyBig('1000.0')).toNumber()).toStrictEqual(1000000000000000000000);
+        expect(etherToWei(Big(1000)).toString()).toStrictEqual('1000000000000000000000');
+        expect(etherToWei(Big('1000.0')).toNumber()).toStrictEqual(1000000000000000000000);
+    });
+    it('matches ethers and web3 toString', () => {
+        expect(etherToWei('-09999.0').toString()).toStrictEqual(ethers.utils.parseEther('-09999.0').toString());
+        expect(etherToWei('-09999.0').toString()).toStrictEqual(web3.utils.toWei('-09999.0', 'ether'));
+    });
+    it('matches ethers and web3 toNumber', () => {
+        expect(etherToWei('9').toNumber()).toStrictEqual(Number(ethers.utils.parseEther('9')));
+        expect(etherToWei('9').toNumber()).toStrictEqual(Number(web3.utils.toWei('9', 'ether')));
+        expect(etherToWei('-0999999.90').toNumber()).toStrictEqual(Number(ethers.utils.parseEther('-0999999.90')));
+        expect(etherToWei('-0999999.9').toNumber()).toStrictEqual(Number(scientificStrToDecimalStr(web3.utils.toWei('-0999999.9', 'ether'))));
+    });
+    it('wrong types', () => {
+        expect(() => {
+            etherToWei(false);
+        }).toThrow();
+        expect(() => {
+            etherToWei([1, 2, 3]);
+        }).toThrow();
+    });
+});

package/lib/esm/utils/tests/is-address.test.d.ts

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

package/lib/esm/utils/tests/is-address.test.js

@@ -0,0 +1,49 @@
+import { utils } from 'ethers';
+import web3 from 'web3';
+import { isAddress } from '../../index';
+describe('is-address', () => {
+    it('should validate real addresses', () => {
+        const addresses = [
+            '0x52908400098527886E0F7030069857D2E4169EE7',
+            '0x8617E340B3D01FA5F11F306F4090FD50E238070D',
+            '0xde709f2102306220921060314715629080e2fb77',
+            '0x27b1fdb04752bbc536007a920d24acb045561c26',
+            '0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed',
+            '0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359',
+            '0xdbF03B407c01E7cD3CBea99509d93f8DDDC8C6FB',
+            '0xD1220A0cf47c7B9Be7A2E6BA89F429762e7b9aDb',
+            '27b1fdb04752bbc536007a920d24acb045561c26',
+        ];
+        addresses.forEach((address) => {
+            expect(isAddress(address)).toStrictEqual(utils.isAddress(address));
+            expect(isAddress(address)).toStrictEqual(web3.utils.isAddress(address));
+        });
+    });
+    it('should return false on invalid addresses', () => {
+        const addresses = [
+            '0x5290840009852',
+            '0x8617E340b3D01FA5F11F306F4090FD50E238070D',
+            '0x8617e340b3d01FA5F11F306F4090FD50E238070D',
+            ' 0xde709f2102306220921060314715629080e2fb77',
+            'dawsbot.eth',
+            '',
+            'xyz',
+            '0x123',
+        ];
+        addresses.forEach((address) => {
+            const essentialEthIsAddress = isAddress(address);
+            const ethersIsAddress = utils.isAddress(address);
+            const web3IsAddress = web3.utils.isAddress(address);
+            expect(essentialEthIsAddress).toStrictEqual(ethersIsAddress);
+            expect(essentialEthIsAddress).toStrictEqual(web3IsAddress);
+        });
+    });
+    it('invalid type inputs', () => {
+        expect(() => {
+            isAddress(false);
+        }).toThrow('string required. Received boolean');
+        expect(() => {
+            isAddress([1, 2, 3]);
+        }).toThrow('string required. Received object');
+    });
+});

package/lib/esm/utils/tests/to-checksum-address.test.d.ts

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

package/lib/esm/utils/tests/to-checksum-address.test.js

@@ -0,0 +1,36 @@
+import { utils } from 'ethers';
+import web3 from 'web3';
+import { toChecksumAddress } from '../../index';
+describe('ether-to-wei', () => {
+    it('happy path', () => {
+        const addresses = [
+            '0x52908400098527886E0F7030069857D2E4169EE7',
+            '0x8617E340B3D01FA5F11F306F4090FD50E238070D',
+            '0xde709f2102306220921060314715629080e2fb77',
+            '0x27b1fdb04752bbc536007a920d24acb045561c26',
+            '0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed',
+            '0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359',
+            '0xdbF03B407c01E7cD3CBea99509d93f8DDDC8C6FB',
+            '0xD1220A0cf47c7B9Be7A2E6BA89F429762e7b9aDb',
+        ];
+        addresses.forEach((address) => {
+            expect(toChecksumAddress(address)).toStrictEqual(utils.getAddress(address));
+            expect(toChecksumAddress(address)).toStrictEqual(web3.utils.toChecksumAddress(address));
+        });
+    });
+    it('invalid inputs', () => {
+        const invalidChecksumAddress = '0x8617E340b3D01FA5F11F306F4090FD50E238070D';
+        expect(() => {
+            toChecksumAddress(invalidChecksumAddress);
+        }).toThrow(`Invalid Checksum address for "${invalidChecksumAddress}"`);
+        expect(() => {
+            toChecksumAddress(false);
+        }).toThrow('string required. Received boolean');
+        expect(() => {
+            toChecksumAddress([1, 2, 3]);
+        }).toThrow('string required. Received object');
+        expect(() => {
+            toChecksumAddress('0x1');
+        }).toThrow('Invalid Ethereum address "0x1"');
+    });
+});

package/lib/esm/utils/tests/wei-to-ether.test.d.ts

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

package/lib/esm/utils/tests/wei-to-ether.test.js

@@ -0,0 +1,38 @@
+import Big from 'big.js';
+import * as ethers from 'ethers';
+import web3 from 'web3';
+import { tinyBig, weiToEther } from '../../index';
+describe('wei-to-ether', () => {
+    it('happy path', () => {
+        expect(weiToEther('100000000000000000000.0').toString()).toStrictEqual('100');
+        expect(weiToEther(100000000000000000000.0).toString()).toStrictEqual('100');
+        expect(weiToEther('1000000000000000000000.0').toNumber()).toStrictEqual(1000);
+        expect(weiToEther(1000000000000000000000.0).toNumber()).toStrictEqual(1000);
+        expect(weiToEther(tinyBig('1000000000000000000000.0')).toNumber()).toStrictEqual(1000);
+        expect(weiToEther(tinyBig(1000000000000000000000.0)).toNumber()).toStrictEqual(1000);
+        expect(weiToEther(Big('1000000000000000000000.0')).toNumber()).toStrictEqual(1000);
+        expect(weiToEther(Big(1000000000000000000000.0)).toNumber()).toStrictEqual(1000);
+    });
+    describe('matches ethers and web3 toString', () => {
+        it('toString', () => {
+            expect(weiToEther('10').toString()).toStrictEqual(ethers.utils.formatEther('10'));
+            expect(weiToEther('1000000000000000000000').toString()).toStrictEqual('1000');
+            expect(weiToEther('10').toString()).toStrictEqual(web3.utils.fromWei('10', 'ether'));
+            expect(weiToEther('1000000000000000000000').toString()).toStrictEqual(web3.utils.fromWei('1000000000000000000000', 'ether'));
+        });
+        it('toNumber', () => {
+            expect(weiToEther('9').toNumber()).toStrictEqual(Number(ethers.utils.formatEther('9')));
+            expect(weiToEther('9').toNumber()).toStrictEqual(Number(web3.utils.fromWei('9', 'ether')));
+            expect(weiToEther('999999').toNumber()).toStrictEqual(Number(ethers.utils.formatEther('999999')));
+            expect(weiToEther('999999').toNumber()).toStrictEqual(Number(web3.utils.fromWei('999999', 'ether')));
+        });
+    });
+    it('wrong types', () => {
+        expect(() => {
+            weiToEther(false);
+        }).toThrow();
+        expect(() => {
+            weiToEther([1, 2, 3]);
+        }).toThrow();
+    });
+});

package/lib/esm/{to-checksum-address.js → utils/to-checksum-address.js}

@@ -1,5 +1,5 @@
 import { Keccak } from 'sha3';
-import { validateType } from './shared/validate-type';
+import { validateType } from '../shared/validate-type';
 export function toChecksumAddress(address) {
     validateType(address, ['string']);
     if (!/^(0x)?[0-9a-f]{40}$/i.test(address)) {

package/lib/esm/utils/wei-to-ether.d.ts

@@ -0,0 +1,3 @@
+import Big from 'big.js';
+import { TinyBig } from './../shared/tiny-big/tiny-big';
+export declare function weiToEther(weiQuantity: string | number | TinyBig | Big): TinyBig;

package/lib/esm/utils/wei-to-ether.js

@@ -0,0 +1,7 @@
+import { tinyBig } from '../shared/tiny-big/tiny-big';
+import { validateType } from '../shared/validate-type';
+export function weiToEther(weiQuantity) {
+    validateType(weiQuantity, ['string', 'number', 'object']);
+    const result = tinyBig(weiQuantity).div('1000000000000000000');
+    return tinyBig(result);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "essential-eth",
   "description": "Ultralight JS library for Ethereum utilities",
-  "version": "0.2.2",
+  "version": "0.3.3",
   "license": "MIT",
   "sideEffects": false,
   "main": "./lib/cjs/index.js",
@@ -33,32 +33,32 @@
     "@types/body-parser": "^1.19.1",
     "@types/eslint": "^7.28.0",
     "@types/express": "^4.17.13",
-    "@types/jest": "^27.0.1",
+    "@types/jest": "^27.0.2",
     "@types/jest-dev-server": "^5.0.0",
-    "@types/node": "^16.9.2",
-    "@types/prettier": "^2.3.2",
+    "@types/node": "^16.10.1",
+    "@types/prettier": "^2.4.0",
     "@types/supertest": "^2.0.11",
-    "@typescript-eslint/eslint-plugin": "^4.31.1",
-    "@typescript-eslint/parser": "^4.31.1",
+    "@typescript-eslint/eslint-plugin": "^4.32.0",
+    "@typescript-eslint/parser": "^4.32.0",
     "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",
+    "jest": "^27.2.2",
+    "jest-dev-server": "^6.0.0",
     "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",
+    "prettier-plugin-organize-imports": "^2.3.4",
     "supertest": "^6.1.6",
     "ts-jest": "^27.0.5",
     "ts-node": "^10.2.1",
-    "typedoc": "^0.22.3",
+    "typedoc": "^0.22.4",
     "typescript": "^4.4.3",
-    "web3": "^1.5.2"
+    "web3": "^1.5.3"
   },
   "dependencies": {
     "big.js": "^6.1.1",