essential-eth 0.8.0 → 0.9.1-next.0

package/dist/cjs/utils/tests/bytes/hexlify.test.js

@@ -1,40 +1,55 @@
-import { utils as ethers } from "ethers";
 import { hexlify } from "../../bytes";
 describe("utils.hexlify", function() {
-    it("numbers - matches ethers strings", function() {
-        var decimalValues = [
-            0,
-            4,
-            5,
-            16,
-            BigInt(0),
-            BigInt(16)
+    it("matches expected strings - numbers", function() {
+        var testCases = [
+            {
+                value: 0,
+                expected: "0x00"
+            },
+            {
+                value: 4,
+                expected: "0x04"
+            },
+            {
+                value: 5,
+                expected: "0x05"
+            },
+            {
+                value: 16,
+                expected: "0x10"
+            },
+            {
+                value: BigInt(0),
+                expected: "0x00"
+            },
+            {
+                value: BigInt(16),
+                expected: "0x10"
+            }
         ];
-        decimalValues.forEach(function(decimalValue) {
-            expect(hexlify(decimalValue)).toBe(ethers.hexlify(decimalValue));
+        testCases.forEach(function(testCase) {
+            expect(hexlify(testCase.value)).toBe(testCase.expected);
         });
-        var opts = {
-            allowMissingPrefix: true
-        };
-        expect(hexlify("22", opts)).toBe(ethers.hexlify("22", opts));
     });
-    it("should match ethers.js - hexPad options", function() {
-        var values = [
-            [
-                "0x3342e95",
-                {
+    it("should hexlify with options - hexPad", function() {
+        var testCases = [
+            {
+                value: "0x3342e95",
+                options: {
                     hexPad: "left"
-                }
-            ],
-            [
-                "0x41c942c42",
-                {
+                },
+                expected: "0x03342e95"
+            },
+            {
+                value: "0x41c942c42",
+                options: {
                     hexPad: "right"
-                }
-            ]
+                },
+                expected: "0x41c942c420"
+            }
         ];
-        values.forEach(function(value) {
-            expect(hexlify(value[0], value[1])).toBe(ethers.hexlify(value[0], value[1]));
+        testCases.forEach(function(testCase) {
+            expect(hexlify(testCase.value, testCase.options)).toBe(testCase.expected);
         });
     });
     it("should throw error - hex data is odd-length", function() {
@@ -49,6 +64,7 @@ describe("utils.hexlify", function() {
         });
     });
     it("should throw error - invalid hexlify value", function() {
+        // @ts-expect-error
         var values = [
             "non-hex string",
             false

package/dist/cjs/utils/tests/bytes/is-bytes-like.test.js

@@ -1,17 +1,16 @@
-import { utils as ethers } from "ethers";
 import { isBytesLike } from "../../bytes";
 describe("utils.isBytesLike", function() {
-    it("should match ethers.js - hex string", function() {
+    it("should return true - hex string", function() {
         var values = [
             "0x9347",
             "0x185754",
             "0x00005823"
         ];
         values.forEach(function(value) {
-            expect(isBytesLike(value)).toBe(ethers.isBytesLike(value));
+            expect(isBytesLike(value)).toBe(true);
         });
     });
-    it("should match ethers.js - UInt8Array", function() {
+    it("should return true - UInt8Array", function() {
         var values = [
             [
                 9,
@@ -34,36 +33,36 @@ describe("utils.isBytesLike", function() {
             ]
         ];
         values.forEach(function(value) {
-            expect(isBytesLike(value)).toBe(ethers.isBytesLike(value));
+            expect(isBytesLike(value)).toBe(true);
         });
     });
-    it("should match ethers.js - number", function() {
+    it("should return false - number", function() {
         var values = [
             152,
             513,
             2354
         ];
         values.forEach(function(value) {
-            expect(isBytesLike(value)).toBe(ethers.isBytesLike(value));
+            expect(isBytesLike(value)).toBe(false);
         });
     });
-    it("should match ethers.js - non-hex string", function() {
+    it("should return false - non-hex string", function() {
         var values = [
             "essential-eth",
             "ethers.js",
             "ethereum"
         ];
         values.forEach(function(value) {
-            expect(isBytesLike(value)).toBe(ethers.isBytesLike(value));
+            expect(isBytesLike(value)).toBe(false);
         });
     });
-    it("should match ethers.js - boolean", function() {
+    it("should return false - boolean", function() {
         var values = [
             false,
             true
         ];
         values.forEach(function(value) {
-            expect(isBytesLike(value)).toBe(ethers.isBytesLike(value));
+            expect(isBytesLike(value)).toBe(false);
         });
     });
 });

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

@@ -1,33 +1,76 @@
-import * as ethers from "ethers";
 import { isBytes, isBytesLike } from "../../..";
 describe("isBytesLike", function() {
-    it("matches ethers", function() {
-        var inputs = [
-            [
-                "1",
-                "2",
-                "3"
-            ],
-            [
-                1,
-                2,
-                3
-            ],
-            "0x123",
-            123,
-            0x123,
-            "bad",
-            false,
-            {
-                test: "bad"
-            },
-            null,
-            new Uint8Array(),
-            new Uint8Array(1)
+    it("matches expected", function() {
+        var testCases = [
+            {
+                value: [
+                    "1",
+                    "2",
+                    "3"
+                ],
+                isBytesLike: false,
+                isBytes: false
+            },
+            {
+                value: [
+                    1,
+                    2,
+                    3
+                ],
+                isBytesLike: true,
+                isBytes: true
+            },
+            {
+                value: "0x123",
+                isBytesLike: false,
+                isBytes: false
+            },
+            {
+                value: 123,
+                isBytesLike: false,
+                isBytes: false
+            },
+            {
+                value: 0x123,
+                isBytesLike: false,
+                isBytes: false
+            },
+            {
+                value: "bad",
+                isBytesLike: false,
+                isBytes: false
+            },
+            {
+                value: false,
+                isBytesLike: false,
+                isBytes: false
+            },
+            {
+                value: {
+                    test: "bad"
+                },
+                isBytesLike: false,
+                isBytes: false
+            },
+            {
+                value: null,
+                isBytesLike: false,
+                isBytes: false
+            },
+            {
+                value: new Uint8Array(),
+                isBytesLike: true,
+                isBytes: true
+            },
+            {
+                value: new Uint8Array(1),
+                isBytesLike: true,
+                isBytes: true
+            }
         ];
-        inputs.forEach(function(input) {
-            expect(isBytesLike(input)).toBe(ethers.utils.isBytesLike(input));
-            expect(isBytes(input)).toBe(ethers.utils.isBytes(input));
+        testCases.forEach(function(testCase) {
+            expect(isBytesLike(testCase.value)).toBe(testCase.isBytesLike);
+            expect(isBytes(testCase.value)).toBe(testCase.isBytes);
         });
     });
 });

package/dist/cjs/utils/tests/bytes/is-hex-string.test.js

@@ -1,36 +1,45 @@
-import { utils as ethers } from "ethers";
 import { isHexString } from "../../bytes";
 describe("utils.isHexString", function() {
-    it("should match ethers.js - hex string", function() {
+    it("should return true - hex string", function() {
         var values = [
             "0x9347",
             "0x185754",
             "0x00005823"
         ];
         values.forEach(function(value) {
-            expect(isHexString(value)).toBe(ethers.isHexString(value));
+            expect(isHexString(value)).toBe(true);
         });
     });
-    it("should match ethers.js - hex string of specific length", function() {
-        var values = [
-            [
-                "0x9347",
-                2
-            ],
-            [
-                "0x185754",
-                5
-            ],
-            [
-                "0x00005823",
-                4
-            ]
+    it("should match expected result- hex string of specific length", function() {
+        var testCases = [
+            {
+                value: [
+                    "0x9347",
+                    2
+                ],
+                expected: true
+            },
+            // False because '0x185754' is 3 bytes long, not 5.
+            {
+                value: [
+                    "0x185754",
+                    5
+                ],
+                expected: false
+            },
+            {
+                value: [
+                    "0x00005823",
+                    4
+                ],
+                expected: true
+            }
         ];
-        values.forEach(function(value) {
-            expect(isHexString(value[0], value[1])).toBe(ethers.isHexString(value[0], value[1]));
+        testCases.forEach(function(testCase) {
+            expect(isHexString(testCase.value[0], testCase.value[1])).toBe(testCase.expected);
         });
     });
-    it("should match ethers.js - UInt8Array", function() {
+    it("should return false - UInt8Array", function() {
         var values = [
             [
                 9,
@@ -53,36 +62,36 @@ describe("utils.isHexString", function() {
             ]
         ];
         values.forEach(function(value) {
-            expect(isHexString(value)).toBe(ethers.isHexString(value));
+            expect(isHexString(value)).toBe(false);
         });
     });
-    it("should match ethers.js - number", function() {
+    it("should return false - number", function() {
         var values = [
             152,
             513,
             2354
         ];
         values.forEach(function(value) {
-            expect(isHexString(value)).toBe(ethers.isHexString(value));
+            expect(isHexString(value)).toBe(false);
         });
     });
-    it("should match ethers.js - non-hex string", function() {
+    it("should return false - non-hex string", function() {
         var values = [
             "essential-eth",
             "ethers.js",
-            "ethereum"
+            "\uD83D\uDC4B firek.eth was here hehe"
         ];
         values.forEach(function(value) {
-            expect(isHexString(value)).toBe(ethers.isHexString(value));
+            expect(isHexString(value)).toBe(false);
         });
     });
-    it("should match ethers.js - boolean", function() {
+    it("should return false - boolean", function() {
         var values = [
             false,
             true
         ];
         values.forEach(function(value) {
-            expect(isHexString(value)).toBe(ethers.isHexString(value));
+            expect(isHexString(value)).toBe(false);
         });
     });
 });

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

@@ -1,57 +1,106 @@
-import { utils as ethers } from "ethers";
 import { stripZeros } from "../../bytes";
 describe("utils.stripZeros", function() {
-    it("should match ethers.js - hex string", function() {
-        var values = [
-            "0x00009347",
-            "0x00185754",
-            "0x00000000005823"
+    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
+                ])
+            }
         ];
-        values.forEach(function(value) {
-            expect(stripZeros(value)).toStrictEqual(ethers.stripZeros(value));
+        testCases.forEach(function(testCase) {
+            expect(stripZeros(testCase.value)).toStrictEqual(testCase.expected);
         });
     });
-    it("should match ethers.js - UInt8Array", function() {
-        var values = [
-            [
-                0,
-                0,
-                0,
-                9,
-                58,
-                29,
-                24
-            ],
-            [
-                0,
-                185,
-                203
-            ],
-            [
-                0,
-                0,
-                0,
-                0,
-                239,
-                30,
-                49,
-                41,
-                5,
-                10,
-                42
-            ]
+    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
+                ])
+            }
         ];
-        values.forEach(function(value) {
-            expect(stripZeros(value)).toStrictEqual(ethers.stripZeros(value));
+        testCases.forEach(function(testCase) {
+            expect(stripZeros(testCase.value)).toStrictEqual(testCase.expected);
         });
     });
-    it("should match ethers.js - empty array", function() {
-        var values = [
-            [],
-            "0x"
+    it("should match expected result - empty array", function() {
+        var testCases = [
+            {
+                value: [],
+                expected: new Uint8Array([])
+            },
+            {
+                value: "0x",
+                expected: new Uint8Array([])
+            }
         ];
-        values.forEach(function(value) {
-            expect(stripZeros(value)).toStrictEqual(ethers.stripZeros(value));
+        testCases.forEach(function(testCase) {
+            expect(stripZeros(testCase.value)).toStrictEqual(testCase.expected);
         });
     });
 });

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

@@ -1,45 +1,110 @@
-import { utils as ethers } from "ethers";
 import { zeroPad } from "../../bytes";
 describe("utils.zeroPad", function() {
-    it("should match ethers.js - hex string", function() {
-        var values = [
-            [
-                "0x9347",
-                10
-            ],
-            [
-                "0x185754",
-                5
-            ],
-            [
-                "0x00005823",
-                7
-            ]
+    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
+                ])
+            }
         ];
-        values.forEach(function(value) {
-            expect(zeroPad(value[0], value[1])).toStrictEqual(ethers.zeroPad(value[0], value[1]));
+        testCases.forEach(function(testCase) {
+            expect(zeroPad(testCase.value[0], testCase.value[1])).toStrictEqual(testCase.expected);
         });
     });
-    it("should match ethers.js - UInt8Array", function() {
-        var values = [
-            [
-                [
+    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
                 ],
-                5
-            ],
-            [
-                [
+                expected: new Uint8Array([
+                    0,
+                    0,
                     185,
                     203
+                ])
+            },
+            {
+                value: [
+                    [
+                        239,
+                        30,
+                        49,
+                        41,
+                        5,
+                        10,
+                        42
+                    ],
+                    10
                 ],
-                4
-            ],
-            [
-                [
+                expected: new Uint8Array([
+                    0,
+                    0,
+                    0,
                     239,
                     30,
                     49,
@@ -47,12 +112,11 @@ describe("utils.zeroPad", function() {
                     5,
                     10,
                     42
-                ],
-                10
-            ]
+                ])
+            }
         ];
-        values.forEach(function(value) {
-            expect(zeroPad(value[0], value[1])).toStrictEqual(ethers.zeroPad(value[0], value[1]));
+        testCases.forEach(function(testCase) {
+            expect(zeroPad(testCase.value[0], testCase.value[1])).toStrictEqual(testCase.expected);
         });
     });
     it("should throw error - value out of range", function() {