essential-eth 0.5.0 → 0.5.1

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

@@ -6,7 +6,7 @@ export declare class JsonRpcProvider {
     readonly _rpcUrl: string;
     private post;
     constructor(rpcUrl?: string);
-    getBlock(timeFrame: BlockTag, returnTransactionObjects?: boolean): Promise<BlockResponse>;
+    getBlock(timeFrame?: BlockTag, returnTransactionObjects?: boolean): Promise<BlockResponse>;
     getNetwork(): Promise<Network>;
     getGasPrice(): Promise<TinyBig>;
     getBalance(address: string, blockTag?: BlockTag): Promise<TinyBig>;

package/lib/esm/providers/JsonRpcProvider.js

@@ -18,7 +18,7 @@ export class JsonRpcProvider {
         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') {

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

@@ -215,6 +215,7 @@ declare const _default: {
     "2153": string[];
     "2213": string[];
     "2221": string[];
+    "2223": string[];
     "2559": string[];
     "3000": string[];
     "3001": string[];
@@ -233,6 +234,8 @@ declare const _default: {
     "4918": string[];
     "5197": string[];
     "5315": string[];
+    "5551": string[];
+    "5553": string[];
     "5700": string[];
     "5777": string[];
     "5851": string[];
@@ -351,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

@@ -651,6 +651,9 @@ export default {
     "2221": [
         "kava"
     ],
+    "2223": [
+        "VChain"
+    ],
     "2559": [
         "ktoc"
     ],
@@ -705,6 +708,12 @@ export default {
     "5315": [
         "UZMI"
     ],
+    "5551": [
+        "Nahmii"
+    ],
+    "5553": [
+        "Nahmii testnet"
+    ],
     "5700": [
         "tsys"
     ],
@@ -1059,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

@@ -2,13 +2,10 @@ import Big from 'big.js';
 import { scientificStrToDecimalStr } from './helpers';
 export class TinyBig extends Big {
     constructor(value) {
-        try {
-            super(value);
-        }
-        catch (e) {
-            console.error(`TinyBig cannot parse value (value=${value})`);
-            throw e;
-        }
+        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)}`;
@@ -22,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/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;

package/lib/esm/utils/bytes.js

@@ -0,0 +1,245 @@
+import { logger } from '../logger/logger';
+function isHexable(value) {
+    return !!value.toHexString;
+}
+export function isBytesLike(value) {
+    return (isHexString(value) && !(value.length % 2)) || isBytes(value);
+}
+function isInteger(value) {
+    return typeof value === 'number' && value == value && value % 1 === 0;
+}
+export function isBytes(value) {
+    if (value == null) {
+        return false;
+    }
+    if (value.constructor === Uint8Array) {
+        return true;
+    }
+    if (typeof value === 'string') {
+        return false;
+    }
+    if (!isInteger(value.length) || value.length < 0) {
+        return false;
+    }
+    for (let i = 0; i < value.length; i++) {
+        const v = value[i];
+        if (!isInteger(v) || v < 0 || v >= 256) {
+            return false;
+        }
+    }
+    return true;
+}
+export function arrayify(value, options) {
+    if (!options) {
+        options = {};
+    }
+    if (typeof value === 'number') {
+        logger.checkSafeUint53(value, 'invalid arrayify value');
+        const result = [];
+        while (value) {
+            result.unshift(value & 0xff);
+            value = parseInt(String(value / 256));
+        }
+        if (result.length === 0) {
+            result.push(0);
+        }
+        return new Uint8Array(result);
+    }
+    if (options.allowMissingPrefix &&
+        typeof value === 'string' &&
+        value.substring(0, 2) !== '0x') {
+        value = '0x' + value;
+    }
+    if (isHexable(value)) {
+        value = value.toHexString();
+    }
+    if (isHexString(value)) {
+        let hex = value.substring(2);
+        if (hex.length % 2) {
+            if (options.hexPad === 'left') {
+                hex = '0' + hex;
+            }
+            else if (options.hexPad === 'right') {
+                hex += '0';
+            }
+            else {
+                logger.throwArgumentError('hex data is odd-length', 'value', value);
+            }
+        }
+        const result = [];
+        for (let i = 0; i < hex.length; i += 2) {
+            result.push(parseInt(hex.substring(i, i + 2), 16));
+        }
+        return new Uint8Array(result);
+    }
+    if (isBytes(value)) {
+        return new Uint8Array(value);
+    }
+    return logger.throwArgumentError('invalid arrayify value', 'value', value);
+}
+export function concat(items) {
+    const objects = items.map((item) => arrayify(item));
+    const length = objects.reduce((accum, item) => accum + item.length, 0);
+    const result = new Uint8Array(length);
+    objects.reduce((offset, object) => {
+        result.set(object, offset);
+        return offset + object.length;
+    }, 0);
+    return result;
+}
+export function stripZeros(value) {
+    let result = arrayify(value);
+    if (result.length === 0) {
+        return result;
+    }
+    let start = 0;
+    while (start < result.length && result[start] === 0) {
+        start++;
+    }
+    if (start) {
+        result = result.slice(start);
+    }
+    return result;
+}
+export function zeroPad(value, length) {
+    value = arrayify(value);
+    if (value.length > length) {
+        logger.throwArgumentError('value out of range', 'value', value);
+    }
+    const result = new Uint8Array(length);
+    result.set(value, length - value.length);
+    return result;
+}
+export function isHexString(value, length) {
+    if (typeof value !== 'string' || !value.match(/^0x[0-9A-Fa-f]*$/)) {
+        return false;
+    }
+    if (length && value.length !== 2 + 2 * length) {
+        return false;
+    }
+    return true;
+}
+const HexCharacters = '0123456789abcdef';
+export function hexlify(value, options) {
+    if (!options) {
+        options = {};
+    }
+    if (typeof value === 'number') {
+        logger.checkSafeUint53(value, 'invalid hexlify value');
+        let hex = '';
+        while (value) {
+            hex = HexCharacters[value & 0xf] + hex;
+            value = Math.floor(value / 16);
+        }
+        if (hex.length) {
+            if (hex.length % 2) {
+                hex = '0' + hex;
+            }
+            return '0x' + hex;
+        }
+        return '0x00';
+    }
+    if (typeof value === 'bigint') {
+        value = value.toString(16);
+        if (value.length % 2) {
+            return '0x0' + value;
+        }
+        return '0x' + value;
+    }
+    if (options.allowMissingPrefix &&
+        typeof value === 'string' &&
+        value.substring(0, 2) !== '0x') {
+        value = '0x' + value;
+    }
+    if (isHexable(value)) {
+        return value.toHexString();
+    }
+    if (isHexString(value)) {
+        if (value.length % 2) {
+            if (options.hexPad === 'left') {
+                value = '0x0' + value.substring(2);
+            }
+            else if (options.hexPad === 'right') {
+                value += '0';
+            }
+            else {
+                logger.throwArgumentError('hex data is odd-length', 'value', value);
+            }
+        }
+        return value.toLowerCase();
+    }
+    if (isBytes(value)) {
+        let result = '0x';
+        for (let i = 0; i < value.length; i++) {
+            const v = value[i];
+            result += HexCharacters[(v & 0xf0) >> 4] + HexCharacters[v & 0x0f];
+        }
+        return result;
+    }
+    return logger.throwArgumentError('invalid hexlify value', 'value', value);
+}
+export function hexDataLength(data) {
+    if (typeof data !== 'string') {
+        data = hexlify(data);
+    }
+    else if (!isHexString(data) || data.length % 2) {
+        return null;
+    }
+    return (data.length - 2) / 2;
+}
+export function hexDataSlice(data, offset, endOffset) {
+    if (typeof data !== 'string') {
+        data = hexlify(data);
+    }
+    else if (!isHexString(data) || data.length % 2) {
+        logger.throwArgumentError('invalid hexData', 'value', data);
+    }
+    offset = 2 + 2 * offset;
+    if (endOffset != null) {
+        return '0x' + data.substring(offset, 2 + 2 * endOffset);
+    }
+    return '0x' + data.substring(offset);
+}
+export function hexConcat(items) {
+    let result = '0x';
+    items.forEach((item) => {
+        result += hexlify(item).substring(2);
+    });
+    return result;
+}
+export function hexValue(value) {
+    const trimmed = hexStripZeros(hexlify(value, { hexPad: 'left' }));
+    if (trimmed === '0x') {
+        return '0x0';
+    }
+    return trimmed;
+}
+export function hexStripZeros(value) {
+    if (typeof value !== 'string') {
+        value = hexlify(value);
+    }
+    if (!isHexString(value)) {
+        logger.throwArgumentError('invalid hex string', 'value', value);
+    }
+    value = value.substring(2);
+    let offset = 0;
+    while (offset < value.length && value[offset] === '0') {
+        offset++;
+    }
+    return '0x' + value.substring(offset);
+}
+export function hexZeroPad(value, length) {
+    if (typeof value !== 'string') {
+        value = hexlify(value);
+    }
+    else if (!isHexString(value)) {
+        logger.throwArgumentError('invalid hex string', 'value', value);
+    }
+    if (value.length > 2 * length + 2) {
+        logger.throwError('value out of range', { value, length });
+    }
+    while (value.length < 2 * length + 2) {
+        value = '0x0' + value.substring(2);
+    }
+    return value;
+}

package/lib/esm/utils/solidity-keccak256.d.ts

@@ -0,0 +1,3 @@
+export declare function pack(types: ReadonlyArray<string>, values: ReadonlyArray<any>): string;
+export declare const hashKeccak256: (data: string) => string;
+export declare function solidityKeccak256(types: ReadonlyArray<string>, values: ReadonlyArray<any>): string;

package/lib/esm/utils/solidity-keccak256.js

@@ -0,0 +1,91 @@
+import { Buffer } from 'buffer';
+import { Keccak } from 'sha3';
+import { logger } from '../logger/logger';
+import { tinyBig } from '../shared/tiny-big/tiny-big';
+import { arrayify, concat, hexlify, zeroPad } from './bytes';
+const regexBytes = new RegExp('^bytes([0-9]+)$');
+const regexNumber = new RegExp('^(u?int)([0-9]*)$');
+const regexArray = new RegExp('^(.*)\\[([0-9]*)\\]$');
+const Zeros = '0000000000000000000000000000000000000000000000000000000000000000';
+function _pack(type, value, isArray) {
+    switch (type) {
+        case 'address':
+            if (isArray) {
+                return zeroPad(value, 32);
+            }
+            return arrayify(value);
+        case 'string':
+            return Buffer.from(value);
+        case 'bytes':
+            return arrayify(value);
+        case 'bool':
+            value = value ? '0x01' : '0x00';
+            if (isArray) {
+                return zeroPad(value, 32);
+            }
+            return arrayify(value);
+    }
+    let match = type.match(regexNumber);
+    if (match) {
+        let size = parseInt(match[2] || '256');
+        if ((match[2] && String(size) !== match[2]) ||
+            size % 8 !== 0 ||
+            size === 0 ||
+            size > 256) {
+            logger.throwArgumentError('invalid number type', 'type', type);
+        }
+        if (isArray) {
+            size = 256;
+        }
+        value = tinyBig(value).toTwos(size).toNumber();
+        const hexValue = hexlify(value);
+        return zeroPad(hexValue, size / 8);
+    }
+    match = type.match(regexBytes);
+    if (match) {
+        const size = parseInt(match[1]);
+        if (String(size) !== match[1] || size === 0 || size > 32) {
+            logger.throwArgumentError('invalid bytes type', 'type', type);
+        }
+        if (arrayify(value).byteLength !== size) {
+            logger.throwArgumentError(`invalid value for ${type}`, 'value', value);
+        }
+        if (isArray) {
+            return arrayify((value + Zeros).substring(0, 66));
+        }
+        return value;
+    }
+    match = type.match(regexArray);
+    if (match && Array.isArray(value)) {
+        const baseType = match[1];
+        const count = parseInt(match[2] || String(value.length));
+        if (count != value.length) {
+            logger.throwArgumentError(`invalid array length for ${type}`, 'value', value);
+        }
+        const result = [];
+        value.forEach(function (value) {
+            result.push(_pack(baseType, value, true));
+        });
+        return concat(result);
+    }
+    return logger.throwArgumentError('invalid type', 'type', type);
+}
+export function pack(types, values) {
+    if (types.length != values.length) {
+        logger.throwArgumentError('wrong number of values; expected ${ types.length }', 'values', values);
+    }
+    const tight = [];
+    types.forEach(function (type, index) {
+        tight.push(_pack(type, values[index]));
+    });
+    return hexlify(concat(tight));
+}
+export const hashKeccak256 = (data) => {
+    const keccak = new Keccak(256);
+    const bufferableData = Buffer.from(data.replace(/^0x/, ''), 'hex');
+    const addressHash = '0x' + keccak.update(bufferableData).digest('hex');
+    return addressHash;
+};
+export function solidityKeccak256(types, values) {
+    return hashKeccak256(pack(types, values));
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "essential-eth",
   "description": "Ultralight JS library for Ethereum utilities",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "license": "MIT",
   "sideEffects": false,
   "main": "./lib/cjs/index.js",
@@ -17,7 +17,7 @@
   "scripts": {
     "test": "npm-run-all --parallel jest compile lint",
     "test:all-node-versions": "npx trevor",
-    "lint": "eslint .",
+    "lint": "eslint --cache --fix .",
     "compile": "npm-run-all --parallel tsc:esm tsc:cjs",
     "tsc:esm": "tsc -p tsconfig.json",
     "tsc:cjs": "tsc -p tsconfig-cjs.json",
@@ -25,7 +25,9 @@
     "prepublishOnly": "npm run build",
     "jest": "jest",
     "build:chains-info": "npx ts-node scripts/fetch-chains-info.ts # used in getNetwork()",
-    "pre-commit": "sh scripts/pre-commit.sh"
+    "update-deps": "sh ./scripts/pre-commit.sh",
+    "pre-commit": "run-p build:chains-info update-deps",
+    "prepare": "husky install"
   },
   "devDependencies": {
     "@ethersproject/keccak256": "^5.4.0",
@@ -36,19 +38,19 @@
     "@types/jest-dev-server": "^5.0.0",
     "@types/node": "^16.10.1",
     "@types/prettier": "^2.4.4",
-    "@typescript-eslint/eslint-plugin": "^5.19.0",
-    "@typescript-eslint/parser": "^5.19.0",
+    "@typescript-eslint/eslint-plugin": "^5.20.0",
+    "@typescript-eslint/parser": "^5.20.0",
     "body-parser": "^1.19.0",
     "dotenv": "^16.0.0",
     "eslint": "^8.13.0",
     "eslint-plugin-jest": "^26.1.4",
-    "ethers": "^5.6.3",
+    "ethers": "^5.6.4",
     "express": "^4.17.1",
-    "husky": "^4.3.0",
+    "husky": "^7.0.4",
     "jest": "^27.5.1",
     "jest-dev-server": "^6.0.3",
     "just-omit": "^2.0.1",
-    "lint-staged": "^12.3.7",
+    "lint-staged": "^12.4.0",
     "npm-run-all": "^4.1.5",
     "prettier": "^2.6.2",
     "prettier-plugin-organize-imports": "^2.3.4",
@@ -64,15 +66,11 @@
     "isomorphic-unfetch": "^3.1.0",
     "sha3": "^2.1.4"
   },
-  "husky": {
-    "hooks": {
-      "pre-commit": "lint-staged && run-p pre-commit test build:chains-info"
-    }
-  },
   "lint-staged": {
     "*.{js,jsx,ts,tsx,css,scss,md,json,html,yml,yaml}": [
       "prettier --write"
-    ]
+    ],
+    "*.{ts,tsx}": "eslint --cache --fix"
   },
   "prettier": {
     "trailingComma": "all",

package/lib/cjs/utils/hex-zero-pad.d.ts

@@ -1,32 +0,0 @@
-/**
- * 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(hexValue: string | number, length: number): string;