essential-eth 0.9.1-next.0 → 0.9.1-next.1

package/dist/cjs/utils/tests/bytes/strip-zeros.test.js

@@ -1,106 +0,0 @@
-import { stripZeros } from "../../bytes";
-describe("utils.stripZeros", function() {
-    it("should match expected result - hex string", function() {
-        var testCases = [
-            {
-                value: "0x00009347",
-                expected: new Uint8Array([
-                    147,
-                    71
-                ])
-            },
-            {
-                value: "0x00185754",
-                expected: new Uint8Array([
-                    24,
-                    87,
-                    84
-                ])
-            },
-            {
-                value: "0x00000000005823",
-                expected: new Uint8Array([
-                    88,
-                    35
-                ])
-            }
-        ];
-        testCases.forEach(function(testCase) {
-            expect(stripZeros(testCase.value)).toStrictEqual(testCase.expected);
-        });
-    });
-    it("should match expected result - UInt8Array", function() {
-        var testCases = [
-            {
-                value: [
-                    0,
-                    0,
-                    0,
-                    9,
-                    58,
-                    29,
-                    24
-                ],
-                expected: new Uint8Array([
-                    9,
-                    58,
-                    29,
-                    24
-                ])
-            },
-            {
-                value: [
-                    0,
-                    185,
-                    203
-                ],
-                expected: new Uint8Array([
-                    185,
-                    203
-                ])
-            },
-            {
-                value: [
-                    0,
-                    0,
-                    0,
-                    0,
-                    239,
-                    30,
-                    49,
-                    41,
-                    5,
-                    10,
-                    42
-                ],
-                expected: new Uint8Array([
-                    239,
-                    30,
-                    49,
-                    41,
-                    5,
-                    10,
-                    42
-                ])
-            }
-        ];
-        testCases.forEach(function(testCase) {
-            expect(stripZeros(testCase.value)).toStrictEqual(testCase.expected);
-        });
-    });
-    it("should match expected result - empty array", function() {
-        var testCases = [
-            {
-                value: [],
-                expected: new Uint8Array([])
-            },
-            {
-                value: "0x",
-                expected: new Uint8Array([])
-            }
-        ];
-        testCases.forEach(function(testCase) {
-            expect(stripZeros(testCase.value)).toStrictEqual(testCase.expected);
-        });
-    });
-});

package/dist/cjs/utils/tests/bytes/zero-pad.test.js

@@ -1,144 +0,0 @@
-import { zeroPad } from "../../bytes";
-describe("utils.zeroPad", function() {
-    it("should match expected result - hex string", function() {
-        var testCases = [
-            {
-                value: [
-                    "0x9347",
-                    10
-                ],
-                expected: new Uint8Array([
-                    0,
-                    0,
-                    0,
-                    0,
-                    0,
-                    0,
-                    0,
-                    0,
-                    147,
-                    71
-                ])
-            },
-            {
-                value: [
-                    "0x185754",
-                    5
-                ],
-                expected: new Uint8Array([
-                    0,
-                    0,
-                    24,
-                    87,
-                    84
-                ])
-            },
-            {
-                value: [
-                    "0x00005823",
-                    7
-                ],
-                expected: new Uint8Array([
-                    0,
-                    0,
-                    0,
-                    0,
-                    0,
-                    88,
-                    35
-                ])
-            }
-        ];
-        testCases.forEach(function(testCase) {
-            expect(zeroPad(testCase.value[0], testCase.value[1])).toStrictEqual(testCase.expected);
-        });
-    });
-    it("should match expected result - UInt8Array", function() {
-        var testCases = [
-            {
-                value: [
-                    [
-                        9,
-                        58,
-                        29,
-                        24
-                    ],
-                    5
-                ],
-                expected: new Uint8Array([
-                    0,
-                    9,
-                    58,
-                    29,
-                    24
-                ])
-            },
-            {
-                value: [
-                    [
-                        185,
-                        203
-                    ],
-                    4
-                ],
-                expected: new Uint8Array([
-                    0,
-                    0,
-                    185,
-                    203
-                ])
-            },
-            {
-                value: [
-                    [
-                        239,
-                        30,
-                        49,
-                        41,
-                        5,
-                        10,
-                        42
-                    ],
-                    10
-                ],
-                expected: new Uint8Array([
-                    0,
-                    0,
-                    0,
-                    239,
-                    30,
-                    49,
-                    41,
-                    5,
-                    10,
-                    42
-                ])
-            }
-        ];
-        testCases.forEach(function(testCase) {
-            expect(zeroPad(testCase.value[0], testCase.value[1])).toStrictEqual(testCase.expected);
-        });
-    });
-    it("should throw error - value out of range", function() {
-        var values = [
-            [
-                [
-                    9,
-                    58,
-                    29,
-                    24
-                ],
-                3
-            ],
-            [
-                "0x185754",
-                1
-            ]
-        ];
-        values.forEach(function(value) {
-            expect(function() {
-                return zeroPad(value[0], value[1]);
-            }).toThrow("value out of range");
-        });
-    });
-});

package/dist/cjs/utils/tests/compute-address.test.js

@@ -1,49 +0,0 @@
-import { computeAddress } from "../../index";
-describe("computeAddress", function() {
-    it("should compute correct address - public key", function() {
-        var testCases = [
-            {
-                key: "0x04aaa2abcf8d119ad68b2c190abf34355a0029197911e2446007d5b44e6fddfd54352326fedac51eca491d59937c592ecffff65c6941037babbe26edfdbb32a688",
-                expected: "0xeC46DEeFE5e342801A5ab221471B0f934bd04404"
-            },
-            {
-                key: "0x04e8aa3d196e3a785fb5b431265074c01f571a79231e0cc0fc28e67d9c648471aca8229cafcc6cd806cd1a679f538326577bf9485c68f7a1c90b5116b669f30473",
-                expected: "0xb17351DB661e7D40723B1ADA46B43586F2358b7A"
-            },
-            {
-                key: "0x04110dfa471c3f04a6c9dfd857705eb080542c9672cf0f30d95f5fca382181293d6e91320916dd649d03c76818af8e7ee173781888e42e2f00bda9a8f797e0fd61",
-                expected: "0x93a76f1B186A97A3EBd0E1f94Ec52a82FfFD646B"
-            },
-            {
-                key: "0x04593bea29e692123fda1b6f8280b8414524c7838fd448abe6dd1e072bee5e2e9c66e19976b9310ce514d8612c5736201ddc3bb966412076cd4b24e7f649e779b3",
-                expected: "0x9eb71738aaf20F659156535b13df2b809FC8aB26"
-            }
-        ];
-        testCases.forEach(function(testCase) {
-            expect(computeAddress(testCase.key)).toBe(testCase.expected);
-        });
-    });
-    it("should compute correct address - private key", function() {
-        var testCases = [
-            {
-                key: "0x8da4ef21b864d2cc526dbdb2a120bd2874c36c9d0a1fb7f8c63d7f7a8b41de8f",
-                expected: "0x63FaC9201494f0bd17B9892B9fae4d52fe3BD377"
-            },
-            {
-                key: "0x42e12f76412f53de9d60df199a368699b6ec15d3798efb0b2a45b8c1b4f902a6",
-                expected: "0xE21C7F8e28058931C5aa0e36C42d0C40Daf7A698"
-            },
-            {
-                key: "0x262f8fffb353d3e11be770dd4208dcab1fa5c205d574a78088829f45b1ac2487",
-                expected: "0xE17826AC425D19b0531F4B99a243b9Cfb42219dd"
-            },
-            {
-                key: "0x1bcfb8b7a46e2f886ef61f8010426f70ce3c7fc1362973aa26d30b8f77711d93",
-                expected: "0xb17351DB661e7D40723B1ADA46B43586F2358b7A"
-            }
-        ];
-        testCases.forEach(function(testCase) {
-            expect(computeAddress(testCase.key)).toBe(testCase.expected);
-        });
-    });
-});

package/dist/cjs/utils/tests/compute-public-key.test.js

@@ -1,26 +0,0 @@
-import { computePublicKey } from "../../index";
-describe("computePublicKey", function() {
-    it("should compute correct public key", function() {
-        var testCases = [
-            {
-                privateKey: "0x8da4ef21b864d2cc526dbdb2a120bd2874c36c9d0a1fb7f8c63d7f7a8b41de8f",
-                expectedPublicKey: "0x04d11e94912283d217fd98be5ad59c659aede69bbef0e72a2213edf0fbd8de3cc95030d006b137e22b89e738e5565766b83d12c438fe970e3e729532fcfafad2a7"
-            },
-            {
-                privateKey: "0x38a3159d73cefd392d0176c29b3cc60ff43e81813f5ab5782571511df9bb16e2",
-                expectedPublicKey: "0x04d8c5ec2308fdec8535411b8f7eb0251b53f53bcdda3f49bc7959a5dc1e12d2fe721bdd212b20fdbfa770c56af2da1bcf3b77dd46d742b65154c80aac7d44adf1"
-            },
-            {
-                privateKey: "0xb6d36857e1f9b68e413d2496bb588f3650cdcc2398b3941963c44db8108b8671",
-                expectedPublicKey: "0x04dab3b4d14577ec72a25c5b4dc7b404052263ccde860bff23b8e68efa215de0f119ed4540cd230d5c84d8a13a8c2105aefba78f342a423893489ae69c3c8a8cfb"
-            },
-            {
-                privateKey: "0xf237d9763445d41150f9a199ad93ad478dff29ad8fe6fa00149ed12f40f8eb6f",
-                expectedPublicKey: "0x042b9627d5b5e187bcc9e4155c65f986091f76e379a9fe031a7f9797ec74ad70d399e3655e20d3c6b6ca63ef691fe558c1794d78199b697f28697cf44e150dcfb1"
-            }
-        ];
-        testCases.forEach(function(testCase) {
-            expect(computePublicKey(testCase.privateKey)).toBe(testCase.expectedPublicKey);
-        });
-    });
-});

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

@@ -1,26 +0,0 @@
-import Big from "big.js";
-import { etherToGwei, tinyBig } from "../../index";
-describe("gweiToEther", function() {
-    it("happy path", function() {
-        expect(etherToGwei("100.0").toString()).toBe("100000000000");
-        expect(etherToGwei(100.0).toString()).toBe("100000000000");
-        expect(etherToGwei("0.000000001").toNumber()).toBe(1);
-        expect(etherToGwei(0.000000001).toNumber()).toBe(1);
-        expect(etherToGwei(tinyBig(1000)).toNumber()).toBe(1000000000000);
-        expect(etherToGwei(Big(0.000000001)).toNumber()).toBe(1);
-    });
-    it("wrong types", function() {
-        expect(function() {
-            // @ts-expect-error should not accept boolean
-            etherToGwei(false);
-        }).toThrow();
-        expect(function() {
-            // @ts-expect-error should not accept array
-            etherToGwei([
-                1,
-                2,
-                3
-            ]);
-        }).toThrow();
-    });
-});

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

@@ -1,36 +0,0 @@
-import Big from "big.js";
-import { etherToWei, tinyBig } from "../../index";
-describe("ether-to-wei", function() {
-    it("happy path", function() {
-        expect(etherToWei("100").toString()).toBe("100000000000000000000");
-        expect(etherToWei(100).toString()).toBe("100000000000000000000");
-        expect(etherToWei("1000.0").toString()).toBe("1000000000000000000000");
-        expect(etherToWei(1000).toString()).toBe("1000000000000000000000");
-        expect(etherToWei("1000.0").toNumber()).toBe(1000000000000000000000);
-        expect(etherToWei(tinyBig(1000)).toString()).toBe("1000000000000000000000");
-        expect(etherToWei(tinyBig("1000.0")).toNumber()).toBe(1000000000000000000000);
-        expect(etherToWei(Big(1000)).toString()).toBe("1000000000000000000000");
-        expect(etherToWei(Big("1000.0")).toNumber()).toBe(1000000000000000000000);
-    });
-    it("matches expected toString", function() {
-        expect(etherToWei("-09999.0").toString()).toBe("-9999000000000000000000");
-    });
-    it("matches expected toNumber", function() {
-        /* easy */ expect(etherToWei("9").toNumber()).toBe(9000000000000000000);
-        /* harder */ expect(etherToWei("-0999999.90").toNumber()).toStrictEqual(-9.999999e23);
-    });
-    it("should throw for wrong types", function() {
-        expect(function() {
-            // @ts-expect-error should not accept boolean
-            etherToWei(false);
-        }).toThrow();
-        expect(function() {
-            // @ts-expect-error should not accept array
-            etherToWei([
-                1,
-                2,
-                3
-            ]);
-        }).toThrow();
-    });
-});

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

@@ -1,28 +0,0 @@
-import Big from "big.js";
-import { gweiToEther, tinyBig } from "../../index";
-describe("gweiToEther", function() {
-    it("happy path", function() {
-        expect(gweiToEther("100000000000.0").toString()).toBe("100");
-        expect(gweiToEther(100000000000.0).toString()).toBe("100");
-        expect(gweiToEther("1000000000000.0").toNumber()).toBe(1000);
-        expect(gweiToEther(1000000000000.0).toNumber()).toBe(1000);
-        expect(gweiToEther(tinyBig("1000000000000.0")).toNumber()).toBe(1000);
-        expect(gweiToEther(tinyBig(1000000000000.0)).toNumber()).toBe(1000);
-        expect(gweiToEther(Big("1000000000000.0")).toNumber()).toBe(1000);
-        expect(gweiToEther(Big(1000000000000.0)).toNumber()).toBe(1000);
-    });
-    it("wrong types", function() {
-        expect(function() {
-            // @ts-expect-error should not accept boolean
-            gweiToEther(false);
-        }).toThrow();
-        expect(function() {
-            // @ts-expect-error should not accept array
-            gweiToEther([
-                1,
-                2,
-                3
-            ]);
-        }).toThrow();
-    });
-});

package/dist/cjs/utils/tests/hash-message.test.js

@@ -1,32 +0,0 @@
-import { hashMessage } from "../../index";
-describe("utils.hashMessage", function() {
-    it("should compute correct hash", function() {
-        var testCases = [
-            {
-                message: "0xD1220A0cf47c7B9Be7A2E6BA89F429762e7b9aDb",
-                expectedHash: "0x053af31bc24e13e344973ab25910ff8da04a8acdd63a04187f84b7a340e9d663"
-            },
-            {
-                message: "27b1fdb04752bbc536007a920d24acb045561c26",
-                expectedHash: "0xd8141e0ec15afbf98a6f93d51e1b8bb8d988be77bca76a5692b73493d232f4f1"
-            },
-            {
-                message: [
-                    1,
-                    2
-                ],
-                expectedHash: "0xd87309a295607439d67ad5243462242d36775fa665de60f4e26895808e01389b"
-            },
-            {
-                message: [
-                    0x1,
-                    0x2
-                ],
-                expectedHash: "0xd87309a295607439d67ad5243462242d36775fa665de60f4e26895808e01389b"
-            }
-        ];
-        testCases.forEach(function(testCase) {
-            expect(hashMessage(testCase.message)).toBe(testCase.expectedHash);
-        });
-    });
-});

package/dist/cjs/utils/tests/is-address.test.js

@@ -1,48 +0,0 @@
-import { isAddress } from "../../index";
-describe("is-address", function() {
-    it("should validate real addresses", function() {
-        var addresses = [
-            "0x52908400098527886E0F7030069857D2E4169EE7",
-            "0x8617E340B3D01FA5F11F306F4090FD50E238070D",
-            "0xde709f2102306220921060314715629080e2fb77",
-            "0x27b1fdb04752bbc536007a920d24acb045561c26",
-            "0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed",
-            "0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359",
-            "0xdbF03B407c01E7cD3CBea99509d93f8DDDC8C6FB",
-            "0xD1220A0cf47c7B9Be7A2E6BA89F429762e7b9aDb",
-            "27b1fdb04752bbc536007a920d24acb045561c26" /* leading "0x" is not required */ 
-        ];
-        addresses.forEach(function(address) {
-            expect(isAddress(address)).toBe(true);
-        });
-    });
-    it("should return false on invalid addresses", function() {
-        var addresses = [
-            "0x5290840009852",
-            "0x8617E340b3D01FA5F11F306F4090FD50E238070D",
-            "0x8617e340b3d01FA5F11F306F4090FD50E238070D" /* invalid checksum */ ,
-            " 0xde709f2102306220921060314715629080e2fb77",
-            "dawsbot.eth" /* ens invalid */ ,
-            "",
-            "xyz",
-            "0x123"
-        ];
-        addresses.forEach(function(address) {
-            expect(isAddress(address)).toBe(false);
-        });
-    });
-    it("invalid type inputs", function() {
-        expect(function() {
-            // @ts-expect-error should not accept boolean
-            isAddress(false);
-        }).toThrow("string required. Received boolean");
-        expect(function() {
-            // @ts-expect-error should not accept array
-            isAddress([
-                1,
-                2,
-                3
-            ]);
-        }).toThrow("string required. Received object");
-    });
-});

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

@@ -1,121 +0,0 @@
-import { keccak256 } from "./../keccak256";
-import { toUtf8Bytes } from "./../to-utf8-bytes";
-/**
- *
- * @param inputs
- * @param expected
- */ function testKeccak256(inputs, expected) {
-    inputs.forEach(function(input, index) {
-        expect(keccak256(input)).toBe(expected[index]);
-    });
-}
-describe("keccak256", function() {
-    it("should match expected - hex strings", function() {
-        var inputs = [
-            "0x4d7F1790644Af787933c9fF0e2cff9a9B4299Abb",
-            "0xB5503a7db1A9105cd459D99153e69a76a8EF1530",
-            "0xaa0fc255b079e775f9307e5cfec472a555cebc3a"
-        ];
-        var expected = [
-            "0x72fe4a1287bb827ec8d04e045f7559955a8e694063af513008f111670674178a",
-            "0x012d02a94561e140985a0382377e7676eec97a73007e188ffd1d0a0c01b1eb4d",
-            "0xfe9ee1df3c10848ed968a46ced4a0bb9674195ece0cfc63959d8058d77700d84"
-        ];
-        testKeccak256(inputs, expected);
-    });
-    it("should match expected - bytes", function() {
-        var inputs = [
-            [
-                2,
-                182,
-                145
-            ],
-            [
-                0,
-                16,
-                255
-            ],
-            [
-                0x12,
-                0x34
-            ],
-            [
-                0x12
-            ]
-        ];
-        var expected = [
-            "0x324544acf03f9c2ac85ab3a820ab3371bf7965a342bcdd5f74e28eb6d1f60050",
-            "0xfe10bfcde301e8b760615ba65ba2a0c7fb72f9bcdea7c45841ef7b355a443e51",
-            "0x56570de287d73cd1cb6092bb8fdee6173974955fdef345ae579ee9f475ea7432",
-            "0x5fa2358263196dbbf23d1ca7a509451f7a2f64c15837bfbb81298b1e3e24e4fa"
-        ];
-        testKeccak256(inputs, expected);
-    });
-    it("should match expected - numbers", function() {
-        var inputs = [
-            23874234,
-            123346,
-            12395712
-        ].map(function(n) {
-            return toUtf8Bytes(n.toString());
-        });
-        var expected = [
-            "0x6cc5c464579b7e93f9e3192ecad21e933e5497d24a067546a264874a1cdbe48d",
-            "0xf54c8ff9e4afcd296f686a15dda3b8f9f2da621866842b2427ab578e0aaa7344",
-            "0xd9ba3a9f9b521946abbae91c3799ac03a3ec95d2a69a5ab5974242d36e3c6f32"
-        ];
-        testKeccak256(inputs, expected);
-    });
-    it("should match expected  - strings", function() {
-        var inputs = [
-            "essential-eth",
-            "firstText",
-            "secondString",
-            "example1",
-            "2934823",
-            "true"
-        ].map(toUtf8Bytes);
-        var expected = [
-            "0xd5b027dc2bddae7475604f19ca210363f0a3c63a32d79c2fff540b9c21249f2c",
-            "0x3b0c4ce69832f4f4036e87bf56b9062018040b5b0f031062bd9667fb579c844f",
-            "0x2f33a7c2165d73854f66613815214ba5812046579723927d001cabe696078ae7",
-            "0xf5590342e9e60df9335478edb075a7c323b2e11d690d18d35eaa32f13e48788d",
-            "0x0517ce0ae90a6a7f7f4770d867e1fc57e38e7f1d133942fdbcbabe53c98d3761",
-            "0x6273151f959616268004b58dbb21e5c851b7b8d04498b4aabee12291d22fc034"
-        ];
-        testKeccak256(inputs, expected);
-    });
-// it('should match ethers.js bytes (dynamic size) & BytesLike', () => {
-//   const inputs = [
-//     [115, 101, 99, 114, 101, 116],
-//     ['0x62797465734c696b65'],
-//     '0x657373656e7469616c2d657468',
-//     [115, 109, 97, 108, 108, 101, 115, 116],
-//   ];
-//   testKeccak256(inputs);
-// });
-// it('should match ethers.js bytes (static size)', () => {
-//   const 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],
-//       ],
-//     },
-//   ];
-//   testKeccak256(inputs);
-// });
-// it('should match ethers.js (signed and unsigned) integers', () => {
-//   const inputs = [
-//     { types: ['int16'], values: [-1] },
-//     { types: ['uint48'], values: [12] },
-//     { types: ['int16', 'uint48'], values: [-1, 12] },
-//   ];
-//   testKeccak256(inputs);
-// });
-});