essential-eth 0.5.1 → 0.5.5

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

@@ -189,6 +189,9 @@ export default {
     "69": [
         "okov"
     ],
+    "70": [
+        "hsc"
+    ],
     "71": [
         "cfxtest"
     ],
@@ -360,6 +363,9 @@ export default {
     "226": [
         "TLA"
     ],
+    "239": [
+        "AITD"
+    ],
     "246": [
         "ewt"
     ],
@@ -432,6 +438,9 @@ export default {
     "513": [
         "aact"
     ],
+    "534": [
+        "CNDL"
+    ],
     "555": [
         "CLASS"
     ],
@@ -441,9 +450,18 @@ export default {
     "588": [
         "metis-stardust"
     ],
+    "592": [
+        "astr"
+    ],
     "595": [
         "maca"
     ],
+    "596": [
+        "tkar"
+    ],
+    "597": [
+        "taca"
+    ],
     "600": [
         "mesh-chain-testnet"
     ],
@@ -465,6 +483,9 @@ export default {
     "721": [
         "tfeth"
     ],
+    "776": [
+        "opc"
+    ],
     "777": [
         "cth"
     ],
@@ -606,6 +627,9 @@ export default {
     "1688": [
         "LUDAN"
     ],
+    "1819": [
+        "cubet"
+    ],
     "1856": [
         "tsf"
     ],
@@ -621,6 +645,12 @@ export default {
     "2001": [
         "milkAda"
     ],
+    "2008": [
+        "cloudwalk_testnet"
+    ],
+    "2009": [
+        "cloudwalk_mainnet"
+    ],
     "2020": [
         "420"
     ],
@@ -630,6 +660,9 @@ export default {
     "2022": [
         "edgt"
     ],
+    "2023": [
+        "taycan-testnet"
+    ],
     "2025": [
         "rpg"
     ],
@@ -657,6 +690,15 @@ export default {
     "2559": [
         "ktoc"
     ],
+    "2569": [
+        "tpc"
+    ],
+    "2612": [
+        "EZChain"
+    ],
+    "2613": [
+        "Fuji-EZChain"
+    ],
     "3000": [
         "cennz-r"
     ],
@@ -762,6 +804,9 @@ export default {
     "8888": [
         "ambrostestnet"
     ],
+    "8898": [
+        "mmt"
+    ],
     "8995": [
         "berg"
     ],
@@ -820,7 +865,10 @@ export default {
         "cennz-a"
     ],
     "21816": [
-        "oml"
+        "omc"
+    ],
+    "22023": [
+        "SFL"
     ],
     "24484": [
         "web"
@@ -828,12 +876,18 @@ export default {
     "24734": [
         "mintme"
     ],
+    "30067": [
+        "Piece"
+    ],
     "31102": [
         "esn"
     ],
     "31337": [
         "got"
     ],
+    "32520": [
+        "Brise"
+    ],
     "32659": [
         "fsn"
     ],
@@ -868,7 +922,7 @@ export default {
         "ALFA"
     ],
     "45000": [
-        "autobahn"
+        "Autobahn Network"
     ],
     "47805": [
         "REI"
@@ -900,6 +954,9 @@ export default {
     "62320": [
         "BKLV"
     ],
+    "62621": [
+        "mtv"
+    ],
     "63000": [
         "ecs"
     ],
@@ -1035,6 +1092,9 @@ export default {
     "444900": [
         "wlkt"
     ],
+    "512512": [
+        "cmp"
+    ],
     "666666": [
         "vpioneer"
     ],

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

@@ -20,6 +20,24 @@ export declare type TransactionResponse = Modify<RPCTransaction, {
     maxPriorityFeePerGas: TinyBig;
     confirmations: number;
 }>;
+export declare type TransactionReceipt = Modify<RPCTransactionReceipt, {
+    blockNumber: number;
+    cumulativeGasUsed: TinyBig;
+    effectiveGasPrice: TinyBig;
+    gasUsed: TinyBig;
+    logs: Array<Log>;
+    status: number;
+    transactionIndex: number;
+    type: number;
+} & {
+    byzantium: boolean;
+    confirmations: number;
+}>;
+export declare type Log = Modify<Omit<RPCLog, 'removed'>, {
+    blockNumber: number;
+    logIndex: number;
+    transactionIndex: number;
+}>;
 export declare type BlockTransactionResponse = Omit<TransactionResponse, 'maxFeePerGas' | 'maxPriorityFeePerGas'>;
 export interface RPCBlockTransaction {
     blockHash: string;
@@ -39,4 +57,31 @@ export interface RPCBlockTransaction {
     v: string;
     value: string;
 }
+export interface RPCTransactionReceipt {
+    blockHash: string;
+    blockNumber: string;
+    contractAddress: string;
+    cumulativeGasUsed: string;
+    effectiveGasPrice: string;
+    from: string;
+    gasUsed: string;
+    logs: Array<RPCLog>;
+    logsBloom: string;
+    status: string;
+    to: string;
+    transactionHash: string;
+    transactionIndex: string;
+    type: string;
+}
+export interface RPCLog {
+    address: string;
+    blockHash: string;
+    blockNumber: string;
+    data: string;
+    logIndex: string;
+    removed?: boolean;
+    topics: Array<string>;
+    transactionHash: string;
+    transactionIndex: string;
+}
 export {};

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

@@ -1,5 +1,6 @@
 export declare type Bytes = ArrayLike<number>;
-export declare type BytesLike = Bytes | string | number;
+export declare type BytesLike = Bytes | string;
+export declare type BytesLikeWithNumber = BytesLike | number;
 export interface DataOptions {
     allowMissingPrefix?: boolean;
     hexPad?: 'left' | 'right' | null;
@@ -26,14 +27,14 @@ export interface Signature {
 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 concat(arrayOfBytesLike: ReadonlyArray<BytesLikeWithNumber>): 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 hexDataSlice(data: BytesLikeWithNumber, 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;
+export declare function hexZeroPad(value: BytesLikeWithNumber, length: number): string;

package/lib/esm/utils/bytes.js

@@ -77,8 +77,8 @@ export function arrayify(value, options) {
     }
     return logger.throwArgumentError('invalid arrayify value', 'value', value);
 }
-export function concat(items) {
-    const objects = items.map((item) => arrayify(item));
+export function concat(arrayOfBytesLike) {
+    const objects = arrayOfBytesLike.map((item) => arrayify(item));
     const length = objects.reduce((accum, item) => accum + item.length, 0);
     const result = new Uint8Array(length);
     objects.reduce((offset, object) => {

package/lib/esm/utils/compute-address.d.ts

@@ -0,0 +1 @@
+export declare function computeAddress(key: string): string;

package/lib/esm/utils/compute-address.js

@@ -0,0 +1,11 @@
+import { computePublicKey, toChecksumAddress } from '..';
+import { hexDataSlice } from './bytes';
+import { keccak256 } from './keccak256';
+export function computeAddress(key) {
+    if (!key.startsWith('0x04') &&
+        !key.startsWith('0x03') &&
+        !key.startsWith('0x02')) {
+        key = computePublicKey(key);
+    }
+    return toChecksumAddress(hexDataSlice(keccak256(hexDataSlice(key, 1)), 12));
+}

package/lib/esm/utils/compute-public-key.d.ts

@@ -0,0 +1,2 @@
+import { BytesLike } from './bytes';
+export declare function computePublicKey(privKey: BytesLike): string;

package/lib/esm/utils/compute-public-key.js

@@ -0,0 +1,6 @@
+import { Point } from '@noble/secp256k1';
+import { hexlify } from './bytes';
+export function computePublicKey(privKey) {
+    privKey = hexlify(privKey).slice(2);
+    return '0x' + Point.fromPrivateKey(privKey).toHex();
+}

package/lib/esm/utils/hash-message.d.ts

@@ -0,0 +1,2 @@
+import { Bytes } from '../index';
+export declare function hashMessage(message: Bytes | string): string;

package/lib/esm/utils/hash-message.js

@@ -0,0 +1,12 @@
+import { concat, keccak256, toUtf8Bytes } from '../index';
+const messagePrefix = '\x19Ethereum Signed Message:\n';
+export function hashMessage(message) {
+    if (typeof message === 'string') {
+        message = toUtf8Bytes(message);
+    }
+    return keccak256(concat([
+        toUtf8Bytes(messagePrefix),
+        toUtf8Bytes(String(message.length)),
+        message,
+    ]));
+}

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

@@ -0,0 +1,2 @@
+import { BytesLike } from './bytes';
+export declare const keccak256: (data: BytesLike) => string;

package/lib/esm/utils/keccak256.js

@@ -0,0 +1,13 @@
+import { Keccak } from 'sha3';
+export const keccak256 = (data) => {
+    let bufferableData;
+    if (typeof data === 'string') {
+        bufferableData = Buffer.from(data.replace(/^0x/, ''), 'hex');
+    }
+    else {
+        bufferableData = Buffer.from(data);
+    }
+    const keccak = new Keccak(256);
+    const addressHash = '0x' + keccak.update(bufferableData).digest('hex');
+    return addressHash;
+};

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

@@ -1,3 +1,2 @@
 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

@@ -1,12 +1,12 @@
 import { Buffer } from 'buffer';
-import { Keccak } from 'sha3';
+import { hexFalse } from '../classes/utils/encode-decode-transaction';
 import { logger } from '../logger/logger';
 import { tinyBig } from '../shared/tiny-big/tiny-big';
 import { arrayify, concat, hexlify, zeroPad } from './bytes';
+import { keccak256 } from './keccak256';
 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':
@@ -51,7 +51,7 @@ function _pack(type, value, isArray) {
             logger.throwArgumentError(`invalid value for ${type}`, 'value', value);
         }
         if (isArray) {
-            return arrayify((value + Zeros).substring(0, 66));
+            return arrayify((value + hexFalse).substring(0, 66));
         }
         return value;
     }
@@ -80,12 +80,6 @@ export function pack(types, values) {
     });
     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));
+    return keccak256(pack(types, values));
 }

package/lib/esm/utils/split-signature.d.ts

@@ -0,0 +1,2 @@
+import { Signature, SignatureLike } from './bytes';
+export declare function splitSignature(signature: SignatureLike): Signature;

package/lib/esm/utils/split-signature.js

@@ -0,0 +1,126 @@
+import { logger } from './../logger/logger';
+import { arrayify, hexlify, hexZeroPad, isBytesLike, isHexString, zeroPad, } from './bytes';
+export function splitSignature(signature) {
+    const result = {
+        r: '0x',
+        s: '0x',
+        _vs: '0x',
+        recoveryParam: 0,
+        v: 0,
+        yParityAndS: '0x',
+        compact: '0x',
+    };
+    if (isBytesLike(signature)) {
+        const bytes = arrayify(signature);
+        if (bytes.length === 64) {
+            result.v = 27 + (bytes[32] >> 7);
+            bytes[32] &= 0x7f;
+            result.r = hexlify(bytes.slice(0, 32));
+            result.s = hexlify(bytes.slice(32, 64));
+        }
+        else if (bytes.length === 65) {
+            result.r = hexlify(bytes.slice(0, 32));
+            result.s = hexlify(bytes.slice(32, 64));
+            result.v = bytes[64];
+        }
+        else {
+            logger.throwArgumentError('invalid signature string', 'signature', signature);
+        }
+        if (result.v < 27) {
+            if (result.v === 0 || result.v === 1) {
+                result.v += 27;
+            }
+            else {
+                logger.throwArgumentError('signature invalid v byte', 'signature', signature);
+            }
+        }
+        result.recoveryParam = 1 - (result.v % 2);
+        if (result.recoveryParam) {
+            bytes[32] |= 0x80;
+        }
+        result._vs = hexlify(bytes.slice(32, 64));
+    }
+    else {
+        result.r = signature.r;
+        result.s = signature.s;
+        result.v = signature.v;
+        result.recoveryParam = signature.recoveryParam;
+        result._vs = signature._vs;
+        if (result._vs != null) {
+            const vs_1 = zeroPad(arrayify(result._vs), 32);
+            result._vs = hexlify(vs_1);
+            const recoveryParam = vs_1[0] >= 128 ? 1 : 0;
+            if (result.recoveryParam == null) {
+                result.recoveryParam = recoveryParam;
+            }
+            else if (result.recoveryParam !== recoveryParam) {
+                logger.throwArgumentError('signature recoveryParam mismatch _vs', 'signature', signature);
+            }
+            vs_1[0] &= 0x7f;
+            const s = hexlify(vs_1);
+            if (result.s == null) {
+                result.s = s;
+            }
+            else if (result.s !== s) {
+                logger.throwArgumentError('signature v mismatch _vs', 'signature', signature);
+            }
+        }
+        if (result.recoveryParam == null) {
+            if (result.v == null) {
+                logger.throwArgumentError('signature missing v and recoveryParam', 'signature', signature);
+            }
+            else if (result.v === 0 || result.v === 1) {
+                result.recoveryParam = result.v;
+            }
+            else {
+                result.recoveryParam = 1 - (result.v % 2);
+            }
+        }
+        else {
+            if (result.v == null) {
+                result.v = 27 + result.recoveryParam;
+            }
+            else {
+                const recId = result.v === 0 || result.v === 1 ? result.v : 1 - (result.v % 2);
+                if (result.recoveryParam !== recId) {
+                    logger.throwArgumentError('signature recoveryParam mismatch v', 'signature', signature);
+                }
+            }
+        }
+        if (result.r == null || !isHexString(result.r)) {
+            logger.throwArgumentError('signature missing or invalid r', 'signature', signature);
+        }
+        else {
+            result.r = hexZeroPad(result.r, 32);
+        }
+        if (result.s == null || !isHexString(result.s)) {
+            logger.throwArgumentError('signature missing or invalid s', 'signature', signature);
+        }
+        else {
+            result.s = hexZeroPad(result.s, 32);
+        }
+        const vs = arrayify(result.s);
+        if (vs[0] >= 128) {
+            logger.throwArgumentError('signature s out of range', 'signature', signature);
+        }
+        if (result.recoveryParam) {
+            vs[0] |= 0x80;
+        }
+        const _vs = hexlify(vs);
+        if (result._vs) {
+            if (!isHexString(result._vs)) {
+                logger.throwArgumentError('signature invalid _vs', 'signature', signature);
+            }
+            result._vs = hexZeroPad(result._vs, 32);
+        }
+        if (result._vs == null) {
+            result._vs = _vs;
+        }
+        else if (result._vs !== _vs) {
+            logger.throwArgumentError('signature _vs mismatch v and s', 'signature', signature);
+        }
+    }
+    result.yParityAndS = result._vs;
+    result.compact = result.r + result.yParityAndS.substring(2);
+    return result;
+}

package/lib/esm/utils/to-utf8-bytes.d.ts

@@ -0,0 +1 @@
+export declare function toUtf8Bytes(data: string): Uint8Array;

package/lib/esm/utils/to-utf8-bytes.js

@@ -0,0 +1,3 @@
+export function toUtf8Bytes(data) {
+    return new Uint8Array(Buffer.from(data));
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "essential-eth",
-  "description": "Ultralight JS library for Ethereum utilities",
-  "version": "0.5.1",
+  "description": "Ultralight JS for Ethereum",
+  "version": "0.5.5",
   "license": "MIT",
   "sideEffects": false,
   "main": "./lib/cjs/index.js",
@@ -22,45 +22,50 @@
     "tsc:esm": "tsc -p tsconfig.json",
     "tsc:cjs": "tsc -p tsconfig-cjs.json",
     "build": "rm -rf lib && npm run compile",
-    "prepublishOnly": "npm run build",
+    "build:readme": ". ./scripts/markdown-magic/build-readme.sh",
     "jest": "jest",
     "build:chains-info": "npx ts-node scripts/fetch-chains-info.ts # used in getNetwork()",
     "update-deps": "sh ./scripts/pre-commit.sh",
     "pre-commit": "run-p build:chains-info update-deps",
-    "prepare": "husky install"
+    "prepare": "husky install",
+    "version": "npx genversion --es6 src/logger/package-version.ts && git add src/logger/package-version.ts",
+    "postversion": "git push --follow-tags",
+    "prepublishOnly": "npm run build",
+    "doc": "typedoc"
   },
   "devDependencies": {
-    "@ethersproject/keccak256": "^5.4.0",
     "@types/body-parser": "^1.19.1",
-    "@types/eslint": "^8.4.1",
+    "@types/eslint": "^8.4.2",
     "@types/express": "^4.17.13",
     "@types/jest": "^27.4.1",
     "@types/jest-dev-server": "^5.0.0",
     "@types/node": "^16.10.1",
     "@types/prettier": "^2.4.4",
-    "@typescript-eslint/eslint-plugin": "^5.20.0",
-    "@typescript-eslint/parser": "^5.20.0",
+    "@typescript-eslint/eslint-plugin": "^5.25.0",
+    "@typescript-eslint/parser": "^5.25.0",
     "body-parser": "^1.19.0",
     "dotenv": "^16.0.0",
-    "eslint": "^8.13.0",
-    "eslint-plugin-jest": "^26.1.4",
-    "ethers": "^5.6.4",
+    "eslint": "^8.16.0",
+    "eslint-plugin-jest": "^26.2.2",
+    "ethers": "^5.6.7",
     "express": "^4.17.1",
     "husky": "^7.0.4",
     "jest": "^27.5.1",
     "jest-dev-server": "^6.0.3",
     "just-omit": "^2.0.1",
-    "lint-staged": "^12.4.0",
+    "lint-staged": "^12.4.1",
     "npm-run-all": "^4.1.5",
+    "perf_hooks": "^0.0.1",
     "prettier": "^2.6.2",
     "prettier-plugin-organize-imports": "^2.3.4",
     "ts-jest": "^27.1.4",
     "ts-node": "^10.2.1",
-    "typedoc": "^0.22.13",
-    "typescript": "^4.6.3",
+    "typedoc": "^0.22.15",
+    "typescript": "^4.6.4",
     "web3": "^1.7.3"
   },
   "dependencies": {
+    "@noble/secp256k1": "^1.5.5",
     "@types/big.js": "^6.1.3",
     "big.js": "^6.1.1",
     "isomorphic-unfetch": "^3.1.0",