essential-eth 0.8.0 → 0.9.1-next.0

package/dist/cjs/utils/tests/bytes/hex-data-length.test.js

@@ -1,43 +1,60 @@
-import { utils as ethers } from "ethers";
 import { hexDataLength } from "../../bytes";
 describe("utils.hexDataLength", function() {
-    it("should match ethers.js - hex values", function() {
-        var values = [
-            "0x9347",
-            "0x185754",
-            "0x00005823"
+    it("should match expected value - hex values", function() {
+        var testCases = [
+            {
+                value: "0x9347",
+                expected: 2
+            },
+            {
+                value: "0x185754",
+                expected: 3
+            },
+            {
+                value: "0x00005823",
+                expected: 4
+            }
         ];
-        values.forEach(function(value) {
-            expect(hexDataLength(value)).toBe(ethers.hexDataLength(value));
+        testCases.forEach(function(testCase) {
+            expect(hexDataLength(testCase.value)).toStrictEqual(testCase.expected);
         });
     });
-    it("should match ethers.js - UInt8Array values", function() {
-        var values = [
-            [
-                9,
-                58,
-                29,
-                24
-            ],
-            [
-                185,
-                203
-            ],
-            [
-                239,
-                30,
-                49,
-                41,
-                5,
-                10,
-                42
-            ]
+    it("should match expected value - UInt8Array values", function() {
+        var testCases = [
+            {
+                value: new Uint8Array([
+                    9,
+                    58,
+                    29,
+                    24
+                ]),
+                expected: 4
+            },
+            {
+                value: new Uint8Array([
+                    185,
+                    203
+                ]),
+                expected: 2
+            },
+            {
+                value: new Uint8Array([
+                    239,
+                    30,
+                    49,
+                    41,
+                    5,
+                    10,
+                    42
+                ]),
+                expected: 7
+            }
         ];
-        values.forEach(function(value) {
-            expect(hexDataLength(value)).toBe(ethers.hexDataLength(value));
+        testCases.forEach(function(testCase) {
+            expect(hexDataLength(testCase.value)).toStrictEqual(testCase.expected);
         });
     });
-    it("should return null - not hex value or not divisible by 2", function() {
+    it("should return null  - non-hex values or hex values not divisible by 2", function() {
         var values = [
             "0x383",
             "non-hex string"

package/dist/cjs/utils/tests/bytes/hex-data-slice.test.js

@@ -1,26 +1,25 @@
-import { utils as ethers } from "ethers";
 import { hexDataSlice } from "../../bytes";
 describe("utils.hexDataSlice", function() {
-    it("numbers - matches ethers strings", function() {
-        var decimalValues = [
+    it("should match expected slice - hexadecimal strings", function() {
+        var hexValues = [
             "0x123456"
         ];
-        decimalValues.forEach(function(decimalValue) {
-            expect(hexDataSlice(decimalValue, 0, 2)).toStrictEqual(ethers.hexDataSlice(decimalValue, 0, 2));
+        hexValues.forEach(function(hexValue) {
+            expect(hexDataSlice(hexValue, 0, 2)).toBe("0x1234");
         });
     });
-    it("numbers - matches ethers hex numbers", function() {
-        var decimalValues = [
+    it("should match expected slice -  hexadecimal numbers", function() {
+        var hexValues = [
             0x1234567891011
         ];
-        decimalValues.forEach(function(decimalValue) {
-            expect(hexDataSlice(decimalValue, 3)).toStrictEqual(ethers.hexDataSlice(decimalValue, 3));
-            expect(hexDataSlice(decimalValue, 2, 4)).toStrictEqual(ethers.hexDataSlice(decimalValue, 2, 4));
-            expect(hexDataSlice(decimalValue, 100)).toStrictEqual(ethers.hexDataSlice(decimalValue, 100));
+        hexValues.forEach(function(hexValue) {
+            expect(hexDataSlice(hexValue, 3)).toBe("0x67891011");
+            expect(hexDataSlice(hexValue, 2, 4)).toBe("0x4567");
+            expect(hexDataSlice(hexValue, 100)).toBe("0x");
         });
     });
-    it("numbers - matches ethers decimals", function() {
-        var decimalValues = [
+    it("should match expected slice - arrays of decimal numbers", function() {
+        var decimalArrays = [
             [
                 0,
                 1,
@@ -34,11 +33,11 @@ describe("utils.hexDataSlice", function() {
                 9
             ]
         ];
-        decimalValues.forEach(function(decimalValue) {
-            expect(hexDataSlice(decimalValue, 1, 2)).toStrictEqual(ethers.hexDataSlice(decimalValue, 1, 2));
+        decimalArrays.forEach(function(decimalArray) {
+            expect(hexDataSlice(decimalArray, 1, 2)).toBe("0x01");
         });
     });
-    it("should throw error - invalid hexData", function() {
+    it("should throw error - invalid hex data", function() {
         var values = [
             "non-hex string",
             "0x938"

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

@@ -1,51 +1,68 @@
-import { utils as ethers } from "ethers";
 import { hexStripZeros } from "../../bytes";
 describe("utils.hexStripZeros", function() {
-    it("should match ethers.js - hex values", function() {
-        var values = [
-            "0x00009347",
-            "0x00185754",
-            "0x00000000005823"
+    it("should correctly strip leading zeros - hex strings", function() {
+        var testCases = [
+            {
+                value: "0x00009347",
+                expected: "0x9347"
+            },
+            {
+                value: "0x00185754",
+                expected: "0x185754"
+            },
+            {
+                value: "0x00000000005823",
+                expected: "0x5823"
+            }
         ];
-        values.forEach(function(value) {
-            expect(hexStripZeros(value)).toBe(ethers.hexStripZeros(value));
+        testCases.forEach(function(testCase) {
+            expect(hexStripZeros(testCase.value)).toBe(testCase.expected);
         });
     });
-    it("should match ethers.js - UInt8Array values", 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 correctly strip leading zeros - byte arrays", function() {
+        var testCases = [
+            {
+                value: new Uint8Array([
+                    0,
+                    0,
+                    0,
+                    9,
+                    58,
+                    29,
+                    24
+                ]),
+                expected: "0x93a1d18"
+            },
+            {
+                value: new Uint8Array([
+                    0,
+                    185,
+                    203
+                ]),
+                expected: "0xb9cb"
+            },
+            {
+                value: new Uint8Array([
+                    0,
+                    0,
+                    0,
+                    0,
+                    239,
+                    30,
+                    49,
+                    41,
+                    5,
+                    10,
+                    42
+                ]),
+                expected: "0xef1e3129050a2a"
+            }
         ];
-        values.forEach(function(value) {
-            expect(hexStripZeros(value)).toBe(ethers.hexStripZeros(value));
+        testCases.forEach(function(testCase) {
+            expect(hexStripZeros(testCase.value)).toBe(testCase.expected);
         });
     });
-    it("should throw error - invalid hex string", function() {
+    it("should throw error - invalid hex strings", function() {
         var values = [
             "non-hex string"
         ];

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

@@ -1,85 +1,141 @@
-import { utils as ethers } from "ethers";
 import { hexValue } from "../../bytes";
 import { tinyBig } from "./../../../shared/tiny-big/tiny-big";
 describe("utils.hexValue", function() {
-    it("should match ethers.js - hex string", function() {
-        var values = [
-            "0x9347",
-            "0x185754",
-            "0x00005823"
+    it("should correctly convert - hex string", function() {
+        var testCases = [
+            {
+                value: "0x9347",
+                expected: "0x9347"
+            },
+            {
+                value: "0x185754",
+                expected: "0x185754"
+            },
+            {
+                value: "0x00005823",
+                expected: "0x5823"
+            }
         ];
-        values.forEach(function(value) {
-            expect(hexValue(value)).toBe(ethers.hexValue(value));
+        testCases.forEach(function(testCase) {
+            expect(hexValue(testCase.value)).toStrictEqual(testCase.expected);
         });
     });
-    it("should match ethers.js - UInt8Array", function() {
-        var values = [
-            [
-                4,
-                50,
-                2
-            ],
-            [
-                231,
-                49,
-                40,
-                70,
-                19
-            ],
-            [
-                10,
-                68,
-                20,
-                98
-            ]
+    it("should correctly convert - byte array", function() {
+        var testCases = [
+            {
+                value: [
+                    4,
+                    50,
+                    2
+                ],
+                expected: "0x43202"
+            },
+            {
+                value: [
+                    231,
+                    49,
+                    40,
+                    70,
+                    19
+                ],
+                expected: "0xe731284613"
+            },
+            {
+                value: [
+                    10,
+                    68,
+                    20,
+                    98
+                ],
+                expected: "0xa441462"
+            }
         ];
-        values.forEach(function(value) {
-            expect(hexValue(value)).toBe(ethers.hexValue(value));
+        testCases.forEach(function(testCase) {
+            expect(hexValue(testCase.value)).toStrictEqual(testCase.expected);
         });
     });
-    it("should match ethers.js - TinyBig (hexable)", function() {
-        var values = [
-            tinyBig("29389"),
-            tinyBig(2834),
-            tinyBig(402)
+    it("should correctly convert - TinyBig instance", function() {
+        var testCases = [
+            {
+                value: tinyBig("29389"),
+                expected: "0x72cd"
+            },
+            {
+                value: tinyBig(2834),
+                expected: "0xb12"
+            },
+            {
+                value: tinyBig(402),
+                expected: "0x192"
+            }
         ];
-        values.forEach(function(value) {
-            expect(hexValue(value)).toBe(ethers.hexValue(value));
+        testCases.forEach(function(testCase) {
+            expect(hexValue(testCase.value)).toStrictEqual(testCase.expected);
         });
     });
-    it("should match ethers.js - number", function() {
-        var values = [
-            624,
-            457,
-            23451
+    it("should correctly convert - number", function() {
+        var testCases = [
+            {
+                value: 624,
+                expected: "0x270"
+            },
+            {
+                value: 457,
+                expected: "0x1c9"
+            },
+            {
+                value: 23451,
+                expected: "0x5b9b"
+            }
         ];
-        values.forEach(function(value) {
-            expect(hexValue(value)).toBe(ethers.hexValue(value));
+        testCases.forEach(function(testCase) {
+            expect(hexValue(testCase.value)).toStrictEqual(testCase.expected);
         });
     });
-    it("should match ethers.js - BigInt", function() {
-        var values = [
-            BigInt(204),
-            BigInt("23491"),
-            BigInt(4183459235723491)
+    it("should correctly convert - BigInt", function() {
+        var testCases = [
+            {
+                value: BigInt(204),
+                expected: "0xcc"
+            },
+            {
+                value: BigInt("23491"),
+                expected: "0x5bc3"
+            },
+            {
+                value: BigInt(4183459235723491),
+                expected: "0xedcd581ad78e3"
+            }
         ];
-        values.forEach(function(value) {
-            expect(hexValue(value)).toBe(ethers.hexValue(value));
+        testCases.forEach(function(testCase) {
+            expect(hexValue(testCase.value)).toStrictEqual(testCase.expected);
         });
     });
     it("should return 0x0 - only zero data given", function() {
-        var values = [
-            BigInt(0),
-            0,
-            "0x0000",
-            [
-                0,
-                0,
-                0
-            ]
+        var testCases = [
+            {
+                value: BigInt(0),
+                expected: "0x0"
+            },
+            {
+                value: 0,
+                expected: "0x0"
+            },
+            {
+                value: "0x0000",
+                expected: "0x0"
+            },
+            {
+                value: [
+                    0,
+                    0,
+                    0
+                ],
+                expected: "0x0"
+            }
         ];
-        values.forEach(function(value) {
-            expect(hexValue(value)).toBe("0x0");
+        testCases.forEach(function(testCase) {
+            expect(hexValue(testCase.value)).toStrictEqual(testCase.expected);
         });
     });
 });

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

@@ -1,35 +1,43 @@
-import * as ethers from "ethers";
 import { hexZeroPad } from "../../../";
 describe("hexZeroPad", function() {
-    it("numbers - matches ethers", function() {
-        var decimalValues = [
-            123,
-            0
+    it("should correctly pad - numbers", function() {
+        var testCases = [
+            {
+                value: 123,
+                expected: "0x000000000000000000000000000000000000007b"
+            },
+            {
+                value: 0,
+                expected: "0x0000000000000000000000000000000000000000"
+            }
         ];
-        decimalValues.forEach(function(decimalValue) {
-            expect(hexZeroPad(decimalValue, 30)).toStrictEqual(ethers.utils.hexZeroPad(decimalValue, 30));
+        testCases.forEach(function(testCase) {
+            expect(hexZeroPad(testCase.value, 20)).toStrictEqual(testCase.expected);
         });
     });
-    it("arrays of numbers - matches ethers", function() {
-        var decimalValues = [
-            [
-                1,
-                2,
-                3,
-                4
-            ]
+    it("should correctly pad - arrays of numbers", function() {
+        var testCases = [
+            {
+                value: [
+                    1,
+                    2,
+                    3,
+                    4
+                ],
+                expected: "0x000000000000000000000001020304"
+            }
         ];
-        decimalValues.forEach(function(decimalValue) {
-            expect(hexZeroPad(decimalValue, 30)).toStrictEqual(ethers.utils.hexZeroPad(decimalValue, 30));
+        testCases.forEach(function(testCase) {
+            expect(hexZeroPad(testCase.value, 15)).toStrictEqual(testCase.expected);
         });
     });
-    it("should reject strings passed in which are not hex strings", function() {
+    it("should throw error - non-hex string", function() {
         var value = "52908";
         expect(function() {
             hexZeroPad(value, 23);
         }).toThrow();
     });
-    it("should throw error when value is already longer than desired length", function() {
+    it("should throw error - values longer than desired length", function() {
         var hexValues = [
             0x123456,
             "0x5aAebAd",
@@ -42,21 +50,51 @@ describe("hexZeroPad", function() {
             }).toThrow();
         });
     });
-    it("should match ethers.js when padding can be applied", function() {
-        var values = [
-            10,
-            "0x5290",
-            "0x8617E3",
-            "0xde709f210",
-            "0x27b",
-            0x0,
-            0x5aaeb605,
-            "0xfB6916095ca1df",
-            "0xdbF03B407c01E7cD3CBea99509d93",
-            0xd1220a0cf4
+    it("should correctly pad - valid hex values", function() {
+        var testCases = [
+            {
+                value: 10,
+                expected: "0x00000000000000000000000000000a"
+            },
+            {
+                value: "0x5290",
+                expected: "0x000000000000000000000000005290"
+            },
+            {
+                value: "0x8617E3",
+                expected: "0x0000000000000000000000008617E3"
+            },
+            {
+                value: "0xde709f210",
+                expected: "0x000000000000000000000de709f210"
+            },
+            {
+                value: "0x27b",
+                expected: "0x00000000000000000000000000027b"
+            },
+            {
+                value: 0x0,
+                expected: "0x000000000000000000000000000000"
+            },
+            {
+                value: 0x5aaeb605,
+                expected: "0x00000000000000000000005aaeb605"
+            },
+            {
+                value: "0xfB6916095ca1df",
+                expected: "0x0000000000000000fB6916095ca1df"
+            },
+            {
+                value: "0xdbF03B407c01E7cD3CBea99509d93",
+                expected: "0x0dbF03B407c01E7cD3CBea99509d93"
+            },
+            {
+                value: 0xd1220a0cf4,
+                expected: "0x00000000000000000000d1220a0cf4"
+            }
         ];
-        values.forEach(function(value) {
-            expect(hexZeroPad(value, 30)).toStrictEqual(ethers.utils.hexZeroPad(value, 30));
+        testCases.forEach(function(testCase) {
+            expect(hexZeroPad(testCase.value, 15)).toStrictEqual(testCase.expected);
         });
     });
 });