essential-eth 0.8.0 → 0.9.1-next.0

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

@@ -1,27 +1,49 @@
-import { utils } from "ethers";
 import { computeAddress } from "../../index";
-function testComputeAddress(keys) {
-    keys.forEach(function(key) {
-        expect(computeAddress(key)).toBe(utils.computeAddress(key));
-    });
-}
 describe("computeAddress", function() {
-    it("should match ethers.js - public key", function() {
-        var publicKeys = [
-            "0x04aaa2abcf8d119ad68b2c190abf34355a0029197911e2446007d5b44e6fddfd54352326fedac51eca491d59937c592ecffff65c6941037babbe26edfdbb32a688",
-            "0x04e8aa3d196e3a785fb5b431265074c01f571a79231e0cc0fc28e67d9c648471aca8229cafcc6cd806cd1a679f538326577bf9485c68f7a1c90b5116b669f30473",
-            "0x04110dfa471c3f04a6c9dfd857705eb080542c9672cf0f30d95f5fca382181293d6e91320916dd649d03c76818af8e7ee173781888e42e2f00bda9a8f797e0fd61",
-            "0x04593bea29e692123fda1b6f8280b8414524c7838fd448abe6dd1e072bee5e2e9c66e19976b9310ce514d8612c5736201ddc3bb966412076cd4b24e7f649e779b3"
+    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"
+            }
         ];
-        testComputeAddress(publicKeys);
+        testCases.forEach(function(testCase) {
+            expect(computeAddress(testCase.key)).toBe(testCase.expected);
+        });
     });
-    it("should match ethers.js - private key", function() {
-        var privateKeys = [
-            "0x8da4ef21b864d2cc526dbdb2a120bd2874c36c9d0a1fb7f8c63d7f7a8b41de8f",
-            "0x42e12f76412f53de9d60df199a368699b6ec15d3798efb0b2a45b8c1b4f902a6",
-            "0x262f8fffb353d3e11be770dd4208dcab1fa5c205d574a78088829f45b1ac2487",
-            "0x1bcfb8b7a46e2f886ef61f8010426f70ce3c7fc1362973aa26d30b8f77711d93"
+    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"
+            }
         ];
-        testComputeAddress(privateKeys);
+        testCases.forEach(function(testCase) {
+            expect(computeAddress(testCase.key)).toBe(testCase.expected);
+        });
     });
 });

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

@@ -1,15 +1,26 @@
-import { utils } from "ethers";
 import { computePublicKey } from "../../index";
 describe("computePublicKey", function() {
-    it("should match ethers.js", function() {
-        var privateKeys = [
-            "0x8da4ef21b864d2cc526dbdb2a120bd2874c36c9d0a1fb7f8c63d7f7a8b41de8f",
-            "0x38a3159d73cefd392d0176c29b3cc60ff43e81813f5ab5782571511df9bb16e2",
-            "0xb6d36857e1f9b68e413d2496bb588f3650cdcc2398b3941963c44db8108b8671",
-            "0xf237d9763445d41150f9a199ad93ad478dff29ad8fe6fa00149ed12f40f8eb6f"
+    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"
+            }
         ];
-        privateKeys.forEach(function(key) {
-            expect(computePublicKey(key)).toBe(utils.computePublicKey(key));
+        testCases.forEach(function(testCase) {
+            expect(computePublicKey(testCase.privateKey)).toBe(testCase.expectedPublicKey);
         });
     });
 });

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

@@ -1,8 +1,5 @@
 import Big from "big.js";
-import * as ethers from "ethers";
-import web3 from "web3";
 import { etherToWei, tinyBig } from "../../index";
-import { scientificStrToDecimalStr } from "../../shared/tiny-big/helpers";
 describe("ether-to-wei", function() {
     it("happy path", function() {
         expect(etherToWei("100").toString()).toBe("100000000000000000000");
@@ -15,17 +12,12 @@ describe("ether-to-wei", function() {
         expect(etherToWei(Big(1000)).toString()).toBe("1000000000000000000000");
         expect(etherToWei(Big("1000.0")).toNumber()).toBe(1000000000000000000000);
     });
-    it("matches ethers and web3 toString", function() {
-        expect(etherToWei("-09999.0").toString()).toStrictEqual(ethers.utils.parseEther("-09999.0").toString());
-        expect(etherToWei("-09999.0").toString()).toStrictEqual(web3.utils.toWei("-09999.0", "ether"));
+    it("matches expected toString", function() {
+        expect(etherToWei("-09999.0").toString()).toBe("-9999000000000000000000");
     });
-    it("matches ethers and web3 toNumber", function() {
-        /* easy */ expect(etherToWei("9").toNumber()).toStrictEqual(Number(ethers.utils.parseEther("9")));
-        // web3 responds with scientific notation
-        expect(etherToWei("9").toNumber()).toStrictEqual(Number(web3.utils.toWei("9", "ether")));
-        /* harder */ expect(etherToWei("-0999999.90").toNumber()).toStrictEqual(Number(ethers.utils.parseEther("-0999999.90")));
-        // web3 responds with scientific notation
-        expect(etherToWei("-0999999.9").toNumber()).toStrictEqual(Number(scientificStrToDecimalStr(web3.utils.toWei("-0999999.9", "ether"))));
+    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() {

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

@@ -1,21 +1,32 @@
-import { utils } from "ethers";
 import { hashMessage } from "../../index";
 describe("utils.hashMessage", function() {
-    it("should match ethers.js", function() {
-        var messages = [
-            "0xD1220A0cf47c7B9Be7A2E6BA89F429762e7b9aDb",
-            "27b1fdb04752bbc536007a920d24acb045561c26" /* leading "0x" is not required */ ,
-            [
-                1,
-                2
-            ],
-            [
-                0x1,
-                0x2
-            ]
+    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"
+            }
         ];
-        messages.forEach(function(message) {
-            expect(hashMessage(message)).toStrictEqual(utils.hashMessage(message));
+        testCases.forEach(function(testCase) {
+            expect(hashMessage(testCase.message)).toBe(testCase.expectedHash);
         });
     });
 });

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

@@ -1,5 +1,3 @@
-import { utils } from "ethers";
-import web3 from "web3";
 import { isAddress } from "../../index";
 describe("is-address", function() {
     it("should validate real addresses", function() {
@@ -15,8 +13,7 @@ describe("is-address", function() {
             "27b1fdb04752bbc536007a920d24acb045561c26" /* leading "0x" is not required */ 
         ];
         addresses.forEach(function(address) {
-            expect(isAddress(address)).toStrictEqual(utils.isAddress(address));
-            expect(isAddress(address)).toStrictEqual(web3.utils.isAddress(address));
+            expect(isAddress(address)).toBe(true);
         });
     });
     it("should return false on invalid addresses", function() {
@@ -31,11 +28,7 @@ describe("is-address", function() {
             "0x123"
         ];
         addresses.forEach(function(address) {
-            var essentialEthIsAddress = isAddress(address);
-            var ethersIsAddress = utils.isAddress(address);
-            var web3IsAddress = web3.utils.isAddress(address);
-            expect(essentialEthIsAddress).toStrictEqual(ethersIsAddress);
-            expect(essentialEthIsAddress).toStrictEqual(web3IsAddress);
+            expect(isAddress(address)).toBe(false);
         });
     });
     it("invalid type inputs", function() {

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

@@ -1,24 +1,29 @@
-import { utils } from "ethers";
 import { keccak256 } from "./../keccak256";
 import { toUtf8Bytes } from "./../to-utf8-bytes";
 /**
  *
  * @param inputs
- */ function testKeccak256(inputs) {
-    inputs.forEach(function(input) {
-        expect(keccak256(input)).toBe(utils.keccak256(input));
+ * @param expected
+ */ function testKeccak256(inputs, expected) {
+    inputs.forEach(function(input, index) {
+        expect(keccak256(input)).toBe(expected[index]);
     });
 }
 describe("keccak256", function() {
-    it("should match ethers.js hex strings", function() {
+    it("should match expected - hex strings", function() {
         var inputs = [
             "0x4d7F1790644Af787933c9fF0e2cff9a9B4299Abb",
             "0xB5503a7db1A9105cd459D99153e69a76a8EF1530",
             "0xaa0fc255b079e775f9307e5cfec472a555cebc3a"
         ];
-        testKeccak256(inputs);
+        var expected = [
+            "0x72fe4a1287bb827ec8d04e045f7559955a8e694063af513008f111670674178a",
+            "0x012d02a94561e140985a0382377e7676eec97a73007e188ffd1d0a0c01b1eb4d",
+            "0xfe9ee1df3c10848ed968a46ced4a0bb9674195ece0cfc63959d8058d77700d84"
+        ];
+        testKeccak256(inputs, expected);
     });
-    it("should match ethers.js bytes", function() {
+    it("should match expected - bytes", function() {
         var inputs = [
             [
                 2,
@@ -38,9 +43,15 @@ describe("keccak256", function() {
                 0x12
             ]
         ];
-        testKeccak256(inputs);
+        var expected = [
+            "0x324544acf03f9c2ac85ab3a820ab3371bf7965a342bcdd5f74e28eb6d1f60050",
+            "0xfe10bfcde301e8b760615ba65ba2a0c7fb72f9bcdea7c45841ef7b355a443e51",
+            "0x56570de287d73cd1cb6092bb8fdee6173974955fdef345ae579ee9f475ea7432",
+            "0x5fa2358263196dbbf23d1ca7a509451f7a2f64c15837bfbb81298b1e3e24e4fa"
+        ];
+        testKeccak256(inputs, expected);
     });
-    it("should match ethers.js numbers", function() {
+    it("should match expected - numbers", function() {
         var inputs = [
             23874234,
             123346,
@@ -48,9 +59,14 @@ describe("keccak256", function() {
         ].map(function(n) {
             return toUtf8Bytes(n.toString());
         });
-        testKeccak256(inputs);
+        var expected = [
+            "0x6cc5c464579b7e93f9e3192ecad21e933e5497d24a067546a264874a1cdbe48d",
+            "0xf54c8ff9e4afcd296f686a15dda3b8f9f2da621866842b2427ab578e0aaa7344",
+            "0xd9ba3a9f9b521946abbae91c3799ac03a3ec95d2a69a5ab5974242d36e3c6f32"
+        ];
+        testKeccak256(inputs, expected);
     });
-    it("should match ethers.js strings", function() {
+    it("should match expected  - strings", function() {
         var inputs = [
             "essential-eth",
             "firstText",
@@ -59,7 +75,15 @@ describe("keccak256", function() {
             "2934823",
             "true"
         ].map(toUtf8Bytes);
-        testKeccak256(inputs);
+        var expected = [
+            "0xd5b027dc2bddae7475604f19ca210363f0a3c63a32d79c2fff540b9c21249f2c",
+            "0x3b0c4ce69832f4f4036e87bf56b9062018040b5b0f031062bd9667fb579c844f",
+            "0x2f33a7c2165d73854f66613815214ba5812046579723927d001cabe696078ae7",
+            "0xf5590342e9e60df9335478edb075a7c323b2e11d690d18d35eaa32f13e48788d",
+            "0x0517ce0ae90a6a7f7f4770d867e1fc57e38e7f1d133942fdbcbabe53c98d3761",
+            "0x6273151f959616268004b58dbb21e5c851b7b8d04498b4aabee12291d22fc034"
+        ];
+        testKeccak256(inputs, expected);
     });
 // it('should match ethers.js bytes (dynamic size) & BytesLike', () => {
 //   const inputs = [

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

@@ -1,15 +1,14 @@
-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));
+        expect(solidityKeccak256(input.types, input.values)).toBe(input.expected);
     });
 }
 describe("solidityKeccak256", function() {
-    it("should match ethers.js addresses", function() {
+    it("should match expected hash - addresses", function() {
         var inputs = [
             {
                 types: [
@@ -17,7 +16,8 @@ describe("solidityKeccak256", function() {
                 ],
                 values: [
                     "0x4d7F1790644Af787933c9fF0e2cff9a9B4299Abb"
-                ]
+                ],
+                expected: "0x72fe4a1287bb827ec8d04e045f7559955a8e694063af513008f111670674178a"
             },
             {
                 types: [
@@ -27,12 +27,13 @@ describe("solidityKeccak256", function() {
                 values: [
                     "0xB5503a7db1A9105cd459D99153e69a76a8EF1530",
                     "0xaa0fc255b079e775f9307e5cfec472a555cebc3a"
-                ]
+                ],
+                expected: "0x36020dd625e805ec80eb7c7e36e5b69108500af4bb4913245a3d643d33466581"
             }
         ];
         testSolidityKeccak256(inputs);
     });
-    it("should match ethers.js strings", function() {
+    it("should match expected hash - strings", function() {
         var inputs = [
             {
                 types: [
@@ -40,7 +41,8 @@ describe("solidityKeccak256", function() {
                 ],
                 values: [
                     "essential-eth"
-                ]
+                ],
+                expected: "0xd5b027dc2bddae7475604f19ca210363f0a3c63a32d79c2fff540b9c21249f2c"
             },
             {
                 types: [
@@ -50,7 +52,8 @@ describe("solidityKeccak256", function() {
                 values: [
                     "firstText",
                     "secondString"
-                ]
+                ],
+                expected: "0xf9b3d91668a0f53719a929eb38ac29b07896b3a33ef806cfbe5033bb5ce1e58b"
             },
             {
                 types: [
@@ -62,12 +65,13 @@ describe("solidityKeccak256", function() {
                     "example1",
                     "2934823",
                     "true"
-                ]
+                ],
+                expected: "0x731e3313bb527075d72c8a724eea170cdc200edf65c958d3014f666faf9a4d41"
             }
         ];
         testSolidityKeccak256(inputs);
     });
-    it("should match ethers.js bytes (dynamic size) & BytesLike", function() {
+    it("should match expected hash for bytes (dynamic size) & BytesLike", function() {
         var inputs = [
             {
                 types: [
@@ -82,7 +86,8 @@ describe("solidityKeccak256", function() {
                         101,
                         116
                     ]
-                ]
+                ],
+                expected: "0x65462b0520ef7d3df61b9992ed3bea0c56ead753be7c8b3614e0ce01e4cac41b"
             },
             {
                 types: [
@@ -90,7 +95,8 @@ describe("solidityKeccak256", function() {
                 ],
                 values: [
                     "0x62797465734c696b65"
-                ]
+                ],
+                expected: "0x89ddb668afdb92cd9027c2ecf8ef3f36f2a76d07f72db32f17be6ddd5552abfb"
             },
             {
                 types: [
@@ -109,12 +115,13 @@ describe("solidityKeccak256", function() {
                         115,
                         116
                     ]
-                ]
+                ],
+                expected: "0xb57d179e947e0bfe9813227c428eeea3558dc20e47a9fe64b9d9f29b9b5eeff0"
             }
         ];
         testSolidityKeccak256(inputs);
     });
-    it("should match ethers.js bytes (static size)", function() {
+    it("should match expected hash for bytes (static size)", function() {
         var inputs = [
             {
                 types: [
@@ -127,7 +134,8 @@ describe("solidityKeccak256", function() {
                         115,
                         116
                     ]
-                ]
+                ],
+                expected: "0x9c22ff5f21f0b81b113e63f7db6da94fedef11b2119b4088b89664fb9a3cb658"
             },
             {
                 types: [
@@ -170,12 +178,13 @@ describe("solidityKeccak256", function() {
                     [
                         33
                     ]
-                ]
+                ],
+                expected: "0xe44f351d6a5adfe8e8917ee07b7269e9fb019a97fba5eeab82899b02e3f15d1f"
             }
         ];
         testSolidityKeccak256(inputs);
     });
-    it('should match ethers.js booleans (specified as type "bool" to match solidity)', function() {
+    it('should match expected hash for booleans (specified as type "bool" to match solidity)', function() {
         var inputs = [
             {
                 types: [
@@ -183,7 +192,8 @@ describe("solidityKeccak256", function() {
                 ],
                 values: [
                     true
-                ]
+                ],
+                expected: "0x5fe7f977e71dba2ea1a68e21057beebb9be2ac30c6410aa38d4f3fbe41dcffd2"
             },
             {
                 types: [
@@ -193,12 +203,13 @@ describe("solidityKeccak256", function() {
                 values: [
                     false,
                     false
-                ]
+                ],
+                expected: "0x54a8c0ab653c15bfb48b47fd011ba2b9617af01cb45cab344acd57c924d56798"
             }
         ];
         testSolidityKeccak256(inputs);
     });
-    it("should match ethers.js (signed and unsigned) integers", function() {
+    it("should match expected hash for (signed and unsigned) integers", function() {
         var inputs = [
             {
                 types: [
@@ -206,7 +217,8 @@ describe("solidityKeccak256", function() {
                 ],
                 values: [
                     -1
-                ]
+                ],
+                expected: "0x06d41322d79dfed27126569cb9a80eb0967335bf2f3316359d2a93c779fcd38a"
             },
             {
                 types: [
@@ -214,7 +226,8 @@ describe("solidityKeccak256", function() {
                 ],
                 values: [
                     12
-                ]
+                ],
+                expected: "0x505be1cd98680abcc2473d7336b83f86f30185d233a18e7dbf9a0add7f7fb583"
             },
             {
                 types: [
@@ -224,28 +237,13 @@ describe("solidityKeccak256", function() {
                 values: [
                     -1,
                     12
-                ]
-            }
-        ];
-        testSolidityKeccak256(inputs);
-    });
-    it("should match ethers.js array parsing", function() {
-        var inputs = [
-            {
-                types: [
-                    "string[2]"
                 ],
-                values: [
-                    [
-                        "some-text",
-                        "additional-text"
-                    ]
-                ]
+                expected: "0x81da7abb5c9c7515f57dab2fc946f01217ab52f3bd8958bc36bd55894451a93c"
             }
         ];
         testSolidityKeccak256(inputs);
     });
-    it("should match ethers.js when passing different types into the same solidityKeccak256 function call", function() {
+    it("should match expected hash when passing different types into the same solidityKeccak256 function call", function() {
         var inputs = [
             {
                 types: [
@@ -257,7 +255,8 @@ describe("solidityKeccak256", function() {
                     -5,
                     "essential-eth",
                     true
-                ]
+                ],
+                expected: "0xa7bbaa8154fe7d3d9a9d813fa435b386fd75dc57d02b620baafc04074658c454"
             },
             {
                 types: [
@@ -274,7 +273,8 @@ describe("solidityKeccak256", function() {
                         115,
                         116
                     ]
-                ]
+                ],
+                expected: "0x6e4e133a4879decc8bf952c54092cb965ba979f38d5e6fb62d47e6bdd7ea390c"
             },
             {
                 types: [
@@ -302,7 +302,8 @@ describe("solidityKeccak256", function() {
                         false,
                         true
                     ]
-                ]
+                ],
+                expected: "0xb66a5a976e76e7f2d8b2d5baff670f9937c12b6c3484a9479075d9ecfc2700d2"
             }
         ];
         testSolidityKeccak256(inputs);

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

@@ -1,17 +1,38 @@
-import { utils } from "ethers";
 import { splitSignature } from "../split-signature";
 describe("splitSignature", function() {
-    it("should match ethers.js", function() {
-        var signatures = [
-            "0x60bc4ed91f2021aefe7045f3f77bd12f87eb733aee24bd1965343b3c27b3971647252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee331b",
-            "0x60bc4ed91f2021aefe7045f3f77bd12f87eb733aee24bd1965343b3c27b3971647252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33"
+    it("should match expected results", function() {
+        var testCases = [
+            {
+                signature: "0x60bc4ed91f2021aefe7045f3f77bd12f87eb733aee24bd1965343b3c27b3971647252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee331b",
+                expected: {
+                    _vs: "0x47252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33",
+                    compact: "0x60bc4ed91f2021aefe7045f3f77bd12f87eb733aee24bd1965343b3c27b3971647252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33",
+                    r: "0x60bc4ed91f2021aefe7045f3f77bd12f87eb733aee24bd1965343b3c27b39716",
+                    recoveryParam: 0,
+                    s: "0x47252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33",
+                    v: 27,
+                    yParityAndS: "0x47252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33"
+                }
+            },
+            {
+                signature: "0x60bc4ed91f2021aefe7045f3f77bd12f87eb733aee24bd1965343b3c27b3971647252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33",
+                expected: {
+                    _vs: "0x47252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33",
+                    compact: "0x60bc4ed91f2021aefe7045f3f77bd12f87eb733aee24bd1965343b3c27b3971647252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33",
+                    r: "0x60bc4ed91f2021aefe7045f3f77bd12f87eb733aee24bd1965343b3c27b39716",
+                    recoveryParam: 0,
+                    s: "0x47252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33",
+                    v: 27,
+                    yParityAndS: "0x47252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33"
+                }
+            }
         ];
-        signatures.forEach(function(signature) {
-            expect(splitSignature(signature)).toStrictEqual(utils.splitSignature(signature));
+        testCases.forEach(function(testCase) {
+            expect(splitSignature(testCase.signature)).toStrictEqual(testCase.expected);
         });
     });
     it("should throw error on invalid signature", function() {
-        var signature = "0x60bc4ed91f2021aefe7045f3f77bd12f87eb733aee24bd1965343b3c27b3971647252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33238423849234765127"; //invalid signature length
+        var signature = "0x60bc4ed91f2021aefe7045f3f77bd12f87eb733aee24bd1965343b3c27b3971647252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33238423849234765127";
         expect(function() {
             splitSignature(signature);
         }).toThrow("invalid signature string");

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

@@ -1,5 +1,3 @@
-import { utils } from "ethers";
-import web3 from "web3";
 import { toChecksumAddress } from "../../index";
 describe("ether-to-wei", function() {
     it("happy path", function() {
@@ -14,8 +12,7 @@ describe("ether-to-wei", function() {
             "0xD1220A0cf47c7B9Be7A2E6BA89F429762e7b9aDb"
         ];
         addresses.forEach(function(address) {
-            expect(toChecksumAddress(address)).toStrictEqual(utils.getAddress(address));
-            expect(toChecksumAddress(address)).toStrictEqual(web3.utils.toChecksumAddress(address));
+            expect(toChecksumAddress(address)).toStrictEqual(address);
         });
     });
     it("invalid inputs", function() {

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

@@ -1,14 +1,34 @@
-import { utils } from "ethers";
 import { toUtf8Bytes } from "../../index";
 describe("utils.toUtf8Bytes", function() {
-    it("should match ethers.js", function() {
-        var inputs = [
-            "0xa",
-            "1",
-            "false"
+    it("should correctly convert to UTF8 bytes", function() {
+        var testCases = [
+            {
+                input: "0xa",
+                expected: new Uint8Array([
+                    48,
+                    120,
+                    97
+                ])
+            },
+            {
+                input: "1",
+                expected: new Uint8Array([
+                    49
+                ])
+            },
+            {
+                input: "false",
+                expected: new Uint8Array([
+                    102,
+                    97,
+                    108,
+                    115,
+                    101
+                ])
+            }
         ];
-        inputs.forEach(function(input) {
-            expect(toUtf8Bytes(input)).toStrictEqual(utils.toUtf8Bytes(input));
+        testCases.forEach(function(testCase) {
+            expect(toUtf8Bytes(testCase.input)).toStrictEqual(testCase.expected);
         });
     });
 });