essential-eth 0.9.1-next.0 → 0.9.1

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

@@ -1,51 +0,0 @@
-import { hexDataSlice } from "../../bytes";
-describe("utils.hexDataSlice", function() {
-    it("should match expected slice - hexadecimal strings", function() {
-        var hexValues = [
-            "0x123456"
-        ];
-        hexValues.forEach(function(hexValue) {
-            expect(hexDataSlice(hexValue, 0, 2)).toBe("0x1234");
-        });
-    });
-    it("should match expected slice -  hexadecimal numbers", function() {
-        var hexValues = [
-            0x1234567891011
-        ];
-        hexValues.forEach(function(hexValue) {
-            expect(hexDataSlice(hexValue, 3)).toBe("0x67891011");
-            expect(hexDataSlice(hexValue, 2, 4)).toBe("0x4567");
-            expect(hexDataSlice(hexValue, 100)).toBe("0x");
-        });
-    });
-    it("should match expected slice - arrays of decimal numbers", function() {
-        var decimalArrays = [
-            [
-                0,
-                1,
-                2,
-                3,
-                4,
-                5,
-                6,
-                7,
-                8,
-                9
-            ]
-        ];
-        decimalArrays.forEach(function(decimalArray) {
-            expect(hexDataSlice(decimalArray, 1, 2)).toBe("0x01");
-        });
-    });
-    it("should throw error - invalid hex data", function() {
-        var values = [
-            "non-hex string",
-            "0x938"
-        ];
-        values.forEach(function(value) {
-            expect(function() {
-                return hexDataSlice(value, 1, 3);
-            }).toThrow("invalid hexData");
-        });
-    });
-});

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

@@ -1,75 +0,0 @@
-import { hexStripZeros } from "../../bytes";
-describe("utils.hexStripZeros", function() {
-    it("should correctly strip leading zeros - hex strings", function() {
-        var testCases = [
-            {
-                value: "0x00009347",
-                expected: "0x9347"
-            },
-            {
-                value: "0x00185754",
-                expected: "0x185754"
-            },
-            {
-                value: "0x00000000005823",
-                expected: "0x5823"
-            }
-        ];
-        testCases.forEach(function(testCase) {
-            expect(hexStripZeros(testCase.value)).toBe(testCase.expected);
-        });
-    });
-    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"
-            }
-        ];
-        testCases.forEach(function(testCase) {
-            expect(hexStripZeros(testCase.value)).toBe(testCase.expected);
-        });
-    });
-    it("should throw error - invalid hex strings", function() {
-        var values = [
-            "non-hex string"
-        ];
-        values.forEach(function(value) {
-            expect(function() {
-                return hexStripZeros(value);
-            }).toThrow("invalid hex string");
-        });
-    });
-});

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

@@ -1,141 +0,0 @@
-import { hexValue } from "../../bytes";
-import { tinyBig } from "./../../../shared/tiny-big/tiny-big";
-describe("utils.hexValue", function() {
-    it("should correctly convert - hex string", function() {
-        var testCases = [
-            {
-                value: "0x9347",
-                expected: "0x9347"
-            },
-            {
-                value: "0x185754",
-                expected: "0x185754"
-            },
-            {
-                value: "0x00005823",
-                expected: "0x5823"
-            }
-        ];
-        testCases.forEach(function(testCase) {
-            expect(hexValue(testCase.value)).toStrictEqual(testCase.expected);
-        });
-    });
-    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"
-            }
-        ];
-        testCases.forEach(function(testCase) {
-            expect(hexValue(testCase.value)).toStrictEqual(testCase.expected);
-        });
-    });
-    it("should correctly convert - TinyBig instance", function() {
-        var testCases = [
-            {
-                value: tinyBig("29389"),
-                expected: "0x72cd"
-            },
-            {
-                value: tinyBig(2834),
-                expected: "0xb12"
-            },
-            {
-                value: tinyBig(402),
-                expected: "0x192"
-            }
-        ];
-        testCases.forEach(function(testCase) {
-            expect(hexValue(testCase.value)).toStrictEqual(testCase.expected);
-        });
-    });
-    it("should correctly convert - number", function() {
-        var testCases = [
-            {
-                value: 624,
-                expected: "0x270"
-            },
-            {
-                value: 457,
-                expected: "0x1c9"
-            },
-            {
-                value: 23451,
-                expected: "0x5b9b"
-            }
-        ];
-        testCases.forEach(function(testCase) {
-            expect(hexValue(testCase.value)).toStrictEqual(testCase.expected);
-        });
-    });
-    it("should correctly convert - BigInt", function() {
-        var testCases = [
-            {
-                value: BigInt(204),
-                expected: "0xcc"
-            },
-            {
-                value: BigInt("23491"),
-                expected: "0x5bc3"
-            },
-            {
-                value: BigInt(4183459235723491),
-                expected: "0xedcd581ad78e3"
-            }
-        ];
-        testCases.forEach(function(testCase) {
-            expect(hexValue(testCase.value)).toStrictEqual(testCase.expected);
-        });
-    });
-    it("should return 0x0 - only zero data given", function() {
-        var testCases = [
-            {
-                value: BigInt(0),
-                expected: "0x0"
-            },
-            {
-                value: 0,
-                expected: "0x0"
-            },
-            {
-                value: "0x0000",
-                expected: "0x0"
-            },
-            {
-                value: [
-                    0,
-                    0,
-                    0
-                ],
-                expected: "0x0"
-            }
-        ];
-        testCases.forEach(function(testCase) {
-            expect(hexValue(testCase.value)).toStrictEqual(testCase.expected);
-        });
-    });
-});

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

@@ -1,100 +0,0 @@
-import { hexZeroPad } from "../../../";
-describe("hexZeroPad", function() {
-    it("should correctly pad - numbers", function() {
-        var testCases = [
-            {
-                value: 123,
-                expected: "0x000000000000000000000000000000000000007b"
-            },
-            {
-                value: 0,
-                expected: "0x0000000000000000000000000000000000000000"
-            }
-        ];
-        testCases.forEach(function(testCase) {
-            expect(hexZeroPad(testCase.value, 20)).toStrictEqual(testCase.expected);
-        });
-    });
-    it("should correctly pad - arrays of numbers", function() {
-        var testCases = [
-            {
-                value: [
-                    1,
-                    2,
-                    3,
-                    4
-                ],
-                expected: "0x000000000000000000000001020304"
-            }
-        ];
-        testCases.forEach(function(testCase) {
-            expect(hexZeroPad(testCase.value, 15)).toStrictEqual(testCase.expected);
-        });
-    });
-    it("should throw error - non-hex string", function() {
-        var value = "52908";
-        expect(function() {
-            hexZeroPad(value, 23);
-        }).toThrow();
-    });
-    it("should throw error - values longer than desired length", function() {
-        var hexValues = [
-            0x123456,
-            "0x5aAebAd",
-            "0xfB691",
-            "0xD1220ab"
-        ];
-        hexValues.forEach(function(hexValue) {
-            expect(function() {
-                return hexZeroPad(hexValue, 2);
-            }).toThrow();
-        });
-    });
-    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"
-            }
-        ];
-        testCases.forEach(function(testCase) {
-            expect(hexZeroPad(testCase.value, 15)).toStrictEqual(testCase.expected);
-        });
-    });
-});

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

@@ -1,78 +0,0 @@
-import { hexlify } from "../../bytes";
-describe("utils.hexlify", function() {
-    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"
-            }
-        ];
-        testCases.forEach(function(testCase) {
-            expect(hexlify(testCase.value)).toBe(testCase.expected);
-        });
-    });
-    it("should hexlify with options - hexPad", function() {
-        var testCases = [
-            {
-                value: "0x3342e95",
-                options: {
-                    hexPad: "left"
-                },
-                expected: "0x03342e95"
-            },
-            {
-                value: "0x41c942c42",
-                options: {
-                    hexPad: "right"
-                },
-                expected: "0x41c942c420"
-            }
-        ];
-        testCases.forEach(function(testCase) {
-            expect(hexlify(testCase.value, testCase.options)).toBe(testCase.expected);
-        });
-    });
-    it("should throw error - hex data is odd-length", function() {
-        var values = [
-            "0x931",
-            "0x34414"
-        ];
-        values.forEach(function(value) {
-            expect(function() {
-                return hexlify(value);
-            }).toThrow("hex data is odd-length");
-        });
-    });
-    it("should throw error - invalid hexlify value", function() {
-        // @ts-expect-error
-        var values = [
-            "non-hex string",
-            false
-        ];
-        values.forEach(function(value) {
-            expect(function() {
-                return hexlify(value);
-            }).toThrow("invalid hexlify value");
-        });
-    });
-});

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

@@ -1,68 +0,0 @@
-import { isBytesLike } from "../../bytes";
-describe("utils.isBytesLike", function() {
-    it("should return true - hex string", function() {
-        var values = [
-            "0x9347",
-            "0x185754",
-            "0x00005823"
-        ];
-        values.forEach(function(value) {
-            expect(isBytesLike(value)).toBe(true);
-        });
-    });
-    it("should return true - UInt8Array", function() {
-        var values = [
-            [
-                9,
-                58,
-                29,
-                24
-            ],
-            [
-                185,
-                203
-            ],
-            [
-                239,
-                30,
-                49,
-                41,
-                5,
-                10,
-                42
-            ]
-        ];
-        values.forEach(function(value) {
-            expect(isBytesLike(value)).toBe(true);
-        });
-    });
-    it("should return false - number", function() {
-        var values = [
-            152,
-            513,
-            2354
-        ];
-        values.forEach(function(value) {
-            expect(isBytesLike(value)).toBe(false);
-        });
-    });
-    it("should return false - non-hex string", function() {
-        var values = [
-            "essential-eth",
-            "ethers.js",
-            "ethereum"
-        ];
-        values.forEach(function(value) {
-            expect(isBytesLike(value)).toBe(false);
-        });
-    });
-    it("should return false - boolean", function() {
-        var values = [
-            false,
-            true
-        ];
-        values.forEach(function(value) {
-            expect(isBytesLike(value)).toBe(false);
-        });
-    });
-});

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

@@ -1,76 +0,0 @@
-import { isBytes, isBytesLike } from "../../..";
-describe("isBytesLike", function() {
-    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
-            }
-        ];
-        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,97 +0,0 @@
-import { isHexString } from "../../bytes";
-describe("utils.isHexString", function() {
-    it("should return true - hex string", function() {
-        var values = [
-            "0x9347",
-            "0x185754",
-            "0x00005823"
-        ];
-        values.forEach(function(value) {
-            expect(isHexString(value)).toBe(true);
-        });
-    });
-    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
-            }
-        ];
-        testCases.forEach(function(testCase) {
-            expect(isHexString(testCase.value[0], testCase.value[1])).toBe(testCase.expected);
-        });
-    });
-    it("should return false - UInt8Array", function() {
-        var values = [
-            [
-                9,
-                58,
-                29,
-                24
-            ],
-            [
-                185,
-                203
-            ],
-            [
-                239,
-                30,
-                49,
-                41,
-                5,
-                10,
-                42
-            ]
-        ];
-        values.forEach(function(value) {
-            expect(isHexString(value)).toBe(false);
-        });
-    });
-    it("should return false - number", function() {
-        var values = [
-            152,
-            513,
-            2354
-        ];
-        values.forEach(function(value) {
-            expect(isHexString(value)).toBe(false);
-        });
-    });
-    it("should return false - non-hex string", function() {
-        var values = [
-            "essential-eth",
-            "ethers.js",
-            "\uD83D\uDC4B firek.eth was here hehe"
-        ];
-        values.forEach(function(value) {
-            expect(isHexString(value)).toBe(false);
-        });
-    });
-    it("should return false - boolean", function() {
-        var values = [
-            false,
-            true
-        ];
-        values.forEach(function(value) {
-            expect(isHexString(value)).toBe(false);
-        });
-    });
-});