essential-eth 0.4.11 → 0.5.4-alpha.0

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

@@ -61,12 +61,15 @@ declare const _default: {
     "67": string[];
     "68": string[];
     "69": string[];
+    "70": string[];
     "71": string[];
     "74": string[];
     "76": string[];
     "77": string[];
     "78": string[];
+    "79": string[];
     "80": string[];
+    "81": string[];
     "82": string[];
     "83": string[];
     "85": string[];
@@ -147,6 +150,7 @@ declare const _default: {
     "600": string[];
     "666": string[];
     "686": string[];
+    "700": string[];
     "707": string[];
     "708": string[];
     "721": string[];
@@ -208,9 +212,13 @@ declare const _default: {
     "2025": string[];
     "2100": string[];
     "2101": string[];
+    "2152": string[];
+    "2153": string[];
     "2213": string[];
     "2221": string[];
+    "2223": string[];
     "2559": string[];
+    "2569": string[];
     "3000": string[];
     "3001": string[];
     "3331": string[];
@@ -228,6 +236,8 @@ declare const _default: {
     "4918": string[];
     "5197": string[];
     "5315": string[];
+    "5551": string[];
+    "5553": string[];
     "5700": string[];
     "5777": string[];
     "5851": string[];
@@ -290,8 +300,10 @@ declare const _default: {
     "60002": string[];
     "60103": string[];
     "62320": string[];
+    "62621": string[];
     "63000": string[];
     "63001": string[];
+    "69420": string[];
     "70000": string[];
     "70001": string[];
     "70002": string[];
@@ -334,6 +346,7 @@ declare const _default: {
     "333999": string[];
     "421611": string[];
     "444900": string[];
+    "512512": string[];
     "666666": string[];
     "888888": string[];
     "955305": string[];
@@ -345,6 +358,7 @@ declare const _default: {
     "11155111": string[];
     "13371337": string[];
     "18289463": string[];
+    "20180430": string[];
     "20181205": string[];
     "28945486": string[];
     "35855456": string[];

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

@@ -193,6 +193,9 @@ exports.default = {
     "69": [
         "okov"
     ],
+    "70": [
+        "hsc"
+    ],
     "71": [
         "cfxtest"
     ],
@@ -208,9 +211,15 @@ exports.default = {
     "78": [
         "primuschain"
     ],
+    "79": [
+        "zenith"
+    ],
     "80": [
         "GeneChain"
     ],
+    "81": [
+        "VIL"
+    ],
     "82": [
         "Meter"
     ],
@@ -451,6 +460,9 @@ exports.default = {
     "686": [
         "kar"
     ],
+    "700": [
+        "SNS"
+    ],
     "707": [
         "bcs"
     ],
@@ -634,15 +646,27 @@ exports.default = {
     "2101": [
         "esp"
     ],
+    "2152": [
+        "fra"
+    ],
+    "2153": [
+        "findora-testnet"
+    ],
     "2213": [
         "evanesco"
     ],
     "2221": [
         "kava"
     ],
+    "2223": [
+        "VChain"
+    ],
     "2559": [
         "ktoc"
     ],
+    "2569": [
+        "tpc"
+    ],
     "3000": [
         "cennz-r"
     ],
@@ -694,6 +718,12 @@ exports.default = {
     "5315": [
         "UZMI"
     ],
+    "5551": [
+        "Nahmii"
+    ],
+    "5553": [
+        "Nahmii testnet"
+    ],
     "5700": [
         "tsys"
     ],
@@ -880,12 +910,18 @@ exports.default = {
     "62320": [
         "BKLV"
     ],
+    "62621": [
+        "mtv"
+    ],
     "63000": [
         "ecs"
     ],
     "63001": [
         "ecs-testnet"
     ],
+    "69420": [
+        "cndr"
+    ],
     "70000": [
         "TKM0"
     ],
@@ -1012,6 +1048,9 @@ exports.default = {
     "444900": [
         "wlkt"
     ],
+    "512512": [
+        "cmp"
+    ],
     "666666": [
         "vpioneer"
     ],
@@ -1045,6 +1084,9 @@ exports.default = {
     "18289463": [
         "ilt"
     ],
+    "20180430": [
+        "spectrum"
+    ],
     "20181205": [
         "qki"
     ],

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

@@ -1,7 +1,7 @@
 import Big from 'big.js';
 /**
- * A wrapper around big.js which expands scientific notation and creates a "toHexString" function.
- * This is the return type of every operation on ether, wei, etc.
+ * A wrapper around [big.js](https://github.com/MikeMcl/big.js) which expands scientific notation and creates a "toHexString" function.
+ * * This is the return type of every operation on ether, wei, etc.
  */
 export declare class TinyBig extends Big {
     constructor(value: string | number | TinyBig | Big);
@@ -12,6 +12,13 @@ export declare class TinyBig extends Big {
     toHexString(): string;
     toNumber(): number;
     toString(): string;
+    /**
+     * @param {String} str
+     * @param {String} padChar
+     * @param {Number} length
+     */
+    private padAndChop;
+    toTwos(bitCount: number): Big;
 }
 /**
  * Helper factory function so that you don't have to type "new" when instantiating a new TinyBig

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

@@ -7,12 +7,20 @@ exports.tinyBig = exports.TinyBig = void 0;
 const big_js_1 = __importDefault(require("big.js"));
 const helpers_1 = require("./helpers");
 /**
- * A wrapper around big.js which expands scientific notation and creates a "toHexString" function.
- * This is the return type of every operation on ether, wei, etc.
+ * A wrapper around [big.js](https://github.com/MikeMcl/big.js) which expands scientific notation and creates a "toHexString" function.
+ * * This is the return type of every operation on ether, wei, etc.
  */
 class TinyBig extends big_js_1.default {
     constructor(value) {
         super(value);
+        /**
+         * @param {String} str
+         * @param {String} padChar
+         * @param {Number} length
+         */
+        this.padAndChop = (str, padChar, length) => {
+            return (Array(length).fill(padChar).join('') + str).slice(length * -1);
+        };
     }
     /**
      * Used anytime you're passing in "value" to ethers or web3
@@ -30,6 +38,22 @@ class TinyBig extends big_js_1.default {
         }
         return (0, helpers_1.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);
+    }
 }
 exports.TinyBig = TinyBig;
 /**

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

@@ -1,27 +1,15 @@
-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>;
+}>;
+/** Exact response from backend */
 export interface RPCBlock {
     baseFeePerGas: string;
     difficulty: string;
@@ -46,3 +34,4 @@ export interface RPCBlock {
     uncles: unknown[];
 }
 export declare type BlockTag = 'latest' | 'earliest' | 'pending' | number | string;
+export {};

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

@@ -1,23 +1,31 @@
-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'>;
+/** What JSONRPC responds with in getBlock transaction array */
+export interface RPCBlockTransaction {
     blockHash: string;
     blockNumber: string;
+    chainId: string;
     from: string;
     gas: string;
     gasPrice: string;
@@ -32,3 +40,4 @@ export interface RPCTransaction {
     v: string;
     value: string;
 }
+export {};

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

@@ -0,0 +1,171 @@
+export declare type Bytes = ArrayLike<number>;
+/**
+ * @example
+ * [1,2,3]
+ *
+ * @example
+ * 0x123
+ *
+ * @example
+ * '0x123'
+ */
+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;
+}
+/**
+ * Returns true if and only if value is a valid [Bytes](#bytes) or DataHexString
+ * * Same as [`ethers.utils.isBytesLike`](https://docs.ethers.io/v5/api/utils/bytes/#utils-isBytesLike)
+ *
+ * @example
+ * ```js
+ * isBytesLike([1,2,3]);
+ * // true
+ * ```
+ *
+ * @example
+ * ```js
+ * isBytesLike(false);
+ * // false
+ * ```
+ *
+ * @example
+ * ```js
+ * isBytesLike(new Uint8Array(1));
+ * // true
+ * ```
+ */
+export declare function isBytesLike(value: any): value is BytesLike;
+/**
+ * Returns true if and only if value is a valid [Bytes](#bytes)
+ * * Same as [`ethers.utils.isBytes`](https://docs.ethers.io/v5/api/utils/bytes/#utils-isBytes)
+ *
+ * @example
+ * ```js
+ * isBytes([1,2,3]);
+ * // true
+ * ```
+ *
+ * @example
+ * ```js
+ * isBytes(false);
+ * // false
+ * ```
+ *
+ * @example
+ * ```js
+ * isBytes(new Uint8Array(1));
+ * // true
+ * ```
+ */
+export declare function isBytes(value: any): value is Bytes;
+/**
+ * Converts DataHexStringOrArrayish to a Uint8Array
+ * * Same as [`ethers.utils.arrayify`](https://docs.ethers.io/v5/api/utils/bytes/#utils-arrayify)
+ *
+ * @example
+ * ```js
+ * arrayify(1);
+ * // Uint8Array(1) [ 1 ]
+ * ```
+ *
+ * @example
+ * ```js
+ * arrayify(0x1234);
+ * // Uint8Array(2) [ 18, 52 ]
+ * ```
+ *
+ * @example
+ * ```js
+ * arrayify('0x1', { hexPad: 'right' });
+ * // Uint8Array(1) [ 16 ]
+ * ```
+ */
+export declare function arrayify(value: BytesLike | Hexable | number, options?: DataOptions): Uint8Array;
+/**
+ * Concatenates all the BytesLike in arrayOfBytesLike into a single Uint8Array.
+ * * Same as [`ethers.utils.concat`](https://docs.ethers.io/v5/api/utils/bytes/#utils-concat)
+ *
+ * @example
+ * ```js
+ * concat([0, 1]);
+ * // Uint8Array(2) [ 0, 1 ]
+ * ```
+ */
+export declare function concat(arrayOfBytesLike: ReadonlyArray<BytesLike>): Uint8Array;
+export declare function stripZeros(value: BytesLike): Uint8Array;
+export declare function zeroPad(value: BytesLike, length: number): Uint8Array;
+/**
+ * Returns true if and only if object is a valid hex string.
+ * If length is specified and object is not a valid DataHexString of length bytes, an InvalidArgument error is thrown.
+ * * Same as [`ethers.utils.isHexString`](https://docs.ethers.io/v5/api/utils/bytes/#utils-isHexString)
+ */
+export declare function isHexString(value: any, length?: number): boolean;
+/**
+ * @example
+ * ```js
+ * hexlify(4);
+ * // '0x04'
+ *
+ * hexlify(14);
+ * // '0x0e'
+ * ```
+ */
+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;
+/**
+ * Returns a hex string padded to a specified length of bytes.
+ *
+ * Similar to ["hexZeroPad" in ethers.js](https://docs.ethers.io/v5/api/utils/bytes/#utils-hexZeroPad)
+ *
+ * Differs from ["padLeft" in web3.js](https://web3js.readthedocs.io/en/v1.7.1/web3-utils.html#padleft) because web3 counts by characters, not bytes.
+ *
+ * @param hexValue - A hex-string, hex-number, or decimal number (auto-converts to base-16) to be padded
+ * @param length - The final length in bytes
+ *
+ * @throws - If the value is not a hex string or number
+ * @throws - If the value is longer than the length
+ *
+ * @example
+ * ```javascript
+ * hexZeroPad('0x60', 2);
+ * // '0x0060'
+ * ```
+ *
+ * @example
+ * ```javascript
+ * hexZeroPad(0x60, 3);
+ * // '0x000060'
+ * ```
+ *
+ * @example
+ * ```javascript
+ * hexZeroPad('12345', 1);
+ * // Throws
+ * ```
+ */
+export declare function hexZeroPad(value: BytesLike, length: number): string;