essential-eth 0.6.2 → 0.7.0

package/dist/cjs/utils/tests/solidity-keccak256.test.js

@@ -0,0 +1,310 @@
+import { utils } from "ethers";
+import { solidityKeccak256 } from "../../index";
+/**
+ *
+ * @param inputs
+ */ function testSolidityKeccak256(inputs) {
+    inputs.forEach(function(input) {
+        expect(solidityKeccak256(input.types, input.values)).toBe(utils.solidityKeccak256(input.types, input.values));
+    });
+}
+describe("solidityKeccak256", function() {
+    it("should match ethers.js addresses", function() {
+        var inputs = [
+            {
+                types: [
+                    "address"
+                ],
+                values: [
+                    "0x4d7F1790644Af787933c9fF0e2cff9a9B4299Abb"
+                ]
+            },
+            {
+                types: [
+                    "address",
+                    "address"
+                ],
+                values: [
+                    "0xB5503a7db1A9105cd459D99153e69a76a8EF1530",
+                    "0xaa0fc255b079e775f9307e5cfec472a555cebc3a"
+                ]
+            }
+        ];
+        testSolidityKeccak256(inputs);
+    });
+    it("should match ethers.js strings", function() {
+        var inputs = [
+            {
+                types: [
+                    "string"
+                ],
+                values: [
+                    "essential-eth"
+                ]
+            },
+            {
+                types: [
+                    "string",
+                    "string"
+                ],
+                values: [
+                    "firstText",
+                    "secondString"
+                ]
+            },
+            {
+                types: [
+                    "string",
+                    "string",
+                    "string"
+                ],
+                values: [
+                    "example1",
+                    "2934823",
+                    "true"
+                ]
+            }
+        ];
+        testSolidityKeccak256(inputs);
+    });
+    it("should match ethers.js bytes (dynamic size) & BytesLike", function() {
+        var inputs = [
+            {
+                types: [
+                    "bytes"
+                ],
+                values: [
+                    [
+                        115,
+                        101,
+                        99,
+                        114,
+                        101,
+                        116
+                    ]
+                ]
+            },
+            {
+                types: [
+                    "bytes"
+                ],
+                values: [
+                    "0x62797465734c696b65"
+                ]
+            },
+            {
+                types: [
+                    "bytes",
+                    "bytes"
+                ],
+                values: [
+                    "0x657373656e7469616c2d657468",
+                    [
+                        115,
+                        109,
+                        97,
+                        108,
+                        108,
+                        101,
+                        115,
+                        116
+                    ]
+                ]
+            }
+        ];
+        testSolidityKeccak256(inputs);
+    });
+    it("should match ethers.js bytes (static size)", function() {
+        var inputs = [
+            {
+                types: [
+                    "bytes4"
+                ],
+                values: [
+                    [
+                        116,
+                        101,
+                        115,
+                        116
+                    ]
+                ]
+            },
+            {
+                types: [
+                    "bytes13",
+                    "bytes1",
+                    "bytes2",
+                    "bytes5",
+                    "bytes1"
+                ],
+                values: [
+                    [
+                        101,
+                        115,
+                        115,
+                        101,
+                        110,
+                        116,
+                        105,
+                        97,
+                        108,
+                        45,
+                        101,
+                        116,
+                        104
+                    ],
+                    [
+                        32
+                    ],
+                    [
+                        105,
+                        115
+                    ],
+                    [
+                        103,
+                        114,
+                        101,
+                        97,
+                        116
+                    ],
+                    [
+                        33
+                    ]
+                ]
+            }
+        ];
+        testSolidityKeccak256(inputs);
+    });
+    it('should match ethers.js booleans (specified as type "bool" to match solidity)', function() {
+        var inputs = [
+            {
+                types: [
+                    "bool"
+                ],
+                values: [
+                    true
+                ]
+            },
+            {
+                types: [
+                    "bool",
+                    "bool"
+                ],
+                values: [
+                    false,
+                    false
+                ]
+            }
+        ];
+        testSolidityKeccak256(inputs);
+    });
+    it("should match ethers.js (signed and unsigned) integers", function() {
+        var inputs = [
+            {
+                types: [
+                    "int16"
+                ],
+                values: [
+                    -1
+                ]
+            },
+            {
+                types: [
+                    "uint48"
+                ],
+                values: [
+                    12
+                ]
+            },
+            {
+                types: [
+                    "int16",
+                    "uint48"
+                ],
+                values: [
+                    -1,
+                    12
+                ]
+            }
+        ];
+        testSolidityKeccak256(inputs);
+    });
+    it("should match ethers.js array parsing", function() {
+        var inputs = [
+            {
+                types: [
+                    "string[2]"
+                ],
+                values: [
+                    [
+                        "some-text",
+                        "additional-text"
+                    ]
+                ]
+            }
+        ];
+        testSolidityKeccak256(inputs);
+    });
+    it("should match ethers.js when passing different types into the same solidityKeccak256 function call", function() {
+        var inputs = [
+            {
+                types: [
+                    "int16",
+                    "string",
+                    "bool"
+                ],
+                values: [
+                    -5,
+                    "essential-eth",
+                    true
+                ]
+            },
+            {
+                types: [
+                    "address",
+                    "uint48",
+                    "bytes4"
+                ],
+                values: [
+                    "0xB5503a7db1A9105cd459D99153e69a76a8EF1530",
+                    20,
+                    [
+                        116,
+                        101,
+                        115,
+                        116
+                    ]
+                ]
+            },
+            {
+                types: [
+                    "string[3]",
+                    "bytes",
+                    "bool[2]"
+                ],
+                values: [
+                    [
+                        "ethereum",
+                        "blockchain",
+                        "204"
+                    ],
+                    [
+                        115,
+                        111,
+                        108,
+                        105,
+                        100,
+                        105,
+                        116,
+                        121
+                    ],
+                    [
+                        false,
+                        true
+                    ]
+                ]
+            }
+        ];
+        testSolidityKeccak256(inputs);
+    });
+});

package/dist/cjs/utils/tests/split-signature.test.js

@@ -0,0 +1,25 @@
+import { utils } from "ethers";
+import { splitSignature } from "../split-signature";
+describe("splitSignature", function() {
+    it("should match ethers.js", function() {
+        var signatures = [
+            "0x60bc4ed91f2021aefe7045f3f77bd12f87eb733aee24bd1965343b3c27b3971647252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee331b",
+            "0x60bc4ed91f2021aefe7045f3f77bd12f87eb733aee24bd1965343b3c27b3971647252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33"
+        ];
+        signatures.forEach(function(signature) {
+            expect(splitSignature(signature)).toStrictEqual(utils.splitSignature(signature));
+        });
+    });
+    it("should throw error on invalid signature", function() {
+        var signature = "0x60bc4ed91f2021aefe7045f3f77bd12f87eb733aee24bd1965343b3c27b3971647252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33238423849234765127"; //invalid signature length
+        expect(function() {
+            splitSignature(signature);
+        }).toThrow("invalid signature string");
+    });
+    it("should throw error on invalid v byte", function() {
+        var signature = "0x60bc4ed91f2021aefe7045f3f77bd12f87eb733aee24bd1965343b3c27b3971647252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee3305";
+        expect(function() {
+            splitSignature(signature);
+        }).toThrow("signature invalid v byte");
+    });
+});

package/dist/cjs/utils/tests/to-checksum-address.test.js

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

package/dist/cjs/utils/tests/to-utf8-bytes.test.js

@@ -0,0 +1,14 @@
+import { utils } from "ethers";
+import { toUtf8Bytes } from "../../index";
+describe("utils.toUtf8Bytes", function() {
+    it("should match ethers.js", function() {
+        var inputs = [
+            "0xa",
+            "1",
+            "false"
+        ];
+        inputs.forEach(function(input) {
+            expect(toUtf8Bytes(input)).toStrictEqual(utils.toUtf8Bytes(input));
+        });
+    });
+});

package/dist/cjs/utils/tests/wei-to-ether.test.js

@@ -0,0 +1,51 @@
+import Big from "big.js";
+import * as ethers from "ethers";
+import web3 from "web3";
+import { tinyBig, weiToEther } from "../../index";
+describe("wei-to-ether", function() {
+    it("happy path", function() {
+        expect(weiToEther("100000000000000000000.0").toString()).toBe("100");
+        expect(weiToEther(100000000000000000000.0).toString()).toBe("100");
+        expect(weiToEther("1000000000000000000000.0").toNumber()).toBe(1000);
+        expect(weiToEther(1000000000000000000000.0).toNumber()).toBe(1000);
+        expect(weiToEther(tinyBig("1000000000000000000000.0")).toNumber()).toBe(1000);
+        expect(weiToEther(tinyBig(1000000000000000000000.0)).toNumber()).toBe(1000);
+        expect(weiToEther(Big("1000000000000000000000.0")).toNumber()).toBe(1000);
+        expect(weiToEther(Big(1000000000000000000000.0)).toNumber()).toBe(1000);
+    });
+    describe("matches ethers and web3 toString", function() {
+        it("toString", function() {
+            expect(weiToEther("10").toString()).toStrictEqual(ethers.utils.formatEther("10"));
+            expect(weiToEther("1000000000000000000000").toString()).toBe("1000");
+            expect(weiToEther("10").toString()).toStrictEqual(web3.utils.fromWei("10", "ether"));
+            expect(weiToEther("1000000000000000000000").toString()).toStrictEqual(web3.utils.fromWei("1000000000000000000000", "ether"));
+        });
+        it("toNumber", function() {
+            /* easy */ expect(weiToEther("9").toNumber()).toStrictEqual(Number(ethers.utils.formatEther("9")));
+            // expect(weiToEther("9").toNumber()).toStrictEqual(
+            //   Number(ethers.utils.formatEther("9")),
+            // );
+            expect(weiToEther("9").toNumber()).toStrictEqual(Number(web3.utils.fromWei("9", "ether")));
+            /* hard because they respond with scientific notation or overflowing */ expect(weiToEther("999999").toNumber()).toStrictEqual(Number(ethers.utils.formatEther("999999")));
+            expect(weiToEther("999999").toNumber()).toStrictEqual(Number(web3.utils.fromWei("999999", "ether")));
+        });
+    });
+    it("support hex", function() {
+        expect(weiToEther("0x14").toString()).toStrictEqual(ethers.utils.formatEther("20"));
+        expect(weiToEther(0x14).toString()).toStrictEqual(ethers.utils.formatEther("20"));
+    });
+    it("wrong types", function() {
+        expect(function() {
+            // @ts-expect-error should not accept boolean
+            weiToEther(false);
+        }).toThrow();
+        expect(function() {
+            // @ts-expect-error should not accept array
+            weiToEther([
+                1,
+                2,
+                3
+            ]);
+        }).toThrow();
+    });
+});

package/dist/cjs/utils/to-checksum-address.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toChecksumAddress = void 0;
-const sha3_1 = require("sha3");
-const validate_type_1 = require("../shared/validate-type");
+import { Keccak } from "sha3";
+import { validateType } from "../shared/validate-type";
 /**
  * Returns an Ethereum address in proper mixed-case checksum.
  * Does NOT support ICAP
@@ -18,29 +15,27 @@ const validate_type_1 = require("../shared/validate-type");
  * Similar to ["getAddress" in ethers.js](https://docs.ethers.io/v5/api/utils/address/#utils-getAddress)
  *
  * Similar to ["toChecksumAddress" in web3.js](https://web3js.readthedocs.io/en/v1.7.1/web3-utils.html#tochecksumaddress)
- */
-function toChecksumAddress(address) {
-    (0, validate_type_1.validateType)(address, ['string']);
+ */ export function toChecksumAddress(address) {
+    validateType(address, [
+        "string"
+    ]);
     if (!/^(0x)?[0-9a-f]{40}$/i.test(address)) {
-        throw new Error(`Invalid Ethereum address "${address}"`);
+        throw new Error('Invalid Ethereum address "'.concat(address, '"'));
     }
-    const _address = address.toLowerCase().replace(/^0x/i, '');
-    const keccak = new sha3_1.Keccak(256);
-    const addressHash = keccak.update(_address).digest('hex').replace(/^0x/i, '');
-    let checksumAddress = '0x';
-    for (let i = 0; i < _address.length; i++) {
+    var _address = address.toLowerCase().replace(/^0x/i, "");
+    var keccak = new Keccak(256);
+    var addressHash = keccak.update(_address).digest("hex").replace(/^0x/i, "");
+    var checksumAddress = "0x";
+    for(var i = 0; i < _address.length; i++){
         // If ith character is 8 to f then make it uppercase
         if (parseInt(addressHash[i], 16) > 7) {
             checksumAddress += _address[i].toUpperCase();
-        }
-        else {
+        } else {
             checksumAddress += _address[i];
         }
     }
-    if (address.match(/([A-F].*[a-f])|([a-f].*[A-F])/) &&
-        checksumAddress !== address) {
-        throw new Error(`Invalid Checksum address for "${address}"`);
+    if (address.match(/([A-F].*[a-f])|([a-f].*[A-F])/) && checksumAddress !== address) {
+        throw new Error('Invalid Checksum address for "'.concat(address, '"'));
     }
     return checksumAddress;
 }
-exports.toChecksumAddress = toChecksumAddress;

package/dist/cjs/utils/to-utf8-bytes.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toUtf8Bytes = void 0;
 /**
  * Converts a string into a UTF-8 Byte Array
  *
@@ -14,8 +11,6 @@ exports.toUtf8Bytes = void 0;
  * toUtf8Bytes('ethereum');
  * // Uint8Array { [Iterator]  0: 101, 1: 116, 2: 104, 3: 101, 4: 114, 5: 101, 6: 117, 7: 109 }
  * ```
- */
-function toUtf8Bytes(data) {
+ */ export function toUtf8Bytes(data) {
     return new Uint8Array(Buffer.from(data));
 }
-exports.toUtf8Bytes = toUtf8Bytes;

package/dist/cjs/utils/wei-to-ether.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.weiToEther = void 0;
-const tiny_big_1 = require("../shared/tiny-big/tiny-big");
-const validate_type_1 = require("../shared/validate-type");
+import { tinyBig } from "../shared/tiny-big/tiny-big";
+import { validateType } from "../shared/validate-type";
 /**
  * Convert from Wei to Ether
  *
@@ -26,20 +23,21 @@ const validate_type_1 = require("../shared/validate-type");
  * weiToEther(1000000000000000000000).toNumber()
  * // 1000
  * ```
- */
-function weiToEther(weiQuantity) {
-    (0, validate_type_1.validateType)(weiQuantity, ['string', 'number', 'object']);
+ */ export function weiToEther(weiQuantity) {
+    validateType(weiQuantity, [
+        "string",
+        "number",
+        "object"
+    ]);
     // eslint-disable-next-line no-useless-catch
     try {
-        let _weiQuantity = weiQuantity;
-        if (typeof weiQuantity === 'string' && weiQuantity.slice(0, 2) === '0x') {
+        var _weiQuantity = weiQuantity;
+        if (typeof weiQuantity === "string" && weiQuantity.slice(0, 2) === "0x") {
             _weiQuantity = BigInt(weiQuantity).toString();
         }
-        const result = (0, tiny_big_1.tinyBig)(_weiQuantity).div('1000000000000000000');
-        return (0, tiny_big_1.tinyBig)(result);
-    }
-    catch (error) {
+        var result = tinyBig(_weiQuantity).div("1000000000000000000");
+        return tinyBig(result);
+    } catch (error) {
         throw error;
     }
 }
-exports.weiToEther = weiToEther;

package/dist/esm/classes/utils/clean-block.d.ts

@@ -1,3 +1,2 @@
-import type { BlockResponse } from '../..';
-import type { RPCBlock } from '../../types/Block.types';
+import type { BlockResponse, RPCBlock } from '../../types/Block.types';
 export declare function cleanBlock(block: RPCBlock, returnTransactionObjects: boolean): BlockResponse;

package/dist/esm/classes/utils/clean-block.js

@@ -1,5 +1,5 @@
-import { toChecksumAddress } from '../..';
 import { tinyBig } from '../../shared/tiny-big/tiny-big';
+import { toChecksumAddress } from '../../utils/to-checksum-address';
 import { cleanTransaction } from './clean-transaction';
 import { hexToDecimal } from './hex-to-decimal';
 export function cleanBlock(block, returnTransactionObjects) {

package/dist/esm/classes/utils/clean-transaction-receipt.js

@@ -1,4 +1,5 @@
-import { tinyBig, toChecksumAddress } from '../..';
+import { tinyBig } from '../../shared/tiny-big/tiny-big';
+import { toChecksumAddress } from '../../utils/to-checksum-address';
 import { cleanLog } from './clean-log';
 import { cleanTransaction } from './clean-transaction';
 import { hexToDecimal } from './hex-to-decimal';

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

@@ -1,4 +1,5 @@
-import { tinyBig, toChecksumAddress } from '../..';
+import { tinyBig } from '../../shared/tiny-big/tiny-big';
+import { toChecksumAddress } from '../../utils/to-checksum-address';
 import { hexToDecimal } from './hex-to-decimal';
 export function cleanTransaction(transaction) {
     const cleanedTransaction = Object.assign({}, transaction);

package/dist/esm/classes/utils/encode-decode-transaction.d.ts

@@ -1,4 +1,4 @@
 import type { JSONABIArgument } from '../../types/Contract.types';
 export declare const hexFalse: string;
 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)[];
+export declare function decodeRPCResponse(jsonABIArgument: JSONABIArgument, nodeResponse: string): string | number | boolean | import("../../shared/tiny-big/tiny-big").TinyBig | (string | number | boolean | import("../../shared/tiny-big/tiny-big").TinyBig)[];

package/dist/esm/classes/utils/encode-decode-transaction.js

@@ -1,8 +1,29 @@
 import { Keccak } from 'sha3';
-import { tinyBig, toChecksumAddress } from '../..';
+import { tinyBig } from '../../shared/tiny-big/tiny-big';
+import { toChecksumAddress } from '../../utils/to-checksum-address';
 import { hexToDecimal } from './hex-to-decimal';
 export const hexFalse = '0'.repeat(64);
 const hexTrue = '0'.repeat(63) + '1';
+function hexToUtf8(hex) {
+    let str = '';
+    let i = 0;
+    const l = hex.length;
+    if (hex.substring(0, 2) === '0x') {
+        i = 2;
+    }
+    for (; i < l; i += 2) {
+        const code = parseInt(hex.substr(i, 2), 16);
+        if (code === 0)
+            continue;
+        str += String.fromCharCode(code);
+    }
+    try {
+        return decodeURIComponent(escape(str));
+    }
+    catch (e) {
+        return str;
+    }
+}
 function expandType(type) {
     if (type === 'uint[]') {
         return 'uint256[]';
@@ -75,8 +96,22 @@ export function encodeData(jsonABIArgument, args) {
     return data;
 }
 export function decodeRPCResponse(jsonABIArgument, nodeResponse) {
+    var _a;
     const rawOutputs = jsonABIArgument.outputs;
-    const encodedOutputs = nodeResponse.slice(2).match(/.{1,64}/g);
+    const slicedResponse = nodeResponse.slice(2);
+    if (((_a = jsonABIArgument === null || jsonABIArgument === void 0 ? void 0 : jsonABIArgument.outputs) === null || _a === void 0 ? void 0 : _a.length) === 1 &&
+        jsonABIArgument.outputs[0].type === 'string') {
+        const [hexOffset, responseData] = [
+            slicedResponse.slice(0, 64),
+            slicedResponse.slice(64),
+        ];
+        const decimalOffset = Number(hexToDecimal(`0x${hexOffset}`));
+        const hexLength = responseData.slice(0, decimalOffset * 2);
+        const decimalLength = Number(hexToDecimal(`0x${hexLength}`));
+        const hexToDecode = responseData.slice(decimalOffset * 2, decimalOffset * 2 + decimalLength * 2);
+        return hexToUtf8(hexToDecode);
+    }
+    const encodedOutputs = slicedResponse.match(/.{1,64}/g);
     const outputs = (encodedOutputs || []).map((output, i) => {
         const outputType = (rawOutputs || [])[i].type;
         switch (outputType) {

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

@@ -1 +1 @@
-export declare const version = "0.6.2";
+export declare const version = "0.7.0";

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

@@ -1 +1 @@
-export const version = '0.6.2';
+export const version = '0.7.0';

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

@@ -1,6 +1,7 @@
-import { computePublicKey, toChecksumAddress } from '..';
 import { hexDataSlice } from './bytes';
+import { computePublicKey } from './compute-public-key';
 import { keccak256 } from './keccak256';
+import { toChecksumAddress } from './to-checksum-address';
 export function computeAddress(key) {
     if (!key.startsWith('0x04') &&
         !key.startsWith('0x03') &&