essential-eth 0.4.10 → 0.5.1

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

@@ -1,4 +1,4 @@
-import { toChecksumAddress } from '../..';
+import { tinyBig, toChecksumAddress } from '../..';
 import { hexToDecimal } from './hex-to-decimal';
 export function cleanTransaction(transaction) {
     const cleanedTransaction = Object.assign({}, transaction);
@@ -7,22 +7,26 @@ export function cleanTransaction(transaction) {
             return;
         switch (key) {
             case 'blockNumber':
-            case 'gas':
+            case 'chainId':
             case 'nonce':
             case 'transactionIndex':
             case 'type':
+            case 'v':
                 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;
+            case 'value':
+            case 'gas':
+            case 'gasPrice':
+            case 'maxFeePerGas':
+            case 'maxPriorityFeePerGas':
+                cleanedTransaction[key] = tinyBig(hexToDecimal(transaction[key]));
+                break;
         }
     });
     return cleanedTransaction;

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

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

package/lib/esm/index.d.ts

@@ -1,14 +1,16 @@
 import { Contract } from './classes/Contract';
 import { JsonRpcProvider, jsonRpcProvider } from './providers/JsonRpcProvider';
 import { tinyBig, TinyBig } from './shared/tiny-big/tiny-big';
-import { Block } from './types/Block.types';
+import { BlockResponse } from './types/Block.types';
 import { ContractTypes, JSONABI, JSONABIArgument } from './types/Contract.types';
 import { Network } from './types/Network.types';
-import { Transaction } from './types/Transaction.types';
+import { TransactionResponse } from './types/Transaction.types';
 import { etherToGwei } from './utils/ether-to-gwei';
 import { etherToWei } from './utils/ether-to-wei';
 import { gweiToEther } from './utils/gwei-to-ether';
 import { isAddress } from './utils/is-address';
 import { toChecksumAddress } from './utils/to-checksum-address';
 import { weiToEther } from './utils/wei-to-ether';
-export { etherToWei, etherToGwei, isAddress, jsonRpcProvider, JsonRpcProvider, tinyBig, toChecksumAddress, weiToEther, gweiToEther, Contract, TinyBig, Block, ContractTypes, JSONABI, JSONABIArgument, Network, Transaction, };
+export * from './utils/bytes';
+export * from './utils/solidity-keccak256';
+export { etherToWei, etherToGwei, isAddress, jsonRpcProvider, JsonRpcProvider, tinyBig, toChecksumAddress, weiToEther, gweiToEther, Contract, TinyBig, BlockResponse, ContractTypes, JSONABI, JSONABIArgument, Network, TransactionResponse, };

package/lib/esm/index.js

@@ -7,4 +7,6 @@ import { gweiToEther } from './utils/gwei-to-ether';
 import { isAddress } from './utils/is-address';
 import { toChecksumAddress } from './utils/to-checksum-address';
 import { weiToEther } from './utils/wei-to-ether';
+export * from './utils/bytes';
+export * from './utils/solidity-keccak256';
 export { etherToWei, etherToGwei, isAddress, jsonRpcProvider, JsonRpcProvider, tinyBig, toChecksumAddress, weiToEther, gweiToEther, Contract, TinyBig, };

package/lib/esm/logger/logger.d.ts

@@ -0,0 +1,11 @@
+declare class Logger {
+    private packageVersion;
+    constructor();
+    throwError(message: string, args: {
+        [key: string]: any;
+    }): never;
+    throwArgumentError(message: string, arg: string, value: any): never;
+    checkSafeUint53(value: number, message?: string): void;
+}
+export declare const logger: Logger;
+export {};

package/lib/esm/logger/logger.js

@@ -0,0 +1,33 @@
+import { version } from './package-version';
+class Logger {
+    constructor() {
+        this.packageVersion = version;
+    }
+    throwError(message, args) {
+        const argsLength = Object.keys(args).length;
+        throw new Error(`${message} (${Object.entries(args).map(([key, value], index) => `${key}=${value}${index < argsLength - 1 && ', '}`)}, version=essential-eth@${this.packageVersion})`);
+    }
+    throwArgumentError(message, arg, value) {
+        throw new Error(`${message} (argument="${arg}" value=${value}, version=essential-eth@${this.packageVersion})`);
+    }
+    checkSafeUint53(value, message = 'value not safe') {
+        if (typeof value !== 'number') {
+            return;
+        }
+        if (value < 0 || value >= 0x1fffffffffffff) {
+            this.throwError(message, {
+                operation: 'checkSafeInteger',
+                fault: 'out-of-safe-range',
+                value: value,
+            });
+        }
+        if (value % 1) {
+            this.throwError(message, {
+                operation: 'checkSafeInteger',
+                fault: 'non-integer',
+                value: value,
+            });
+        }
+    }
+}
+export const logger = new Logger();

package/lib/esm/logger/package-version.d.ts

@@ -0,0 +1 @@
+export declare const version = "0.5.1";

package/lib/esm/logger/package-version.js

@@ -0,0 +1 @@
+export const version = '0.5.1';

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

@@ -1,11 +1,15 @@
 import { TinyBig } from '../shared/tiny-big/tiny-big';
-import { Block } from '../types/Block.types';
+import { BlockResponse, BlockTag } from '../types/Block.types';
 import { Network } from '../types/Network.types';
+import { TransactionResponse } from '../types/Transaction.types';
 export declare class JsonRpcProvider {
     readonly _rpcUrl: string;
+    private post;
     constructor(rpcUrl?: string);
-    getBlock(timeFrame: 'latest' | 'earliest' | 'pending' | number, returnTransactionObjects?: boolean): Promise<Block>;
+    getBlock(timeFrame?: BlockTag, returnTransactionObjects?: boolean): Promise<BlockResponse>;
     getNetwork(): Promise<Network>;
     getGasPrice(): Promise<TinyBig>;
+    getBalance(address: string, blockTag?: BlockTag): Promise<TinyBig>;
+    getTransaction(hash: string): Promise<TransactionResponse>;
 }
 export declare function jsonRpcProvider(rpcUrl?: string): JsonRpcProvider;

package/lib/esm/providers/JsonRpcProvider.js

@@ -8,15 +8,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { cleanBlock } from '../classes/utils/clean-block';
+import { cleanTransaction } from '../classes/utils/clean-transaction';
 import { buildRPCPostBody, post } from '../classes/utils/fetchers';
 import { hexToDecimal } from '../classes/utils/hex-to-decimal';
 import { tinyBig } from '../shared/tiny-big/tiny-big';
 import chainsInfo from './utils/chains-info';
 export class JsonRpcProvider {
     constructor(rpcUrl) {
+        this.post = (body) => post(this._rpcUrl, body);
         this._rpcUrl = rpcUrl || 'https://free-eth-node.com/api/eth';
     }
-    getBlock(timeFrame, returnTransactionObjects = false) {
+    getBlock(timeFrame = 'latest', returnTransactionObjects = false) {
         return __awaiter(this, void 0, void 0, function* () {
             let rpcTimeFrame;
             if (typeof timeFrame === 'number') {
@@ -25,23 +27,17 @@ export class JsonRpcProvider {
             else {
                 rpcTimeFrame = timeFrame;
             }
-            const req = () => __awaiter(this, void 0, void 0, function* () {
-                return yield post(this._rpcUrl, buildRPCPostBody('eth_getBlockByNumber', [
-                    rpcTimeFrame,
-                    returnTransactionObjects,
-                ]));
-            });
-            const nodeResponse = (yield req());
-            return cleanBlock(nodeResponse, returnTransactionObjects);
+            const rpcBlock = (yield this.post(buildRPCPostBody('eth_getBlockByNumber', [
+                rpcTimeFrame,
+                returnTransactionObjects,
+            ])));
+            return cleanBlock(rpcBlock, returnTransactionObjects);
         });
     }
     getNetwork() {
         return __awaiter(this, void 0, void 0, function* () {
-            const req = () => __awaiter(this, void 0, void 0, function* () {
-                return yield post(this._rpcUrl, buildRPCPostBody('eth_chainId', []));
-            });
-            const nodeResponse = (yield req());
-            const chainId = hexToDecimal(nodeResponse);
+            const hexChainId = (yield this.post(buildRPCPostBody('eth_chainId', [])));
+            const chainId = hexToDecimal(hexChainId);
             const info = chainsInfo[chainId];
             return {
                 chainId: Number(chainId),
@@ -52,11 +48,26 @@ export class JsonRpcProvider {
     }
     getGasPrice() {
         return __awaiter(this, void 0, void 0, function* () {
-            const req = () => __awaiter(this, void 0, void 0, function* () {
-                return yield post(this._rpcUrl, buildRPCPostBody('eth_gasPrice', []));
-            });
-            const nodeResponse = (yield req());
-            return tinyBig(hexToDecimal(nodeResponse));
+            const hexGasPrice = (yield this.post(buildRPCPostBody('eth_gasPrice', [])));
+            return tinyBig(hexToDecimal(hexGasPrice));
+        });
+    }
+    getBalance(address, blockTag = 'latest') {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hexBalance = (yield this.post(buildRPCPostBody('eth_getBalance', [address, blockTag])));
+            return tinyBig(hexToDecimal(hexBalance));
+        });
+    }
+    getTransaction(hash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [rpcTransaction, blockNumber] = yield Promise.all([
+                this.post(buildRPCPostBody('eth_getTransactionByHash', [hash])),
+                this.getBlock('latest'),
+            ]);
+            const cleanedTransaction = cleanTransaction(rpcTransaction);
+            cleanedTransaction.confirmations =
+                blockNumber.number - cleanedTransaction.blockNumber + 1;
+            return cleanedTransaction;
         });
     }
 }

package/lib/esm/providers/test/rpc-urls.d.ts

@@ -5,4 +5,6 @@ export declare const rpcUrls: {
     mainnet: string;
     gno: string;
     bnb: string;
+    arb1: string;
+    gor: string;
 };

package/lib/esm/providers/test/rpc-urls.js

@@ -5,4 +5,6 @@ export const rpcUrls = {
     mainnet: `${process.env.RPC_ORIGIN}/api/eth`,
     gno: `${process.env.RPC_ORIGIN}/api/gno`,
     bnb: `${process.env.RPC_ORIGIN}/api/bnb`,
+    arb1: `${process.env.RPC_ORIGIN}/api/arb1`,
+    gor: `${process.env.RPC_ORIGIN}/api/gor`,
 };

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

@@ -66,7 +66,9 @@ declare const _default: {
     "76": string[];
     "77": string[];
     "78": string[];
+    "79": string[];
     "80": string[];
+    "81": string[];
     "82": string[];
     "83": string[];
     "85": string[];
@@ -147,6 +149,7 @@ declare const _default: {
     "600": string[];
     "666": string[];
     "686": string[];
+    "700": string[];
     "707": string[];
     "708": string[];
     "721": string[];
@@ -208,8 +211,11 @@ declare const _default: {
     "2025": string[];
     "2100": string[];
     "2101": string[];
+    "2152": string[];
+    "2153": string[];
     "2213": string[];
     "2221": string[];
+    "2223": string[];
     "2559": string[];
     "3000": string[];
     "3001": string[];
@@ -228,6 +234,8 @@ declare const _default: {
     "4918": string[];
     "5197": string[];
     "5315": string[];
+    "5551": string[];
+    "5553": string[];
     "5700": string[];
     "5777": string[];
     "5851": string[];
@@ -262,6 +270,7 @@ declare const _default: {
     "16000": string[];
     "16001": string[];
     "19845": string[];
+    "21337": string[];
     "21816": string[];
     "24484": string[];
     "24734": string[];
@@ -291,6 +300,7 @@ declare const _default: {
     "62320": string[];
     "63000": string[];
     "63001": string[];
+    "69420": string[];
     "70000": string[];
     "70001": string[];
     "70002": string[];
@@ -344,6 +354,7 @@ declare const _default: {
     "11155111": string[];
     "13371337": string[];
     "18289463": string[];
+    "20180430": string[];
     "20181205": string[];
     "28945486": string[];
     "35855456": string[];

package/lib/esm/providers/utils/chains-info.js

@@ -204,9 +204,15 @@ export default {
     "78": [
         "primuschain"
     ],
+    "79": [
+        "zenith"
+    ],
     "80": [
         "GeneChain"
     ],
+    "81": [
+        "VIL"
+    ],
     "82": [
         "Meter"
     ],
@@ -447,6 +453,9 @@ export default {
     "686": [
         "kar"
     ],
+    "700": [
+        "SNS"
+    ],
     "707": [
         "bcs"
     ],
@@ -583,7 +592,7 @@ export default {
         "mrock"
     ],
     "1337": [
-        "cennz-a"
+        "cennz-old"
     ],
     "1618": [
         "cate"
@@ -630,12 +639,21 @@ export default {
     "2101": [
         "esp"
     ],
+    "2152": [
+        "fra"
+    ],
+    "2153": [
+        "findora-testnet"
+    ],
     "2213": [
         "evanesco"
     ],
     "2221": [
         "kava"
     ],
+    "2223": [
+        "VChain"
+    ],
     "2559": [
         "ktoc"
     ],
@@ -690,6 +708,12 @@ export default {
     "5315": [
         "UZMI"
     ],
+    "5551": [
+        "Nahmii"
+    ],
+    "5553": [
+        "Nahmii testnet"
+    ],
     "5700": [
         "tsys"
     ],
@@ -792,6 +816,9 @@ export default {
     "19845": [
         "btcix"
     ],
+    "21337": [
+        "cennz-a"
+    ],
     "21816": [
         "oml"
     ],
@@ -879,6 +906,9 @@ export default {
     "63001": [
         "ecs-testnet"
     ],
+    "69420": [
+        "cndr"
+    ],
     "70000": [
         "TKM0"
     ],
@@ -1038,6 +1068,9 @@ export default {
     "18289463": [
         "ilt"
     ],
+    "20180430": [
+        "spectrum"
+    ],
     "20181205": [
         "qki"
     ],

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

@@ -4,5 +4,7 @@ export declare class TinyBig extends Big {
     toHexString(): string;
     toNumber(): number;
     toString(): string;
+    private padAndChop;
+    toTwos(bitCount: number): Big;
 }
 export declare function tinyBig(value: string | number | TinyBig | Big): TinyBig;

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

@@ -3,6 +3,9 @@ import { scientificStrToDecimalStr } from './helpers';
 export class TinyBig extends Big {
     constructor(value) {
         super(value);
+        this.padAndChop = (str, padChar, length) => {
+            return (Array(length).fill(padChar).join('') + str).slice(length * -1);
+        };
     }
     toHexString() {
         return `0x${BigInt(this.toString()).toString(16)}`;
@@ -16,6 +19,22 @@ export class TinyBig extends Big {
         }
         return scientificStrToDecimalStr(super.toString());
     }
+    toTwos(bitCount) {
+        let binaryStr;
+        if (this.gte(0)) {
+            const twosComp = this.toNumber().toString(2);
+            binaryStr = this.padAndChop(twosComp, '0', bitCount || twosComp.length);
+        }
+        else {
+            binaryStr = this.plus(Math.pow(2, bitCount)).toNumber().toString(2);
+            if (Number(binaryStr) < 0) {
+                throw new Error('Cannot calculate twos complement');
+            }
+        }
+        const binary = `0b${binaryStr}`;
+        const decimal = Number(binary);
+        return tinyBig(decimal);
+    }
 }
 export function tinyBig(value) {
     return new TinyBig(value);

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

@@ -1,27 +1,14 @@
-import { RPCTransaction, Transaction } from './Transaction.types';
-export interface Block {
-    baseFeePerGas: string;
-    difficulty: number;
-    extraData: string;
+import { BlockTransactionResponse, RPCTransaction } from './Transaction.types';
+declare type Modify<T, R> = Omit<T, keyof R> & R;
+export declare type BlockResponse = Modify<RPCBlock, {
     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[];
-}
+    baseFeePerGas: number;
+    transactions: Array<string | BlockTransactionResponse>;
+}>;
 export interface RPCBlock {
     baseFeePerGas: string;
     difficulty: string;
@@ -45,3 +32,5 @@ export interface RPCBlock {
     transactionsRoot: string;
     uncles: unknown[];
 }
+export declare type BlockTag = 'latest' | 'earliest' | 'pending' | number | string;
+export {};

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

@@ -1,23 +1,30 @@
-export interface Transaction {
-    blockHash: string;
+import { TinyBig } from '../shared/tiny-big/tiny-big';
+declare type Modify<T, R> = Omit<T, keyof R> & R;
+export interface RPCTransaction extends RPCBlockTransaction {
+    maxFeePerGas: string;
+    maxPriorityFeePerGas: string;
+}
+export declare type TransactionResponse = Modify<RPCTransaction, {
     blockNumber: number;
-    from: string;
-    gas: number;
-    gasPrice: string;
-    hash: string;
-    input: string;
+    chainId: number;
     nonce: number;
-    r: string;
-    s: string;
-    to: string;
     transactionIndex: number;
     type: number;
-    v: string;
-    value: string;
-}
-export interface RPCTransaction {
+    v: number;
+    value: TinyBig;
+    gasPrice: TinyBig;
+    gas: TinyBig;
+    gasLimit: TinyBig;
+} & {
+    maxFeePerGas: TinyBig;
+    maxPriorityFeePerGas: TinyBig;
+    confirmations: number;
+}>;
+export declare type BlockTransactionResponse = Omit<TransactionResponse, 'maxFeePerGas' | 'maxPriorityFeePerGas'>;
+export interface RPCBlockTransaction {
     blockHash: string;
     blockNumber: string;
+    chainId: string;
     from: string;
     gas: string;
     gasPrice: string;
@@ -32,3 +39,4 @@ export interface RPCTransaction {
     v: string;
     value: string;
 }
+export {};

package/lib/esm/utils/bytes.d.ts

@@ -0,0 +1,39 @@
+export declare type Bytes = ArrayLike<number>;
+export declare type BytesLike = Bytes | string | number;
+export interface DataOptions {
+    allowMissingPrefix?: boolean;
+    hexPad?: 'left' | 'right' | null;
+}
+export interface Hexable {
+    toHexString(): string;
+}
+export declare type SignatureLike = {
+    r: string;
+    s?: string;
+    _vs?: string;
+    recoveryParam?: number;
+    v?: number;
+} | BytesLike;
+export interface Signature {
+    r: string;
+    s: string;
+    _vs: string;
+    recoveryParam: number;
+    v: number;
+    yParityAndS: string;
+    compact: string;
+}
+export declare function isBytesLike(value: any): value is BytesLike;
+export declare function isBytes(value: any): value is Bytes;
+export declare function arrayify(value: BytesLike | Hexable | number, options?: DataOptions): Uint8Array;
+export declare function concat(items: ReadonlyArray<BytesLike>): Uint8Array;
+export declare function stripZeros(value: BytesLike): Uint8Array;
+export declare function zeroPad(value: BytesLike, length: number): Uint8Array;
+export declare function isHexString(value: any, length?: number): boolean;
+export declare function hexlify(value: BytesLike | Hexable | number | bigint, options?: DataOptions): string;
+export declare function hexDataLength(data: BytesLike): number | null;
+export declare function hexDataSlice(data: BytesLike, offset: number, endOffset?: number): string;
+export declare function hexConcat(items: ReadonlyArray<BytesLike>): string;
+export declare function hexValue(value: BytesLike | Hexable | number | bigint): string;
+export declare function hexStripZeros(value: BytesLike): string;
+export declare function hexZeroPad(value: BytesLike, length: number): string;